Add bundle generation

.gitignore

@@ -6,4 +6,8 @@ node_modules/
 nodecg/
 
 # Test coverage output
-coverage/
+coverage/
+
+# IDEs / Text editors
+.idea/
+.vscode/

jest.config.js

@@ -3,5 +3,5 @@ module.exports = {
     testEnvironment: "node",
     // We don't want to test nodecg, and without including it jest fails because it includes a invalid json
     modulePathIgnorePatterns: ["/nodecg/"],
-    testMatch: ["<rootDir>/test/**/**.ts", "!**/testUtils.ts"],
+    testMatch: ["<rootDir>/test/**/*.ts", "!**/*.util.ts"],
 };

package.json

@@ -59,6 +59,7 @@
     "dependencies": {
         "axios": "^0.21.1",
         "chalk": "^4.1.0",
+        "code-block-writer": "^10.1.1",
         "find-up": "^5.0.0",
         "glob": "^7.1.6",
         "gunzip-maybe": "^1.4.2",

src/generate/extension.ts

@@ -0,0 +1,120 @@
+import CodeBlockWriter from "code-block-writer";
+import { getServiceClientName } from "../nodecgIOVersions";
+import { ProductionInstallation } from "../utils/installation";
+import { CodeLanguage, GenerationOptions } from "./prompt";
+import { writeBundleFile } from "./utils";
+
+interface ServiceNames {
+    name: string;
+    camelCase: string;
+    pascalCase: string;
+    clientName: string;
+    packageName: string;
+}
+
+function kebabCase2CamelCase(str: string): string {
+    const parts = str.split("-");
+    const capitalizedParts = parts.map((p, idx) => (idx === 0 ? p : p.charAt(0).toUpperCase() + p.slice(1)));
+    return capitalizedParts.join("");
+}
+
+function kebabCase2PascalCase(str: string): string {
+    const camelCase = kebabCase2CamelCase(str);
+    return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+}
+
+function getServiceNames(serviceBaseName: string, nodecgIOVersion: string): ServiceNames {
+    return {
+        name: serviceBaseName,
+        camelCase: kebabCase2CamelCase(serviceBaseName),
+        pascalCase: kebabCase2PascalCase(serviceBaseName),
+        clientName: getServiceClientName(serviceBaseName, nodecgIOVersion),
+        packageName: `nodecg-io-${serviceBaseName}`,
+    };
+}
+
+export async function genExtension(opts: GenerationOptions, install: ProductionInstallation): Promise<void> {
+    // Generate further information for each service which is needed to generate the bundle extension.
+    const services = opts.services.map((svc) => getServiceNames(svc, install.version));
+
+    const writer = new CodeBlockWriter();
+
+    genImport(writer, "requireService", opts.corePackage.name, opts.language);
+
+    if (opts.language === "typescript") {
+        genImport(writer, "NodeCG", "nodecg/types/server", opts.language);
+        // Service import statements
+        services.forEach((svc) => {
+            genImport(writer, svc.clientName, svc.packageName, opts.language);
+        });
+    }
+
+    // global nodecg function
+    writer.blankLine();
+    const nodecgVariableType = opts.language === "typescript" ? ": NodeCG" : "";
+    writer.write(`module.exports = function (nodecg${nodecgVariableType}) `).block(() => {
+        genLog(writer, `${opts.bundleName} bundle started.`);
+        writer.blankLine();
+
+        // requireService calls
+        services.forEach((svc) => genRequireServiceCall(writer, svc, opts.language));
+
+        // onAvailable and onUnavailable calls
+        services.forEach((svc) => {
+            writer.blankLine();
+            genOnAvailableCall(writer, svc);
+
+            writer.blankLine();
+            genOnUnavailableCall(writer, svc);
+        });
+    });
+
+    const fileExtension = opts.language === "typescript" ? "ts" : "js";
+    await writeBundleFile(writer.toString(), opts.bundlePath, "extension", `index.${fileExtension}`);
+}
+
+function genImport(writer: CodeBlockWriter, symbolToImport: string, packageName: string, lang: CodeLanguage) {
+    if (lang === "typescript") {
+        writer.write(`import { ${symbolToImport} } from `).quote(packageName).write(";");
+    } else if (lang === "javascript") {
+        writer.write(`const ${symbolToImport} = require(`).quote(packageName).write(`).${symbolToImport};`);
+    } else {
+        throw new Error("unsupported language: " + lang);
+    }
+
+    writer.write("\n");
+}
+
+function genLog(writer: CodeBlockWriter, logMessage: string) {
+    writer.write("nodecg.log.info(").quote(logMessage).write(");");
+}
+
+function genRequireServiceCall(writer: CodeBlockWriter, svc: ServiceNames, lang: CodeLanguage) {
+    writer.write(`const ${svc.camelCase} = requireService`);
+
+    if (lang === "typescript") {
+        // Add type parameter which is only needed in TypeScript
+        writer.write(`<${svc.clientName}>`);
+    }
+
+    writer.write(`(nodecg, `).quote(svc.name).write(");");
+}
+
+function genOnAvailableCall(writer: CodeBlockWriter, svc: ServiceNames) {
+    writer
+        .write(`${svc.camelCase}?.onAvailable(async (${svc.camelCase}Client) => `)
+        .inlineBlock(() => {
+            genLog(writer, `${svc.name} service has been updated.`);
+            writer.writeLine(`// You can now use the ${svc.name} client here.`);
+        })
+        .write(");");
+}
+
+function genOnUnavailableCall(writer: CodeBlockWriter, svc: ServiceNames) {
+    writer
+        .write(`${svc.camelCase}?.onUnavailable(() => `)
+        .inlineBlock(() => {
+            genLog(writer, `${svc.name} has been unset.`);
+        })
+        .write(");");
+}

src/generate/index.ts

@@ -0,0 +1,112 @@
+import { CommandModule } from "yargs";
+import * as fs from "fs";
+import { logger } from "../utils/log";
+import { directoryExists } from "../utils/fs";
+import { Installation, ProductionInstallation, readInstallInfo } from "../utils/installation";
+import { corePackages } from "../nodecgIOVersions";
+import { GenerationOptions, promptGenerationOpts } from "./prompt";
+import { runNpmBuild, runNpmInstall } from "../utils/npm";
+import { genExtension } from "./extension";
+import { findNodeCGDirectory, getNodeCGIODirectory } from "../utils/nodecgInstallation";
+import { genDashboard, genGraphic } from "./panel";
+import { genTsConfig } from "./tsConfig";
+import { writeBundleFile, yellowGenerateCommand, yellowInstallCommand } from "./utils";
+import { genPackageJson } from "./packageJson";
+
+export const generateModule: CommandModule = {
+    command: "generate",
+    describe: "generates nodecg bundles that use nodecg-io services",
+
+    handler: async () => {
+        try {
+            const nodecgDir = await findNodeCGDirectory();
+            logger.debug(`Detected nodecg installation at ${nodecgDir}.`);
+            const nodecgIODir = getNodeCGIODirectory(nodecgDir);
+            const install = await readInstallInfo(nodecgIODir);
+
+            // Will throw when install is not valid for generating bundles
+            if (!ensureValidInstallation(install)) return;
+
+            const opts = await promptGenerationOpts(nodecgDir, install);
+
+            await generateBundle(nodecgDir, opts, install);
+
+            logger.success(`Successfully generated bundle ${opts.bundleName}.`);
+        } catch (e) {
+            logger.error(`Couldn't generate bundle:\n${e.message ?? e.toString()}`);
+            process.exit(1);
+        }
+    },
+};
+
+/**
+ * Ensures that a installation can be used to generate bundles, meaning nodecg-io is actually installed,
+ * is not a dev install and has some services installed that can be used.
+ * Throws an error if the installation cannot be used to generate a bundle with an explanation.
+ */
+export function ensureValidInstallation(install: Installation | undefined): install is ProductionInstallation {
+    if (install === undefined) {
+        throw new Error(
+            "nodecg-io is not installed to your local nodecg install.\n" +
+                `Please install it first using this command: ${yellowInstallCommand}`,
+        );
+    } else if (install.dev) {
+        throw new Error(`You cannot use ${yellowGenerateCommand} together with a development installation.`);
+    } else if (install.packages.length <= corePackages.length) {
+        // just has core packages without any services installed.
+        throw new Error(
+            `You first need to have at least one service installed to generate a bundle.\n` +
+                `Please install a service using this command: ${yellowInstallCommand}`,
+        );
+    }
+
+    return true;
+}
+
+export async function generateBundle(
+    nodecgDir: string,
+    opts: GenerationOptions,
+    install: ProductionInstallation,
+): Promise<void> {
+    // Create dir if necessary
+    if (!(await directoryExists(opts.bundlePath))) {
+        await fs.promises.mkdir(opts.bundlePath);
+    }
+
+    // In case some re-executes the command in a already used bundle name we should not overwrite their stuff and error instead.
+    const filesInBundleDir = await fs.promises.readdir(opts.bundlePath);
+    if (filesInBundleDir.length > 0) {
+        throw new Error(
+            `Directory for bundle at ${opts.bundlePath} already exists and contains files.\n` +
+                "Please make sure that you don't have a bundle with the same name already.\n" +
+                `Also you cannot use this tool to add nodecg-io to a already existing bundle. It only supports generating new ones.`,
+        );
+    }
+
+    // All of these calls only generate files if they are set accordingly in the GenerationOptions
+    await genPackageJson(nodecgDir, opts);
+    await genTsConfig(opts);
+    await genGitIgnore(opts);
+    await genExtension(opts, install);
+    await genGraphic(opts);
+    await genDashboard(opts);
+    logger.info("Generated bundle successfully.");
+
+    logger.info("Installing dependencies...");
+    await runNpmInstall(opts.bundlePath, false);
+
+    // JavaScript does not to be compiled
+    if (opts.language === "typescript") {
+        logger.info("Compiling bundle...");
+        await runNpmBuild(opts.bundlePath);
+    }
+}
+
+async function genGitIgnore(opts: GenerationOptions): Promise<void> {
+    // When typescript we want to ignore compilation results.
+    const languageIgnoredFiles = opts.language === "typescript" ? ["/extension/*.js", "/extension/*.js.map"] : [];
+    // Usual editors and node_modules directory
+    const ignoreEntries = ["/node_modules/", "/.vscode/", "/.idea/", ...languageIgnoredFiles];
+    const content = ignoreEntries.join("\n");
+    await writeBundleFile(content, opts.bundlePath, ".gitignore");
+}