@supernovaio/cli/dist/utils/ui/services/dependency-service.js

Supernova.io Command Line Interface

!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="e7e7ee13-690b-5beb-94b7-185abf4577d6")}catch(e){}}();
import { execFile as execFileCallback } from "node:child_process";
import fs from "node:fs";
import fsPromises from "node:fs/promises";
import path from "node:path";
import { promisify } from "node:util";
import inquirer from "inquirer";
import { fileExists } from "../../validate-templates.js";
import { NPM_TOKEN_NPMRC_LINE, TEMP_NPMRC_MARKER } from "../constants.js";
import { createPrivateDependencyEntries, resolveExactPrivatePackages, uniqueStrings } from "../helpers.js";
import { promptNpmToken } from "../steps/dependencies/prompts.js";
import { muted, renderFramedLines, success, warning } from "../ui.js";
const execFile = promisify(execFileCallback);
export function createDependencyService(input) {
    return {
        createPrivateDependencyEntries(packageNames) {
            return createPrivateDependencyEntries(packageNames);
        },
        async ensureLocalNpmrcFile(templateDestinationPath) {
            const npmrcPath = path.join(templateDestinationPath, ".npmrc");
            if (await fileExists(npmrcPath)) {
                const npmrc = await fsPromises.readFile(npmrcPath, "utf8");
                if (!npmrc.includes(NPM_TOKEN_NPMRC_LINE)) {
                    const prefix = npmrc.length > 0 && !npmrc.endsWith("\n") ? "\n" : "";
                    await fsPromises.writeFile(npmrcPath, `${npmrc}${prefix}${NPM_TOKEN_NPMRC_LINE}\n`, "utf8");
                }
            }
            else {
                await fsPromises.writeFile(npmrcPath, `${NPM_TOKEN_NPMRC_LINE}\n`, "utf8");
                await fsPromises.writeFile(path.join(templateDestinationPath, TEMP_NPMRC_MARKER), "", "utf8");
            }
            return npmrcPath;
        },
        async applyTemplateDependencyConfiguration(context) {
            if (!context.templateDestinationPath) {
                input.error("Template destination path is missing.");
            }
            const packageJsonPath = path.join(context.templateDestinationPath, "package.json");
            if (!fs.existsSync(packageJsonPath)) {
                input.error(`Template package.json was not found at ${packageJsonPath}`);
            }
            const raw = await fsPromises.readFile(packageJsonPath, "utf8");
            const packageJson = JSON.parse(raw);
            packageJson.dependencies = packageJson.dependencies ?? {};
            packageJson.supernova = packageJson.supernova ?? {};
            const exactPrivatePackages = resolveExactPrivatePackages(context);
            if (context.dependencyMode === "Public") {
                for (const packageName of context.dependencyPackageNames ?? []) {
                    packageJson.dependencies[packageName] = packageJson.dependencies[packageName] ?? "latest";
                }
            }
            else if (context.dependencyMode === "Private") {
                for (const packageName of exactPrivatePackages) {
                    packageJson.dependencies[packageName] = packageJson.dependencies[packageName] ?? "latest";
                }
                packageJson.supernova.privateDependencies = uniqueStrings(context.privateDependencyEntries ?? []);
            }
            if (packageJson.supernova && Object.keys(packageJson.supernova).length === 0) {
                delete packageJson.supernova;
            }
            const nextRaw = `${JSON.stringify(packageJson, null, 2)}\n`;
            if (nextRaw === raw) {
                return;
            }
            await fsPromises.writeFile(packageJsonPath, nextRaw, "utf8");
            input.log(success("Updated template package.json with dependency configuration."));
        },
        async validateTemplateDependencies(context) {
            if (!context.templateDestinationPath) {
                input.error("Template destination path is missing.");
            }
            if (context.dependencyMode === "Public" && !context.dependencyPackageNames?.length) {
                input.error("Public package names are missing.");
            }
            if (context.dependencyMode === "Private" && !context.privateDependencyEntries?.length) {
                input.error("Private dependency entries are missing.");
            }
            if (context.dependencyMode === "Private" && resolveExactPrivatePackages(context).length === 0) {
                input.error("Private package names are missing.");
            }
            if (context.dependencyMode === "Private" && !context.npmToken) {
                input.log(muted("NPM token is required again because setup sessions do not save private tokens."));
                context.npmToken = await promptNpmToken(input.error);
            }
            while (true) {
                input.log(muted("Running npm install to validate dependency access..."));
                try {
                    await execFile("npm", ["install", "--no-audit", "--no-fund"], {
                        cwd: context.templateDestinationPath,
                        env: context.npmToken ? { ...process.env, NPM_TOKEN: context.npmToken } : process.env,
                    });
                    input.log(success("Dependency access validated successfully."));
                    return;
                }
                catch (error) {
                    const message = error instanceof Error ? error.message : String(error);
                    input.log("");
                    input.log(warning(`Dependency validation failed: ${message}`));
                    if (context.dependencyMode === "Private") {
                        input.log("");
                        input.log(renderFramedLines([
                            "Dependency install failed - usually a missing or incorrect npm token.",
                            "Enter a new npm token and retry the validation step.",
                        ]));
                    }
                    const response = await inquirer.prompt([
                        {
                            choices: [
                                { name: "Retry dependency validation", value: "retry" },
                                ...(context.dependencyMode === "Private"
                                    ? [{ name: "Enter npm token again and retry", value: "retry_private_registry" }]
                                    : []),
                                { name: "Continue without dependency validation", value: "continue" },
                                { name: "Cancel setup", value: "cancel" },
                            ],
                            default: "retry",
                            message: "Next action:",
                            name: "action",
                            type: "list",
                        },
                    ]);
                    if (response.action === "continue") {
                        input.log(warning("Continuing without validated dependency access."));
                        return;
                    }
                    if (response.action === "cancel") {
                        input.error("Setup cancelled during dependency validation.");
                    }
                    if (response.action === "retry_private_registry") {
                        context.npmToken = await promptNpmToken(input.error);
                    }
                }
            }
        },
    };
}
//# sourceMappingURL=dependency-service.js.map
//# debugId=e7e7ee13-690b-5beb-94b7-185abf4577d6