@soapjs/cli 1.0.0

package/build/io/conflict-policy.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conflictPolicyHelp = exports.resolveConflictPolicy = exports.parseConflictPolicy = void 0;
+const errors_1 = require("../core/errors");
+const conflictPolicies = ["ask", "skip", "overwrite", "new", "abort"];
+function parseConflictPolicy(value) {
+    if (!conflictPolicies.includes(value)) {
+        throw new errors_1.CliError(`Unsupported conflict policy "${value}". Allowed values: ${conflictPolicies.join(", ")}.`);
+    }
+    return value;
+}
+exports.parseConflictPolicy = parseConflictPolicy;
+function resolveConflictPolicy(options = {}) {
+    if (options.onConflict) {
+        return parseConflictPolicy(options.onConflict);
+    }
+    if (options.force) {
+        return "overwrite";
+    }
+    if (options.writeNew) {
+        return "new";
+    }
+    if (options.skipModified) {
+        return "skip";
+    }
+    return "abort";
+}
+exports.resolveConflictPolicy = resolveConflictPolicy;
+function conflictPolicyHelp() {
+    return conflictPolicies.join(", ");
+}
+exports.conflictPolicyHelp = conflictPolicyHelp;

package/build/io/file-writer.d.ts

@@ -0,0 +1,19 @@
+import { CommandContext } from "../core/command-context";
+import { GeneratedFileType, SoapRegistryConfig } from "../config/schemas/types";
+export interface PlannedFile {
+    path: string;
+    type: GeneratedFileType;
+    content: string;
+    owner?: string;
+    executable?: boolean;
+}
+export interface WriteFilesOptions {
+    root: string;
+    files: PlannedFile[];
+    registry: SoapRegistryConfig;
+    force?: boolean;
+    writeNew?: boolean;
+    skipModified?: boolean;
+    onConflict?: string;
+}
+export declare function writePlannedFiles(options: WriteFilesOptions, context: CommandContext): Promise<void>;

package/build/io/file-writer.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writePlannedFiles = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const registry_service_1 = require("../registry/registry.service");
+const errors_1 = require("../core/errors");
+const conflict_policy_1 = require("./conflict-policy");
+const format_file_1 = require("./format-file");
+async function writePlannedFiles(options, context) {
+    const conflictPolicy = (0, conflict_policy_1.resolveConflictPolicy)(options);
+    for (const file of options.files) {
+        const formatted = (0, format_file_1.formatFile)(file.path, file.content);
+        let targetPath;
+        try {
+            targetPath = await (0, registry_service_1.assertCanWriteGeneratedFile)(options.root, file.path, options.registry, {
+                force: conflictPolicy === "overwrite",
+                writeNew: conflictPolicy === "new",
+            });
+        }
+        catch (error) {
+            if (conflictPolicy === "skip" && error instanceof errors_1.CliError) {
+                context.output.warn(`Skipped modified file ${file.path}. Use --force to overwrite or --write-new to write ${file.path}.new.`);
+                continue;
+            }
+            if (conflictPolicy === "ask" && error instanceof errors_1.CliError) {
+                throw new errors_1.CliError(`Interactive conflict resolution is not available yet for ${file.path}. Use --on-conflict skip, overwrite, new, or abort.`);
+            }
+            throw error;
+        }
+        const originalPath = path_1.default.join(options.root, file.path);
+        const writesOriginalPath = targetPath === originalPath;
+        if (context.dryRun) {
+            context.output.info(`[dry-run] write ${targetPath}`);
+            if (writesOriginalPath) {
+                await (0, registry_service_1.registerGeneratedFile)({
+                    root: options.root,
+                    relativePath: file.path,
+                    type: file.type,
+                    owner: file.owner,
+                    registry: options.registry,
+                }, formatted, context);
+            }
+            continue;
+        }
+        await promises_1.default.mkdir(path_1.default.dirname(targetPath), { recursive: true });
+        await promises_1.default.writeFile(targetPath, formatted, "utf8");
+        if (file.executable) {
+            await promises_1.default.chmod(targetPath, 0o755);
+        }
+        if (writesOriginalPath) {
+            await (0, registry_service_1.registerGeneratedFile)({
+                root: options.root,
+                relativePath: file.path,
+                type: file.type,
+                owner: file.owner,
+                registry: options.registry,
+            }, formatted, context);
+        }
+    }
+}
+exports.writePlannedFiles = writePlannedFiles;

package/build/io/format-file.d.ts

@@ -0,0 +1 @@
+export declare function formatFile(filePath: string, content: string): string;

package/build/io/format-file.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFile = void 0;
+function formatFile(filePath, content) {
+    if (filePath.endsWith(".json")) {
+        return `${JSON.stringify(JSON.parse(content), null, 2)}\n`;
+    }
+    if (filePath.endsWith(".md") || filePath.endsWith(".ts") || filePath.endsWith(".js")) {
+        return content.endsWith("\n") ? content : `${content}\n`;
+    }
+    return content.endsWith("\n") ? content : `${content}\n`;
+}
+exports.formatFile = formatFile;

package/build/presets/create-presets.d.ts

@@ -0,0 +1,4 @@
+import { CreatePreset } from "./preset.types";
+export declare const createPresets: CreatePreset[];
+export declare function resolveCreatePreset(name: string | undefined): CreatePreset | undefined;
+export declare function formatCreatePresetNames(): string;

package/build/presets/create-presets.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCreatePresetNames = exports.resolveCreatePreset = exports.createPresets = void 0;
+const errors_1 = require("../core/errors");
+exports.createPresets = [
+    {
+        name: "express-mongo-api",
+        description: "Express API with MongoDB, JWT auth, OpenAPI docs, and Bruno requests.",
+        config: {
+            framework: "express",
+            architecture: "regular",
+            capabilities: {
+                databases: ["mongo"],
+                auth: ["jwt"],
+                messaging: ["in-memory"],
+                realtime: [],
+                telemetry: ["logs"],
+                docs: ["openapi"],
+                contracts: [],
+                apiClient: ["bruno"],
+            },
+            zones: ["public", "private", "admin"],
+        },
+    },
+    {
+        name: "express-postgres-api",
+        description: "Express API with PostgreSQL, JWT auth, OpenAPI docs, and Bruno requests.",
+        config: {
+            framework: "express",
+            architecture: "regular",
+            capabilities: {
+                databases: ["postgres"],
+                auth: ["jwt"],
+                messaging: ["in-memory"],
+                realtime: [],
+                telemetry: ["logs"],
+                docs: ["openapi"],
+                contracts: [],
+                apiClient: ["bruno"],
+            },
+            zones: ["public", "private", "admin"],
+        },
+    },
+    {
+        name: "express-cqrs-kafka-api",
+        description: "Express CQRS API with PostgreSQL, Kafka, JWT auth, OpenAPI docs, and Bruno requests.",
+        config: {
+            framework: "express",
+            architecture: "cqrs",
+            capabilities: {
+                databases: ["postgres"],
+                auth: ["jwt"],
+                messaging: ["kafka"],
+                realtime: [],
+                telemetry: ["logs"],
+                docs: ["openapi"],
+                contracts: [],
+                apiClient: ["bruno"],
+            },
+            zones: ["public", "private", "admin"],
+        },
+    },
+    {
+        name: "express-full-demo",
+        description: "Express demo API with MongoDB, PostgreSQL, JWT, API key, Kafka, WebSocket, OpenAPI, and Bruno.",
+        config: {
+            framework: "express",
+            architecture: "cqrs",
+            capabilities: {
+                databases: ["mongo", "postgres"],
+                auth: ["jwt", "api-key"],
+                messaging: ["kafka"],
+                realtime: ["ws"],
+                telemetry: ["logs", "otel-noop"],
+                docs: ["openapi"],
+                contracts: [],
+                apiClient: ["bruno"],
+            },
+            zones: ["public", "private", "admin"],
+        },
+    },
+];
+function resolveCreatePreset(name) {
+    if (!name) {
+        return undefined;
+    }
+    const preset = exports.createPresets.find((candidate) => candidate.name === name);
+    if (!preset) {
+        throw new errors_1.CliError(`Unknown create preset "${name}". Available presets: ${formatCreatePresetNames()}.`);
+    }
+    return preset;
+}
+exports.resolveCreatePreset = resolveCreatePreset;
+function formatCreatePresetNames() {
+    return exports.createPresets.map((preset) => preset.name).join(", ");
+}
+exports.formatCreatePresetNames = formatCreatePresetNames;

package/build/presets/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./create-presets";
+export * from "./preset.types";

package/build/presets/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./create-presets"), exports);
+__exportStar(require("./preset.types"), exports);

package/build/presets/preset.types.d.ts

@@ -0,0 +1,6 @@
+import { CreateConfigResult } from "../resolvers/create-config.resolver";
+export interface CreatePreset {
+    name: string;
+    description: string;
+    config: Partial<CreateConfigResult>;
+}

package/build/presets/preset.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/prompts/add-resource.prompt.d.ts

@@ -0,0 +1,13 @@
+import { SoapConfig } from "../config/schemas/types";
+import { AddResourceInput } from "../resolvers/add-resource.resolver";
+import { PromptAdapter } from "./prompt-adapter";
+export interface AddResourcePromptAnswers extends AddResourceInput {
+    bruno?: boolean;
+    enableBruno?: boolean;
+    dryRunFirst?: boolean;
+}
+export interface AddResourcePromptOptions {
+    config: SoapConfig;
+    provided: Partial<Record<keyof AddResourcePromptAnswers, boolean>>;
+}
+export declare function promptAddResource(prompt: PromptAdapter, options: AddResourcePromptOptions): Promise<AddResourcePromptAnswers>;

package/build/prompts/add-resource.prompt.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptAddResource = void 0;
+async function promptAddResource(prompt, options) {
+    const answers = {};
+    const config = options.config;
+    if (!options.provided.crud) {
+        answers.crud = await prompt.confirm({
+            message: "Generate CRUD routes",
+            defaultValue: true,
+        });
+    }
+    if (!options.provided.db) {
+        answers.db = await prompt.select({
+            message: "Storage",
+            choices: createDatabaseChoices(config),
+            defaultValue: config.project.capabilities.databases[0] ?? "none",
+        });
+    }
+    if (!options.provided.auth) {
+        answers.auth = await prompt.select({
+            message: "Route auth",
+            choices: createAuthChoices(config),
+            defaultValue: defaultRouteAuth(config.project.capabilities.auth),
+        });
+    }
+    if (!options.provided.zone) {
+        answers.zone = await prompt.select({
+            message: "API zone",
+            choices: config.project.zones.map((zone) => ({ label: zone, value: zone })),
+            defaultValue: config.project.zones.includes("public") ? "public" : config.project.zones[0],
+        });
+    }
+    const brunoEnabled = config.project.capabilities.apiClient.includes("bruno") || config.api.bruno.enabled;
+    if (brunoEnabled && !options.provided.bruno) {
+        answers.bruno = await prompt.confirm({
+            message: "Generate Bruno requests",
+            defaultValue: true,
+        });
+    }
+    if (!brunoEnabled && !options.provided.enableBruno) {
+        answers.enableBruno = await prompt.confirm({
+            message: "Enable Bruno now",
+            defaultValue: false,
+        });
+    }
+    if (!options.provided.dryRunFirst) {
+        answers.dryRunFirst = await prompt.confirm({
+            message: "Run as dry-run first",
+            defaultValue: false,
+        });
+    }
+    return answers;
+}
+exports.promptAddResource = promptAddResource;
+function createDatabaseChoices(config) {
+    return [
+        { label: "None", value: "none" },
+        ...config.project.capabilities.databases.map((database) => ({ label: database, value: database })),
+    ];
+}
+function createAuthChoices(config) {
+    const choices = [{ label: "None", value: "none" }];
+    if (config.project.capabilities.auth.includes("jwt") || config.project.capabilities.auth.includes("local")) {
+        choices.push({ label: "JWT", value: "jwt" });
+    }
+    if (config.project.capabilities.auth.includes("api-key")) {
+        choices.push({ label: "API key", value: "api-key" });
+    }
+    return choices;
+}
+function defaultRouteAuth(values) {
+    if (values.includes("jwt") || values.includes("local")) {
+        return "jwt";
+    }
+    if (values.includes("api-key")) {
+        return "api-key";
+    }
+    return "none";
+}

package/build/prompts/add-route.prompt.d.ts

@@ -0,0 +1,16 @@
+import { ResourceRegistryEntry, SoapConfig } from "../config/schemas/types";
+import { AddRouteInput } from "../resolvers/add-route.resolver";
+import { PromptAdapter } from "./prompt-adapter";
+export interface AddRoutePromptAnswers extends AddRouteInput {
+    resourceName?: string;
+    name?: string;
+    bruno?: boolean;
+}
+export interface AddRoutePromptOptions {
+    config: SoapConfig;
+    resource?: ResourceRegistryEntry;
+    resourceName?: string;
+    routeName?: string;
+    provided: Partial<Record<keyof AddRoutePromptAnswers, boolean>>;
+}
+export declare function promptAddRoute(prompt: PromptAdapter, options: AddRoutePromptOptions): Promise<AddRoutePromptAnswers>;

package/build/prompts/add-route.prompt.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptAddRoute = void 0;
+const route_plan_1 = require("../commands/add/route-plan");
+const naming_1 = require("../templates/naming");
+async function promptAddRoute(prompt, options) {
+    const answers = {};
+    const config = options.config;
+    const resource = options.resource ?? await promptForResource(prompt, config, options.provided.resourceName);
+    const routeName = options.routeName ?? await promptForRouteName(prompt, options.provided.name);
+    if (!options.resourceName) {
+        answers.resourceName = resource.name;
+    }
+    if (!options.routeName) {
+        answers.name = routeName;
+    }
+    if (!options.provided.method) {
+        answers.method = await prompt.select({
+            message: "HTTP method",
+            choices: route_plan_1.routeMethods.map((method) => ({ label: method.toUpperCase(), value: method })),
+            defaultValue: "get",
+        });
+    }
+    if (!options.provided.path) {
+        answers.path = await prompt.input({
+            message: "Route path",
+            defaultValue: (0, naming_1.createNameVariants)(routeName).kebabName,
+        });
+    }
+    if (!options.provided.zone) {
+        answers.zone = await prompt.select({
+            message: "API zone",
+            choices: config.project.zones.map((zone) => ({ label: zone, value: zone })),
+            defaultValue: resource.zone,
+        });
+    }
+    if (!options.provided.auth) {
+        answers.auth = await prompt.select({
+            message: "Route auth",
+            choices: createAuthChoices(config),
+            defaultValue: defaultRouteAuth(resource.auth, config.project.capabilities.auth),
+        });
+    }
+    if (!options.provided.useCase && !options.provided.command && !options.provided.query) {
+        const target = await prompt.select({
+            message: "Route target",
+            choices: createTargetChoices(config),
+            defaultValue: "direct",
+        });
+        if (target === "use-case") {
+            answers.useCase = await prompt.input({
+                message: "Use case name",
+                defaultValue: routeName,
+            });
+        }
+        if (target === "command") {
+            answers.command = await prompt.input({
+                message: "Command name",
+                defaultValue: routeName,
+            });
+        }
+        if (target === "query") {
+            answers.query = await prompt.input({
+                message: "Query name",
+                defaultValue: routeName,
+            });
+        }
+    }
+    const brunoEnabled = config.project.capabilities.apiClient.includes("bruno") || config.api.bruno.enabled;
+    if (brunoEnabled && !options.provided.bruno) {
+        answers.bruno = await prompt.confirm({
+            message: "Generate Bruno request",
+            defaultValue: true,
+        });
+    }
+    return answers;
+}
+exports.promptAddRoute = promptAddRoute;
+async function promptForResource(prompt, config, provided) {
+    if (provided) {
+        throw new Error("Resource was marked as provided but no resource entry was passed.");
+    }
+    const value = await prompt.select({
+        message: "Resource",
+        choices: config.registry.resources.map((resource) => ({
+            label: `${resource.name} (${resource.path})`,
+            value: resource.name,
+        })),
+    });
+    const resource = config.registry.resources.find((entry) => entry.name === value);
+    if (!resource) {
+        throw new Error(`Selected resource "${value}" was not found.`);
+    }
+    return resource;
+}
+async function promptForRouteName(prompt, provided) {
+    if (provided) {
+        throw new Error("Route name was marked as provided but no route name was passed.");
+    }
+    return prompt.input({
+        message: "Route name",
+        required: true,
+    });
+}
+function createAuthChoices(config) {
+    const choices = [{ label: "None", value: "none" }];
+    if (config.project.capabilities.auth.includes("jwt") || config.project.capabilities.auth.includes("local")) {
+        choices.push({ label: "JWT", value: "jwt" });
+    }
+    if (config.project.capabilities.auth.includes("api-key")) {
+        choices.push({ label: "API key", value: "api-key" });
+    }
+    return choices;
+}
+function defaultRouteAuth(resourceAuth, projectAuth) {
+    if (resourceAuth === "local" || resourceAuth === "jwt") {
+        return "jwt";
+    }
+    if (resourceAuth === "api-key") {
+        return "api-key";
+    }
+    if (projectAuth.includes("jwt") || projectAuth.includes("local")) {
+        return "jwt";
+    }
+    if (projectAuth.includes("api-key")) {
+        return "api-key";
+    }
+    return "none";
+}
+function createTargetChoices(config) {
+    const choices = [
+        { label: "Direct controller", value: "direct" },
+        { label: "Use case", value: "use-case" },
+    ];
+    if (config.project.architecture === "cqrs") {
+        choices.push({ label: "CQRS command", value: "command" });
+        choices.push({ label: "CQRS query", value: "query" });
+    }
+    return choices;
+}

package/build/prompts/create-project.prompt.d.ts

@@ -0,0 +1,11 @@
+import { PromptAdapter } from "./prompt-adapter";
+import { CreateConfigInput, CreateConfigResult } from "../resolvers/create-config.resolver";
+export interface CreateProjectPromptAnswers extends CreateConfigInput {
+    install?: boolean;
+    gitInit?: boolean;
+}
+export interface CreateProjectPromptOptions {
+    provided: Partial<Record<keyof CreateProjectPromptAnswers, boolean>>;
+    preset?: Partial<CreateConfigResult>;
+}
+export declare function promptCreateProject(prompt: PromptAdapter, options: CreateProjectPromptOptions): Promise<CreateProjectPromptAnswers>;