@soapjs/cli 1.0.0

package/build/prompts/create-project.prompt.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptCreateProject = void 0;
+async function promptCreateProject(prompt, options) {
+    const answers = {};
+    const preset = options.preset ?? {};
+    if (!options.provided.framework) {
+        answers.framework = await prompt.select({
+            message: "Web framework",
+            choices: [{ label: "Express", value: "express" }],
+            defaultValue: preset.framework ?? "express",
+        });
+    }
+    if (!options.provided.architecture) {
+        answers.architecture = await prompt.select({
+            message: "Architecture pattern",
+            choices: [
+                { label: "Regular Clean Architecture", value: "regular" },
+                { label: "CQRS", value: "cqrs" },
+            ],
+            defaultValue: preset.architecture ?? "regular",
+        });
+    }
+    if (!options.provided.db) {
+        answers.db = await prompt.multiSelect({
+            message: "Databases",
+            choices: [
+                { label: "MongoDB", value: "mongo" },
+                { label: "PostgreSQL", value: "postgres" },
+                { label: "MySQL", value: "mysql" },
+                { label: "SQLite", value: "sqlite" },
+                { label: "Redis", value: "redis" },
+                { label: "None", value: "none" },
+            ],
+            defaultValues: withNoneDefault(preset.capabilities?.databases),
+        });
+    }
+    if (!options.provided.auth) {
+        answers.auth = await prompt.multiSelect({
+            message: "Auth strategies",
+            choices: [
+                { label: "JWT", value: "jwt" },
+                { label: "API Key", value: "api-key" },
+                { label: "Local", value: "local" },
+                { label: "None", value: "none" },
+            ],
+            defaultValues: withNoneDefault(preset.capabilities?.auth),
+        });
+    }
+    if (!options.provided.messaging) {
+        answers.messaging = await prompt.multiSelect({
+            message: "Messaging",
+            choices: [
+                { label: "In-memory", value: "in-memory" },
+                { label: "Kafka/Redpanda", value: "kafka" },
+                { label: "None", value: "none" },
+            ],
+            defaultValues: withDefault(preset.capabilities?.messaging, ["in-memory"]),
+        });
+    }
+    if (!options.provided.realtime) {
+        answers.realtime = await prompt.multiSelect({
+            message: "Realtime",
+            choices: [
+                { label: "WebSocket", value: "ws" },
+                { label: "None", value: "none" },
+            ],
+            defaultValues: withNoneDefault(preset.capabilities?.realtime),
+        });
+    }
+    if (!options.provided.telemetry) {
+        answers.telemetry = await prompt.multiSelect({
+            message: "Telemetry",
+            choices: [
+                { label: "Logs", value: "logs" },
+                { label: "OTel noop", value: "otel-noop" },
+                { label: "None", value: "none" },
+            ],
+            defaultValues: withDefault(preset.capabilities?.telemetry, ["logs"]),
+        });
+    }
+    if (!options.provided.docs) {
+        answers.docs = await prompt.multiSelect({
+            message: "Docs",
+            choices: [
+                { label: "OpenAPI", value: "openapi" },
+                { label: "None", value: "none" },
+            ],
+            defaultValues: withNoneDefault(preset.capabilities?.docs),
+        });
+    }
+    if (!options.provided.contracts) {
+        answers.contracts = await prompt.multiSelect({
+            message: "Contracts",
+            choices: [
+                { label: "Zod", value: "zod" },
+                { label: "None", value: "none" },
+            ],
+            defaultValues: withNoneDefault(preset.capabilities?.contracts),
+        });
+    }
+    if (!options.provided.apiClient) {
+        answers.apiClient = await prompt.multiSelect({
+            message: "API client",
+            choices: [
+                { label: "Bruno", value: "bruno" },
+                { label: "None", value: "none" },
+            ],
+            defaultValues: withNoneDefault(preset.capabilities?.apiClient),
+        });
+    }
+    if (!options.provided.zones) {
+        answers.zones = await prompt.multiSelect({
+            message: "API zones",
+            choices: [
+                { label: "Public", value: "public" },
+                { label: "Private", value: "private" },
+                { label: "Admin", value: "admin" },
+            ],
+            defaultValues: withDefault(preset.zones, ["public", "private", "admin"]),
+            required: true,
+        });
+    }
+    if (!options.provided.packageManager) {
+        answers.packageManager = await prompt.select({
+            message: "Package manager",
+            choices: [
+                { label: "npm", value: "npm" },
+                { label: "pnpm", value: "pnpm" },
+                { label: "yarn", value: "yarn" },
+                { label: "bun", value: "bun" },
+            ],
+            defaultValue: preset.packageManager ?? "npm",
+        });
+    }
+    if (!options.provided.install) {
+        answers.install = await prompt.confirm({
+            message: "Install dependencies",
+            defaultValue: false,
+        });
+    }
+    if (!options.provided.gitInit) {
+        answers.gitInit = await prompt.confirm({
+            message: "Initialize git repository",
+            defaultValue: false,
+        });
+    }
+    return answers;
+}
+exports.promptCreateProject = promptCreateProject;
+function withNoneDefault(values) {
+    return values && values.length > 0 ? values : [];
+}
+function withDefault(values, fallback) {
+    return values && values.length > 0 ? values : fallback;
+}

package/build/prompts/generate-bruno.prompt.d.ts

@@ -0,0 +1,7 @@
+import { BrunoGenerationAnalysis } from "../commands/generate/bruno-analysis";
+import { PromptAdapter } from "./prompt-adapter";
+export type GenerateBrunoMode = "missing" | "all" | "e2e" | "abort";
+export interface GenerateBrunoPromptAnswers {
+    mode: GenerateBrunoMode;
+}
+export declare function promptGenerateBruno(prompt: PromptAdapter, analysis: BrunoGenerationAnalysis): Promise<GenerateBrunoPromptAnswers>;

package/build/prompts/generate-bruno.prompt.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptGenerateBruno = void 0;
+async function promptGenerateBruno(prompt, analysis) {
+    const mode = await prompt.select({
+        message: "Bruno generation mode",
+        choices: [
+            {
+                label: `Generate missing only (${analysis.missingCount})`,
+                value: "missing",
+                disabled: analysis.missingCount === 0 ? "No missing Bruno files" : undefined,
+            },
+            { label: "Regenerate all unmodified generated files", value: "all" },
+            { label: "Generate E2E flow", value: "e2e" },
+            { label: "Abort", value: "abort" },
+        ],
+        defaultValue: analysis.missingCount > 0 ? "missing" : "all",
+    });
+    return { mode };
+}
+exports.promptGenerateBruno = promptGenerateBruno;

package/build/prompts/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./prompt.types";
+export * from "./prompt-adapter";
+export * from "./inquirer-prompt-adapter";
+export * from "./mock-prompt-adapter";
+export * from "./create-project.prompt";
+export * from "./add-resource.prompt";
+export * from "./add-route.prompt";
+export * from "./generate-bruno.prompt";

package/build/prompts/index.js

@@ -0,0 +1,24 @@
+"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("./prompt.types"), exports);
+__exportStar(require("./prompt-adapter"), exports);
+__exportStar(require("./inquirer-prompt-adapter"), exports);
+__exportStar(require("./mock-prompt-adapter"), exports);
+__exportStar(require("./create-project.prompt"), exports);
+__exportStar(require("./add-resource.prompt"), exports);
+__exportStar(require("./add-route.prompt"), exports);
+__exportStar(require("./generate-bruno.prompt"), exports);

package/build/prompts/inquirer-prompt-adapter.d.ts

@@ -0,0 +1,8 @@
+import { PromptAdapter } from "./prompt-adapter";
+import { ConfirmQuestion, InputQuestion, MultiSelectQuestion, SelectQuestion } from "./prompt.types";
+export declare class InquirerPromptAdapter implements PromptAdapter {
+    input(question: InputQuestion): Promise<string>;
+    confirm(question: ConfirmQuestion): Promise<boolean>;
+    select<T extends string>(question: SelectQuestion<T>): Promise<T>;
+    multiSelect<T extends string>(question: MultiSelectQuestion<T>): Promise<T[]>;
+}

package/build/prompts/inquirer-prompt-adapter.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InquirerPromptAdapter = void 0;
+const prompts_1 = require("@inquirer/prompts");
+class InquirerPromptAdapter {
+    async input(question) {
+        return (0, prompts_1.input)({
+            message: question.message,
+            default: question.defaultValue,
+            validate: question.required ? (value) => value.trim().length > 0 || "Value is required." : undefined,
+        });
+    }
+    async confirm(question) {
+        return (0, prompts_1.confirm)({
+            message: question.message,
+            default: question.defaultValue,
+        });
+    }
+    async select(question) {
+        return (0, prompts_1.select)({
+            message: question.message,
+            choices: question.choices.map(toInquirerChoice),
+            default: question.defaultValue,
+        });
+    }
+    async multiSelect(question) {
+        const selected = await (0, prompts_1.checkbox)({
+            message: question.message,
+            choices: question.choices.map((choice) => ({
+                ...toInquirerChoice(choice),
+                checked: question.defaultValues?.includes(choice.value),
+            })),
+            required: question.required,
+        });
+        return normalizeNoneSelection(selected);
+    }
+}
+exports.InquirerPromptAdapter = InquirerPromptAdapter;
+function normalizeNoneSelection(values) {
+    if (values.length <= 1 || !values.includes("none")) {
+        return values;
+    }
+    return values.filter((value) => value !== "none");
+}
+function toInquirerChoice(choice) {
+    return {
+        name: choice.label,
+        value: choice.value,
+        description: choice.description,
+        disabled: choice.disabled,
+    };
+}

package/build/prompts/mock-prompt-adapter.d.ts

@@ -0,0 +1,13 @@
+import { PromptAdapter } from "./prompt-adapter";
+import { ConfirmQuestion, InputQuestion, MultiSelectQuestion, SelectQuestion } from "./prompt.types";
+type MockAnswer = string | boolean | string[];
+export declare class MockPromptAdapter implements PromptAdapter {
+    private readonly answers;
+    constructor(answers?: MockAnswer[]);
+    input(question: InputQuestion): Promise<string>;
+    confirm(question: ConfirmQuestion): Promise<boolean>;
+    select<T extends string>(question: SelectQuestion<T>): Promise<T>;
+    multiSelect<T extends string>(question: MultiSelectQuestion<T>): Promise<T[]>;
+    private nextAnswer;
+}
+export {};

package/build/prompts/mock-prompt-adapter.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockPromptAdapter = void 0;
+class MockPromptAdapter {
+    answers;
+    constructor(answers = []) {
+        this.answers = [...answers];
+    }
+    async input(question) {
+        const answer = this.nextAnswer();
+        if (answer === undefined) {
+            return question.defaultValue ?? "";
+        }
+        if (typeof answer !== "string") {
+            throw new Error(`Mock prompt answer for "${question.message}" must be a string.`);
+        }
+        return answer;
+    }
+    async confirm(question) {
+        const answer = this.nextAnswer();
+        if (answer === undefined) {
+            return question.defaultValue ?? false;
+        }
+        if (typeof answer !== "boolean") {
+            throw new Error(`Mock prompt answer for "${question.message}" must be a boolean.`);
+        }
+        return answer;
+    }
+    async select(question) {
+        const answer = this.nextAnswer();
+        if (answer === undefined) {
+            if (question.defaultValue !== undefined) {
+                return question.defaultValue;
+            }
+            const firstChoice = question.choices.find((choice) => !choice.disabled);
+            if (firstChoice) {
+                return firstChoice.value;
+            }
+            throw new Error(`Mock prompt has no selectable answer for "${question.message}".`);
+        }
+        if (typeof answer !== "string") {
+            throw new Error(`Mock prompt answer for "${question.message}" must be a string.`);
+        }
+        return answer;
+    }
+    async multiSelect(question) {
+        const answer = this.nextAnswer();
+        if (answer === undefined) {
+            return [...(question.defaultValues ?? [])];
+        }
+        if (!Array.isArray(answer)) {
+            throw new Error(`Mock prompt answer for "${question.message}" must be a string array.`);
+        }
+        return answer;
+    }
+    nextAnswer() {
+        return this.answers.shift();
+    }
+}
+exports.MockPromptAdapter = MockPromptAdapter;

package/build/prompts/prompt-adapter.d.ts

@@ -0,0 +1,7 @@
+import { ConfirmQuestion, InputQuestion, MultiSelectQuestion, SelectQuestion } from "./prompt.types";
+export interface PromptAdapter {
+    input(question: InputQuestion): Promise<string>;
+    confirm(question: ConfirmQuestion): Promise<boolean>;
+    select<T extends string>(question: SelectQuestion<T>): Promise<T>;
+    multiSelect<T extends string>(question: MultiSelectQuestion<T>): Promise<T[]>;
+}

package/build/prompts/prompt-adapter.js

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

package/build/prompts/prompt.types.d.ts

@@ -0,0 +1,26 @@
+export interface PromptChoice<T extends string> {
+    value: T;
+    label: string;
+    description?: string;
+    disabled?: boolean | string;
+}
+export interface InputQuestion {
+    message: string;
+    defaultValue?: string;
+    required?: boolean;
+}
+export interface ConfirmQuestion {
+    message: string;
+    defaultValue?: boolean;
+}
+export interface SelectQuestion<T extends string> {
+    message: string;
+    choices: Array<PromptChoice<T>>;
+    defaultValue?: T;
+}
+export interface MultiSelectQuestion<T extends string> {
+    message: string;
+    choices: Array<PromptChoice<T>>;
+    defaultValues?: T[];
+    required?: boolean;
+}

package/build/prompts/prompt.types.js

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

package/build/registry/registry.service.d.ts

@@ -0,0 +1,19 @@
+import { CommandContext } from "../core/command-context";
+import { GeneratedFileEntry, GeneratedFileType, SoapRegistryConfig } from "../config/schemas/types";
+export interface RegisterFileOptions {
+    root: string;
+    relativePath: string;
+    type: GeneratedFileType;
+    owner?: string;
+    registry: SoapRegistryConfig;
+}
+export declare function hashContent(content: string): string;
+export declare function readFileHash(filePath: string): Promise<string | undefined>;
+export declare function upsertGeneratedFile(registry: SoapRegistryConfig, entry: Omit<GeneratedFileEntry, "generatedAt"> & {
+    generatedAt?: string;
+}): void;
+export declare function assertCanWriteGeneratedFile(root: string, relativePath: string, registry: SoapRegistryConfig, options?: {
+    force?: boolean;
+    writeNew?: boolean;
+}): Promise<string>;
+export declare function registerGeneratedFile(options: RegisterFileOptions, content: string, context: CommandContext): Promise<void>;

package/build/registry/registry.service.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGeneratedFile = exports.assertCanWriteGeneratedFile = exports.upsertGeneratedFile = exports.readFileHash = exports.hashContent = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("../core/errors");
+function hashContent(content) {
+    return crypto_1.default.createHash("sha256").update(content).digest("hex");
+}
+exports.hashContent = hashContent;
+async function readFileHash(filePath) {
+    try {
+        return hashContent(await promises_1.default.readFile(filePath, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+exports.readFileHash = readFileHash;
+function upsertGeneratedFile(registry, entry) {
+    const index = registry.generatedFiles.findIndex((item) => item.path === entry.path);
+    const next = {
+        ...entry,
+        generatedAt: entry.generatedAt ?? new Date().toISOString(),
+    };
+    if (index >= 0) {
+        registry.generatedFiles[index] = next;
+    }
+    else {
+        registry.generatedFiles.push(next);
+    }
+}
+exports.upsertGeneratedFile = upsertGeneratedFile;
+async function assertCanWriteGeneratedFile(root, relativePath, registry, options = {}) {
+    const targetPath = path_1.default.join(root, relativePath);
+    const entry = registry.generatedFiles.find((item) => item.path === relativePath);
+    const currentHash = await readFileHash(targetPath);
+    if (!currentHash || options.force) {
+        return targetPath;
+    }
+    if (entry && entry.hash === currentHash) {
+        return targetPath;
+    }
+    if (options.writeNew) {
+        return `${targetPath}.new`;
+    }
+    throw new errors_1.CliError(`Refusing to overwrite modified file ${relativePath}. Use --force to overwrite or --write-new to write ${relativePath}.new.`);
+}
+exports.assertCanWriteGeneratedFile = assertCanWriteGeneratedFile;
+async function registerGeneratedFile(options, content, context) {
+    upsertGeneratedFile(options.registry, {
+        path: options.relativePath,
+        type: options.type,
+        owner: options.owner,
+        hash: hashContent(content),
+    });
+    if (context.dryRun) {
+        context.output.info(`[dry-run] register ${options.relativePath}`);
+    }
+}
+exports.registerGeneratedFile = registerGeneratedFile;

package/build/resolvers/add-resource.resolver.d.ts

@@ -0,0 +1,23 @@
+import { ApiZone, AuthCapability, DatabaseCapability, SoapConfig } from "../config/schemas/types";
+import { CommandInputResolver } from "./resolver.types";
+export interface AddResourceInput {
+    crud?: boolean;
+    db?: "none" | DatabaseCapability;
+    auth?: "none" | AuthCapability | "jwt";
+    zone?: ApiZone;
+}
+export interface AddResourceResult {
+    crud: boolean;
+    db: "none" | DatabaseCapability;
+    auth: "none" | "jwt" | "api-key";
+    zone: ApiZone;
+}
+export declare class AddResourceResolver implements CommandInputResolver<AddResourceInput, AddResourceInput, SoapConfig, AddResourceResult> {
+    resolve(input: {
+        flags: AddResourceInput;
+        promptAnswers?: AddResourceInput;
+        projectConfig?: SoapConfig;
+        preset?: Partial<AddResourceResult>;
+    }): AddResourceResult;
+}
+export declare const addResourceResolver: AddResourceResolver;

package/build/resolvers/add-resource.resolver.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addResourceResolver = exports.AddResourceResolver = void 0;
+const errors_1 = require("../core/errors");
+class AddResourceResolver {
+    resolve(input) {
+        const config = requireProjectConfig(input.projectConfig);
+        const flags = input.flags;
+        const promptAnswers = input.promptAnswers ?? {};
+        const preset = input.preset ?? {};
+        const db = pick(flags.db, promptAnswers.db, preset.db, firstOrNone(config.project.capabilities.databases));
+        const auth = normalizeRouteAuth(pick(flags.auth, promptAnswers.auth, preset.auth, firstAuthForRoutes(config.project.capabilities.auth)));
+        const zone = pick(flags.zone, promptAnswers.zone, preset.zone, defaultZone(config));
+        assertCapability("database", db, ["none", ...config.project.capabilities.databases]);
+        assertCapability("auth", auth, enabledRouteAuthValues(config.project.capabilities.auth));
+        assertCapability("zone", zone, config.project.zones);
+        return {
+            crud: Boolean(pick(flags.crud, promptAnswers.crud, preset.crud, false)),
+            db,
+            auth,
+            zone,
+        };
+    }
+}
+exports.AddResourceResolver = AddResourceResolver;
+function requireProjectConfig(config) {
+    if (!config) {
+        throw new errors_1.CliError("Project config is required to resolve resource input.");
+    }
+    return config;
+}
+function pick(...values) {
+    const value = values.find((item) => item !== undefined);
+    return value;
+}
+function firstOrNone(values) {
+    return values[0] ?? "none";
+}
+function firstAuthForRoutes(values) {
+    if (values.includes("jwt") || values.includes("local")) {
+        return "jwt";
+    }
+    return values[0] ?? "none";
+}
+function normalizeRouteAuth(value) {
+    if (value === "local") {
+        return "jwt";
+    }
+    if (value === "jwt" || value === "api-key" || value === "none") {
+        return value;
+    }
+    throw new errors_1.CliError(`Auth "${value}" cannot protect routes. Use jwt, api-key, or none.`);
+}
+function enabledRouteAuthValues(values) {
+    const allowed = ["none"];
+    if (values.includes("jwt") || values.includes("local")) {
+        allowed.push("jwt");
+    }
+    if (values.includes("api-key")) {
+        allowed.push("api-key");
+    }
+    return allowed;
+}
+function defaultZone(config) {
+    return config.project.zones.includes("public") ? "public" : config.project.zones[0] ?? "public";
+}
+function assertCapability(label, value, allowed) {
+    if (!allowed.includes(value)) {
+        const allowedValues = allowed.length > 0 ? allowed.join(", ") : "none";
+        throw new errors_1.CliError(`${label} "${value}" is not enabled for this project. Allowed values: ${allowedValues}.`);
+    }
+}
+exports.addResourceResolver = new AddResourceResolver();

package/build/resolvers/add-route.resolver.d.ts

@@ -0,0 +1,34 @@
+import { ApiZone, AuthCapability, ResourceRegistryEntry, SoapConfig } from "../config/schemas/types";
+import { RouteMethod } from "../commands/add/route-plan";
+import { CommandInputResolver } from "./resolver.types";
+export interface AddRouteInput {
+    method?: string;
+    path?: string;
+    useCase?: string;
+    command?: string;
+    query?: string;
+    auth?: "none" | AuthCapability | "jwt";
+    zone?: ApiZone;
+}
+export interface AddRouteConfig {
+    project: SoapConfig;
+    resource: ResourceRegistryEntry;
+}
+export interface AddRouteResult {
+    method: RouteMethod;
+    path?: string;
+    useCase?: string;
+    command?: string;
+    query?: string;
+    auth: "none" | "jwt" | "api-key";
+    zone: ApiZone;
+}
+export declare class AddRouteResolver implements CommandInputResolver<AddRouteInput, AddRouteInput, AddRouteConfig, AddRouteResult> {
+    resolve(input: {
+        flags: AddRouteInput;
+        promptAnswers?: AddRouteInput;
+        projectConfig?: AddRouteConfig;
+        preset?: Partial<AddRouteResult>;
+    }): AddRouteResult;
+}
+export declare const addRouteResolver: AddRouteResolver;