@soapjs/cli 1.0.0

package/build/commands/create/create.command.js

@@ -0,0 +1,234 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCreateCommand = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const command_context_1 = require("../../core/command-context");
+const errors_1 = require("../../core/errors");
+const write_soap_config_1 = require("../../config/write-soap-config");
+const dependency_resolver_1 = require("../../dependencies/dependency-resolver");
+const package_manager_1 = require("../../dependencies/package-manager");
+const file_writer_1 = require("../../io/file-writer");
+const registry_service_1 = require("../../registry/registry.service");
+const common_options_1 = require("../shared/common-options");
+const project_plan_1 = require("./project-plan");
+const create_config_resolver_1 = require("../../resolvers/create-config.resolver");
+const prompts_1 = require("../../prompts");
+const summary_1 = require("../../summary");
+const presets_1 = require("../../presets");
+function registerCreateCommand(program) {
+    (0, common_options_1.addConflictOption)((0, common_options_1.addInteractiveOption)(program
+        .command("create <name>")
+        .description("Create a new SoapJS service project.")
+        .option("--framework <framework>", "framework adapter", "express")
+        .option("--architecture <architecture>", "architecture mode: regular, cqrs", "regular")
+        .option("--db <database>", "database capability: mongo, postgres, mysql, sqlite, redis, none", collect, [])
+        .option("--auth <auth>", "auth capability: jwt, api-key, local, none", collect, [])
+        .option("--messaging <messaging>", "messaging capability: in-memory, kafka, none", collect, [])
+        .option("--telemetry <telemetry>", "telemetry capability: logs, otel-noop, none", collect, [])
+        .option("--docs <docs>", "docs capability: openapi, none", collect, [])
+        .option("--contracts <contracts>", "contract capability: zod, none", collect, [])
+        .option("--api-client <client>", "api client capability: bruno, none", collect, [])
+        .option("--realtime <realtime>", "realtime capability: ws, none", collect, [])
+        .option("--zones <zones>", "comma-separated zones", "public,private,admin")
+        .option("--package-manager <manager>", "package manager: npm, pnpm, yarn, bun")
+        .option("--preset <preset>", "create preset")
+        .option("--skip-install", "do not install dependencies", false)
+        .option("--install", "install dependencies after generation", false)
+        .option("--git-init", "initialize a git repository after generation", false)
+        .option("--yes", "skip interactive confirmation prompts", false)
+        .option("--force", "overwrite generated files even when modified", false)
+        .option("--write-new", "write modified generated files as .new", false)))
+        .action(async (name, options, command) => {
+        const preset = (0, presets_1.resolveCreatePreset)(options.preset);
+        (0, common_options_1.assertInteractiveTerminal)(options);
+        const context = (0, command_context_1.getCommandContext)(command);
+        const root = (0, project_plan_1.targetRoot)(context.cwd, name);
+        if (options.framework !== "express") {
+            throw new errors_1.CliError("Only --framework express is supported in this MVP.");
+        }
+        if (options.architecture !== "regular" && options.architecture !== "cqrs") {
+            throw new errors_1.CliError("Architecture must be regular or cqrs.");
+        }
+        if (fs_1.default.existsSync(root) && !fs_1.default.statSync(root).isDirectory()) {
+            throw new errors_1.CliError(`Target path exists and is not a directory: ${root}`);
+        }
+        const prompt = options.interactive ? new prompts_1.InquirerPromptAdapter() : undefined;
+        const promptAnswers = prompt
+            ? await (0, prompts_1.promptCreateProject)(prompt, {
+                provided: createProvidedCreateOptions(command),
+                preset: preset?.config,
+            })
+            : undefined;
+        const resolved = create_config_resolver_1.createConfigResolver.resolve({
+            flags: createExplicitCreateFlags(options, command),
+            promptAnswers,
+            preset: preset?.config,
+        });
+        const packageManager = (0, package_manager_1.detectPackageManager)(root, resolved.packageManager);
+        const dependencies = (0, dependency_resolver_1.resolveDependencies)(resolved.capabilities);
+        const plan = {
+            name,
+            root,
+            framework: resolved.framework,
+            architecture: resolved.architecture,
+            packageManager,
+            capabilities: resolved.capabilities,
+            zones: resolved.zones,
+            dependencies,
+        };
+        const config = (0, project_plan_1.createSoapConfigBundle)(plan);
+        const files = (0, project_plan_1.createProjectFiles)(plan);
+        registerSoapConfigFiles(config);
+        if (options.interactive) {
+            context.output.info((0, summary_1.formatCreateSummary)(plan));
+            if (!options.yes) {
+                const confirmed = await prompt.confirm({
+                    message: "Generate project?",
+                    defaultValue: true,
+                });
+                if (!confirmed) {
+                    context.output.warn("Project generation aborted.");
+                    return;
+                }
+            }
+        }
+        if (context.dryRun) {
+            context.output.info(`Project: ${name}`);
+            context.output.info(`Target: ${root}`);
+            context.output.info(`Files: ${files.length + 4}`);
+        }
+        await (0, file_writer_1.writePlannedFiles)({
+            root,
+            files,
+            registry: config.registry,
+            force: options.force,
+            writeNew: options.writeNew,
+            onConflict: options.onConflict,
+        }, context);
+        await (0, write_soap_config_1.writeSoapConfig)(root, config, context);
+        const shouldInstall = Boolean(options.install || promptAnswers?.install);
+        const shouldGitInit = Boolean(options.gitInit || promptAnswers?.gitInit);
+        if (context.dryRun) {
+            if (shouldGitInit) {
+                context.output.info("Would initialize git repository.");
+            }
+            if (shouldInstall && !options.skipInstall) {
+                context.output.info(`Would run ${(0, package_manager_1.installCommand)(packageManager)}.`);
+            }
+        }
+        else {
+            if (shouldGitInit) {
+                await runPostCreateCommand({
+                    cwd: root,
+                    command: "git",
+                    args: ["init"],
+                    label: "git init",
+                    context,
+                });
+            }
+            if (shouldInstall && !options.skipInstall) {
+                const install = (0, package_manager_1.installCommandParts)(packageManager);
+                await runPostCreateCommand({
+                    cwd: root,
+                    command: install.command,
+                    args: install.args,
+                    label: (0, package_manager_1.installCommand)(packageManager),
+                    context,
+                });
+            }
+            else if (shouldInstall && options.skipInstall) {
+                context.output.warn("Skipping dependency installation because --skip-install was provided.");
+            }
+        }
+        context.output.success(`Created SoapJS project at ${path_1.default.relative(context.cwd, root) || root}`);
+    });
+}
+exports.registerCreateCommand = registerCreateCommand;
+function createProvidedCreateOptions(command) {
+    return {
+        framework: isCliOption(command, "framework"),
+        architecture: isCliOption(command, "architecture"),
+        db: isCliOption(command, "db"),
+        auth: isCliOption(command, "auth"),
+        messaging: isCliOption(command, "messaging"),
+        telemetry: isCliOption(command, "telemetry"),
+        docs: isCliOption(command, "docs"),
+        contracts: isCliOption(command, "contracts"),
+        apiClient: isCliOption(command, "apiClient"),
+        realtime: isCliOption(command, "realtime"),
+        zones: isCliOption(command, "zones"),
+        packageManager: isCliOption(command, "packageManager"),
+        install: isCliOption(command, "install") || isCliOption(command, "skipInstall"),
+        gitInit: isCliOption(command, "gitInit"),
+    };
+}
+function createExplicitCreateFlags(options, command) {
+    return {
+        framework: isCliOption(command, "framework") ? options.framework : undefined,
+        architecture: isCliOption(command, "architecture") ? options.architecture : undefined,
+        db: isCliOption(command, "db") ? options.db : undefined,
+        auth: isCliOption(command, "auth") ? options.auth : undefined,
+        messaging: isCliOption(command, "messaging") ? options.messaging : undefined,
+        telemetry: isCliOption(command, "telemetry") ? options.telemetry : undefined,
+        docs: isCliOption(command, "docs") ? options.docs : undefined,
+        contracts: isCliOption(command, "contracts") ? options.contracts : undefined,
+        apiClient: isCliOption(command, "apiClient") ? options.apiClient : undefined,
+        realtime: isCliOption(command, "realtime") ? options.realtime : undefined,
+        zones: isCliOption(command, "zones") ? options.zones : undefined,
+        packageManager: isCliOption(command, "packageManager") ? options.packageManager : undefined,
+    };
+}
+function isCliOption(command, name) {
+    return command.getOptionValueSource(name) === "cli";
+}
+function collect(value, previous) {
+    previous.push(value);
+    return previous;
+}
+async function runPostCreateCommand(options) {
+    options.context.output.info(`Running ${options.label}...`);
+    try {
+        await runCommand(options.command, options.args, options.cwd, options.context.silent);
+        options.context.output.success(`Finished ${options.label}.`);
+    }
+    catch (error) {
+        options.context.output.warn(`${options.label} failed: ${error.message}`);
+    }
+}
+function runCommand(command, args, cwd, silent) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, {
+            cwd,
+            stdio: silent ? "ignore" : "inherit",
+        });
+        child.on("error", (error) => {
+            reject(error);
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`${command} ${args.join(" ")} exited with code ${code ?? "unknown"}`));
+        });
+    });
+}
+function registerSoapConfigFiles(config) {
+    const entries = [
+        { path: ".soap/project.json", content: JSON.stringify(config.project, null, 2), type: "config" },
+        { path: ".soap/structure.json", content: JSON.stringify(config.structure, null, 2), type: "config" },
+        { path: ".soap/api.json", content: JSON.stringify(config.api, null, 2), type: "config" },
+    ];
+    for (const entry of entries) {
+        (0, registry_service_1.upsertGeneratedFile)(config.registry, {
+            path: entry.path,
+            type: entry.type,
+            hash: (0, registry_service_1.hashContent)(`${entry.content}\n`),
+        });
+    }
+}

package/build/commands/create/project-plan.d.ts

@@ -0,0 +1,44 @@
+import { PackageManager } from "../../core/command-context";
+import { ApiZone, Architecture, AuthCapability, ContractsCapability, DatabaseCapability, DocsCapability, MessagingCapability, ProjectCapabilities, RealtimeCapability, SoapApiConfig, SoapProjectConfig, SoapRegistryConfig, SoapStructureConfig, TelemetryCapability } from "../../config/schemas/types";
+import { ResolvedDependencies } from "../../dependencies/dependency-resolver";
+import { PlannedFile } from "../../io/file-writer";
+export interface ProjectPlan {
+    name: string;
+    root: string;
+    framework: "express";
+    architecture: Architecture;
+    packageManager: PackageManager;
+    capabilities: ProjectCapabilities;
+    zones: ApiZone[];
+    dependencies: ResolvedDependencies;
+}
+export interface ProjectConfigBundle {
+    project: SoapProjectConfig;
+    structure: SoapStructureConfig;
+    api: SoapApiConfig;
+    registry: SoapRegistryConfig;
+}
+export declare function createDefaultCapabilities(): ProjectCapabilities;
+export declare function createSoapConfigBundle(plan: ProjectPlan): ProjectConfigBundle;
+export declare function parseCsvOption<T extends string>(value: string | string[] | undefined, allowed: readonly T[]): T[];
+export declare const databaseOptions: DatabaseCapability[];
+export declare const authOptions: AuthCapability[];
+export declare const messagingOptions: MessagingCapability[];
+export declare const realtimeOptions: RealtimeCapability[];
+export declare const telemetryOptions: TelemetryCapability[];
+export declare const docsOptions: DocsCapability[];
+export declare const contractsOptions: ContractsCapability[];
+export declare const zonesOptions: ApiZone[];
+export declare function targetRoot(cwd: string, name: string): string;
+export declare function createProjectFiles(plan: ProjectPlan): PlannedFile[];
+export interface ResourceRegistration {
+    functionName: string;
+    importPath: string;
+}
+export declare function createResourcesTs(resources: ResourceRegistration[]): string;
+export interface ControllerRegistration {
+    className: string;
+    importPath: string;
+    spread?: boolean;
+}
+export declare function createControllersTs(controllers: ControllerRegistration[]): string;