azure-sdk-for-js/.scripts

/**
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License. See License.txt in the project root for
 * license information.
 */

import { promises as fs } from "fs";
import * as glob from "glob";
import * as yaml from "js-yaml";
import * as path from "path";
import { SdkType } from "./commandLine";
import { contains, pathExists, startsWith } from "./common";
import { Logger } from "./logger";

const _logger = Logger.get();

interface ReadmeSettings {
    "nodejs": {
        "azure-arm": boolean;
        "license-header": string;
        "payload-flattening-threshold": number;
        "package-name": string;
        "output-folder": string;
        "generate-license-txt": boolean | undefined;
        "generate-package-json": boolean | undefined;
        "generate-readme-md": boolean | undefined;
        "generate-metadata": boolean | undefined;
    } | undefined;
}

export async function getPackageFolderPathFromPackageArgument(packageName: string, azureRestAPISpecsRoot: string, azureSDKForJSRepoRoot: string): Promise<string | undefined> {
    let packageFolderPath: string | undefined;

    if (!packageName) {
        _logger.logError(`No --package specified.`);
    } else {
        const typeScriptReadmeFilePaths: string[] = findReadmeTypeScriptMdFilePaths(azureRestAPISpecsRoot);
        _logger.logTrace(`Found ${typeScriptReadmeFilePaths.length} readmes in ${azureRestAPISpecsRoot}`)

        let foundPackage = false;

        for (let i = 0; i < typeScriptReadmeFilePaths.length; ++i) {
            const typeScriptReadmeFilePath: string = typeScriptReadmeFilePaths[i];

            const typeScriptReadmeFileContents: string = await fs.readFile(typeScriptReadmeFilePath, 'utf8');
            const packageNames: string[] = getPackageNamesFromReadmeTypeScriptMdFileContents(typeScriptReadmeFileContents);
            _logger.logTrace(`Found [${packageNames}] package names`);

            if (contains(packageNames, packageName)) {
                foundPackage = true;
                packageFolderPath = getAbsolutePackageFolderPathFromReadmeFileContents(azureSDKForJSRepoRoot, typeScriptReadmeFileContents);
            }
        }

        if (!foundPackage) {
            _logger.logError(`No package found with the name "${packageName}".`);
        }
    }

    return packageFolderPath;
}

export async function getYamlSection(buffer: Buffer, sectionBeginning: string, sectionEnd: string): Promise<Buffer> {
    const beginningIndex = buffer.indexOf(sectionBeginning);
    const trimmedBuffer = buffer.slice(beginningIndex + (sectionBeginning.length));

    const endIndex = trimmedBuffer.indexOf(sectionEnd, 3);
    const sectionBuffer = trimmedBuffer.slice(0, endIndex);

    return sectionBuffer;
}

export async function doesReadmeMdFileSpecifiesTypescriptSdk(readmeMdPath: string): Promise<boolean> {
    const readmeMdBuffer = await fs.readFile(readmeMdPath);
    const sectionBuffer = await getYamlSection(readmeMdBuffer, "``` yaml $(swagger-to-sdk)", "```");

    if (sectionBuffer.includes("azure-sdk-for-js")) {
        return true;
    }

    return false;
}

export async function copyExistingNodeJsReadme(sdkPath: string): Promise<string> {
    const nodeJsReadmePath = path.resolve(sdkPath, "readme.nodejs.md");
    if (!(await pathExists(nodeJsReadmePath))) {
        return Promise.reject(`${nodeJsReadmePath} doesn't exists`)
    }

    const typescriptReadmePath = path.resolve(sdkPath, "readme.typescript.md");
    _logger.logDebug(`Copying ${nodeJsReadmePath} to ${typescriptReadmePath}`)

    if (await pathExists(typescriptReadmePath)) {
        return Promise.reject(`${typescriptReadmePath} file already exists`)
    }

    await fs.copyFile(nodeJsReadmePath, typescriptReadmePath);
    return typescriptReadmePath;
}

export async function getSinglePackageName(typescriptReadmePath: string): Promise<string> {
    const readmeBuffer: Buffer = await fs.readFile(typescriptReadmePath);
    const yamlSectionBuffer = await getYamlSection(readmeBuffer, "``` yaml $(typescript)", "```");
    const yamlSectionText = yamlSectionBuffer.toString();
    const yamlSection:any = yaml.safeLoad(yamlSectionText);
    return yamlSection["typescript"]["package-name"];
}

async function updatePackageName(settings: ReadmeSettings, sdkType: SdkType): Promise<ReadmeSettings> {
    if (settings.nodejs) {
        let packageName: string = settings.nodejs["package-name"]
        if (packageName.startsWith("azure-")) {
            packageName = packageName.replace("azure-", "");
        }

        if (sdkType == SdkType.ResourceManager && !packageName.startsWith("arm-")) {
            packageName = `arm-${packageName}`
        }

        settings.nodejs["package-name"] = `"@azure/${packageName}"`
    }
    return settings;
}

async function updateMetadataFields(settings: ReadmeSettings): Promise<ReadmeSettings> {
    if (settings.nodejs) {
        settings.nodejs["generate-metadata"] = true;
        delete settings.nodejs["generate-license-txt"]
        delete settings.nodejs["generate-package-json"]
        delete settings.nodejs["generate-readme-md"];
    }

    return settings;
}

function stripExtraQuotes(text: string): string {
    return text.replace(/'/g, "");
}

async function updateOutputFolder(settings: ReadmeSettings): Promise<ReadmeSettings> {
    if (settings.nodejs) {
        const outputName: string = settings.nodejs["package-name"].replace(/"/g, "");
        settings.nodejs["output-folder"] = `"$(typescript-sdks-folder)/packages/${outputName}"`;
    }
    return settings;
}

async function updateYamlSection(sectionText: string, sdkType: SdkType): Promise<string> {
    const section: any = yaml.safeLoad(sectionText);
    await updatePackageName(section, sdkType);
    await updateMetadataFields(section);
    await updateOutputFolder(section);
    section["typescript"] = section.nodejs;
    delete section.nodejs;

    return yaml.safeDump(section).trim();
}

export async function updateTypeScriptReadmeFile(typescriptReadmePath: string, sdkType: SdkType): Promise<string> {
    const readmeBuffer: Buffer = await fs.readFile(typescriptReadmePath);
    let outputReadme: string = readmeBuffer.toString();

    const yamlSection = await getYamlSection(readmeBuffer, "``` yaml $(nodejs)", "```");
    const sectionText = yamlSection.toString().trim();
    let updatedYamlSection = await updateYamlSection(sectionText, sdkType);
    updatedYamlSection = stripExtraQuotes(updatedYamlSection);

    outputReadme = outputReadme.replace(sectionText, updatedYamlSection);
    outputReadme = outputReadme.replace("azure-sdk-for-node", "azure-sdk-for-js");
    outputReadme = outputReadme.replace("Node.js", "TypeScript");
    outputReadme = outputReadme.replace("$(nodejs)", "$(typescript)");
    outputReadme = outputReadme.replace("nodejs", "typescript");
    outputReadme = outputReadme.replace("Node", "TypeScript");
    outputReadme = outputReadme.replace("node", "typescript");

    return outputReadme;
}

export async function updateMainReadmeFile(readmeFilePath: string) {
    const readmeBuffer: Buffer = await fs.readFile(readmeFilePath);
    let outputReadme: string = readmeBuffer.toString();

    const yamlSection = await getYamlSection(readmeBuffer, "``` yaml $(swagger-to-sdk)", "```");
    const sectionText = yamlSection.toString().trim();

    let lines = sectionText.split("\r\n");
    let nodeLineIndex = lines.findIndex(el => el.includes("- repo: azure-sdk-for-node"));

    if (nodeLineIndex == -1) {
        lines.push("  - repo: azure-sdk-for-node");
        nodeLineIndex = lines.length - 1;
    }

    const nodeLine = lines[nodeLineIndex];
    lines.splice(nodeLineIndex, 0, nodeLine.replace("node", "js"));
    const updatedYamlSection = lines.join("\r\n");

    outputReadme = outputReadme.replace(sectionText, updatedYamlSection);
    return outputReadme;
}

export function getPackageNamesFromReadmeTypeScriptMdFileContents(readmeTypeScriptMdFileContents: string): string[] {
    const packageNamePattern: RegExp = /package-name: (\S*)/g;
    const matches: string[] = readmeTypeScriptMdFileContents.match(packageNamePattern) || [];
    _logger.logTrace(`"package-name" matches: ${JSON.stringify(matches)}`);

    for (let i = 0; i < matches.length; ++i) {
        matches[i] = matches[i].substring("package-name: ".length);
    }

    const trimmedMatches = matches.map(match => match.replace(/\"/g, ""));
    _logger.logTrace(`"package-name" matches trimmed: ${JSON.stringify(trimmedMatches)}`);
    return trimmedMatches;
}

export function findReadmeTypeScriptMdFilePaths(azureRestAPISpecsRoot: string): string[] {
    _logger.logDebug(`Looking for "readme.typescript.md" files in "${azureRestAPISpecsRoot}"...`);

    const specificationFolderPath: string = path.resolve(azureRestAPISpecsRoot, 'specification');
    const readmeTypeScriptMdFilePaths: string[] = glob.sync(
        '**/readme.typescript.md',
        { absolute: true, cwd: specificationFolderPath }
    );
    if (readmeTypeScriptMdFilePaths) {
        for (let i = 0; i < readmeTypeScriptMdFilePaths.length; ++i) {
            const readmeTypeScriptMdFilePath: string = readmeTypeScriptMdFilePaths[i];
            _logger.logTrace(`  Found "${readmeTypeScriptMdFilePath}".`);

            if (readmeTypeScriptMdFilePath && !startsWith(readmeTypeScriptMdFilePath, specificationFolderPath)) {
                const resolvedReadmeTypeScriptMdFilePath: string = path.resolve(specificationFolderPath, readmeTypeScriptMdFilePath);
                _logger.logTrace(`    Updating to "${resolvedReadmeTypeScriptMdFilePath}".`);
                readmeTypeScriptMdFilePaths[i] = resolvedReadmeTypeScriptMdFilePath;
            }
        }
    }
    return readmeTypeScriptMdFilePaths;
}

export function getOutputFolderFromReadmeTypeScriptMdFileContents(readmeTypeScriptMdFileContents: string): string | undefined {
    const regExpMatch: RegExpMatchArray | null = readmeTypeScriptMdFileContents.match(/output-folder: (\S*)/);
    return regExpMatch && regExpMatch.length >= 1 ? regExpMatch[1].replace(/\"/g, "") : undefined;
}

export function getAbsolutePackageFolderPathFromReadmeFileContents(
    azureSDKForJSRepoRoot: string,
    typeScriptReadmeFileContents: string,
): string | undefined {
    const outputFolderPath: string | undefined = getOutputFolderFromReadmeTypeScriptMdFileContents(typeScriptReadmeFileContents);
    return !outputFolderPath ? outputFolderPath : outputFolderPath.replace("$(typescript-sdks-folder)", azureSDKForJSRepoRoot);
}