@decohere/create 0.0.1-dev.43 → 0.0.1-dev.44

package/commonjs/src/models/config-yaml.model.js

@@ -2,12 +2,21 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "ConfigYaml", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get ConfigYaml () {
         return ConfigYaml;
+    },
+    get injectYamlDataSource () {
+        return injectYamlDataSource;
     }
 });
+const _nodefs = require("node:fs");
 class ConfigYaml {
     key;
     filePath;
@@ -21,6 +30,25 @@ class ConfigYaml {
         this._sections.push(yaml);
         return this;
     }
+    /** True when a datasource with this `name:` already appears in the file. */ hasDataSource(name) {
+        return this._sections.join("\n").includes(`name: ${name}\n`);
+    }
+    hasDataSources() {
+        return this._sections.join("\n").includes("dataSources:");
+    }
+    /**
+	 * Insert a `dataSources` list item. Used by `webapi add` so we do not write a
+	 * second top-level `database:` key (YAML last-key-wins).
+	 */ appendDataSource(item) {
+        const current = this._sections.join("\n");
+        this._sections.length = 0;
+        this._sections.push(injectYamlDataSource(current, item));
+        return this;
+    }
+    static fromFile(key, relativePath, absolutePath) {
+        const content = (0, _nodefs.readFileSync)(absolutePath, "utf8");
+        return new ConfigYaml(key, relativePath, content);
+    }
     files() {
         return [
             {
@@ -30,5 +58,31 @@ class ConfigYaml {
         ];
     }
 }
+function injectYamlDataSource(yaml, item) {
+    const block = item.replace(/\n$/, "");
+    if (!yaml.includes("dataSources:")) {
+        const prefix = yaml.trimEnd();
+        const section = `database:\n  dataSources:\n${block}\n`;
+        return prefix.length > 0 ? `${prefix}\n\n${section}` : section;
+    }
+    const lines = yaml.split("\n");
+    const dsIndex = lines.findIndex((line)=>/^\s*dataSources:\s*$/.test(line));
+    if (dsIndex < 0) {
+        return `${yaml.trimEnd()}\n\ndatabase:\n  dataSources:\n${block}\n`;
+    }
+    let insertAt = lines.length;
+    for(let i = dsIndex + 1; i < lines.length; i++){
+        if (/^[A-Za-z]/.test(lines[i] ?? "")) {
+            insertAt = i;
+            break;
+        }
+    }
+    const insertLines = block.split("\n");
+    if (insertAt < lines.length && lines[insertAt - 1] !== "") {
+        insertLines.push("");
+    }
+    lines.splice(insertAt, 0, ...insertLines);
+    return lines.join("\n");
+}
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/models/env-file.model.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "EnvFile", {
         return EnvFile;
     }
 });
+const _nodefs = require("node:fs");
 const _const = require("./const.js");
 class EnvFile {
     key = _const.WELL_KNOWN_FILES.ENV_FILE;
@@ -16,6 +17,18 @@ class EnvFile {
         this._entries.set(key, value);
         return this;
     }
+    static fromFile(absolutePath) {
+        const env = new EnvFile();
+        const raw = (0, _nodefs.readFileSync)(absolutePath, "utf8");
+        for (const line of raw.split("\n")){
+            const trimmed = line.trim();
+            if (trimmed === "" || trimmed.startsWith("#")) continue;
+            const eq = line.indexOf("=");
+            if (eq <= 0) continue;
+            env.addEntry(line.slice(0, eq).trim(), line.slice(eq + 1));
+        }
+        return env;
+    }
     files() {
         if (this._entries.size === 0) return [];
         const body = [
@@ -31,4 +44,4 @@ class EnvFile {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/models/launch-json.model.js

@@ -10,43 +10,65 @@ Object.defineProperty(exports, "LaunchJson", {
 });
 const _const = require("./const.js");
 class LaunchJson {
+    apiNames;
     key = _const.WELL_KNOWN_FILES.LAUNCH_JSON;
+    constructor(apiNames = [
+        "api"
+    ]){
+        this.apiNames = apiNames;
+    }
     files() {
+        const configurations = [
+            {
+                name: "Build",
+                type: "node",
+                request: "launch",
+                runtimeExecutable: "pnpm",
+                runtimeArgs: [
+                    "build"
+                ],
+                console: "integratedTerminal",
+                // biome-ignore lint/suspicious/noTemplateCurlyInString: VS Code variable
+                cwd: "${workspaceFolder}"
+            }
+        ];
+        const first = this.apiNames[0] ?? "api";
+        const defaultDevArgs = first === "api" && this.apiNames.length === 1 ? [
+            "dev"
+        ] : [
+            "run",
+            `dev:${first}`
+        ];
+        configurations.push(serveConfig("Serve / Dev", defaultDevArgs));
+        for (const apiName of this.apiNames){
+            if (apiName === first && this.apiNames.length === 1 && apiName === "api") continue;
+            configurations.push(serveConfig(`Serve / Dev (${apiName})`, [
+                "run",
+                `dev:${apiName}`
+            ]));
+        }
         return [
             {
                 filePath: ".vscode/launch.json",
                 content: JSON.stringify({
                     version: "0.2.0",
-                    configurations: [
-                        {
-                            name: "Build",
-                            type: "node",
-                            request: "launch",
-                            runtimeExecutable: "pnpm",
-                            runtimeArgs: [
-                                "build"
-                            ],
-                            console: "integratedTerminal",
-                            // biome-ignore lint/suspicious/noTemplateCurlyInString: VS Code variable
-                            cwd: "${workspaceFolder}"
-                        },
-                        {
-                            name: "Serve / Dev",
-                            type: "node",
-                            request: "launch",
-                            runtimeExecutable: "pnpm",
-                            runtimeArgs: [
-                                "dev"
-                            ],
-                            console: "integratedTerminal",
-                            // biome-ignore lint/suspicious/noTemplateCurlyInString: VS Code variable
-                            cwd: "${workspaceFolder}"
-                        }
-                    ]
+                    configurations
                 }, null, 2)
             }
         ];
     }
 }
+function serveConfig(name, runtimeArgs) {
+    return {
+        name,
+        type: "node",
+        request: "launch",
+        runtimeExecutable: "pnpm",
+        runtimeArgs,
+        console: "integratedTerminal",
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: VS Code variable
+        cwd: "${workspaceFolder}"
+    };
+}
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/models/package-json.model.js

@@ -8,26 +8,41 @@ Object.defineProperty(exports, "PackageJson", {
         return PackageJson;
     }
 });
+const _nodefs = require("node:fs");
 const _version = require("../version.js");
-const _const = require("./const.js");
+const _const = require("../webapi/const.js");
+const _const1 = require("./const.js");
 class PackageJson {
     name;
-    key = _const.WELL_KNOWN_FILES.PACKAGE_JSON;
+    key = _const1.WELL_KNOWN_FILES.PACKAGE_JSON;
     _dependencies;
     _devDependencies;
     _scripts;
+    _version = "0.0.1";
+    _type = "module";
+    _rest = {};
     constructor(name, options){
         this.name = name;
-        const startEntry = options?.startEntry ?? "dist/release/projects/api/es6/src/main.js";
+        const apiNames = options?.apiNames ?? [
+            _const.DEFAULT_WEBAPI_NAME
+        ];
+        const first = apiNames[0] ?? _const.DEFAULT_WEBAPI_NAME;
+        const startEntry = options?.startEntry ?? (0, _const.webapiReleaseEntry)(first);
+        const workspaceName = options?.workspaceName ?? stripApiSuffix(name);
+        const namedOrMany = apiNames.length > 1 || first !== _const.DEFAULT_WEBAPI_NAME;
         this._scripts = {
             build: "forge build --configuration release",
             "build:watch": "forge build --watch",
             start: `node ${startEntry}`,
-            dev: "flux serve",
+            dev: namedOrMany ? fluxDevScript(workspaceName, first, (0, _const.webapiPort)(0)) : "flux serve",
             "lint:check": "biome check .",
             typecheck: "tsc --noEmit",
             test: "vitest run --passWithNoTests"
         };
+        for (const [index, apiName] of apiNames.entries()){
+            this._scripts[`start:${apiName}`] = `node ${(0, _const.webapiReleaseEntry)(apiName)}`;
+            this._scripts[`dev:${apiName}`] = fluxDevScript(workspaceName, apiName, (0, _const.webapiPort)(index));
+        }
         this._dependencies = {
             "@decohere/cortex": _version.CREATE_VERSION,
             "@decohere/crucible": _version.CREATE_VERSION,
@@ -44,6 +59,33 @@ class PackageJson {
             vitest: "^3.2.4"
         };
     }
+    /** Load an existing root package.json so `webapi add` can merge scripts/deps. */ static fromFile(filePath) {
+        const raw = JSON.parse((0, _nodefs.readFileSync)(filePath, "utf8"));
+        const pkg = new PackageJson(typeof raw.name === "string" ? raw.name : "app", {
+            apiNames: []
+        });
+        pkg._version = typeof raw.version === "string" ? raw.version : "0.0.1";
+        pkg._type = typeof raw.type === "string" ? raw.type : "module";
+        pkg._scripts = {
+            ...asStringMap(raw.scripts)
+        };
+        pkg._dependencies = {
+            ...asStringMap(raw.dependencies)
+        };
+        pkg._devDependencies = {
+            ...asStringMap(raw.devDependencies)
+        };
+        const reserved = new Set([
+            "name",
+            "version",
+            "type",
+            "scripts",
+            "dependencies",
+            "devDependencies"
+        ]);
+        pkg._rest = Object.fromEntries(Object.entries(raw).filter(([key])=>!reserved.has(key)));
+        return pkg;
+    }
     addDependency(name, version) {
         this._dependencies[name] = version;
         return this;
@@ -62,8 +104,9 @@ class PackageJson {
                 filePath: "package.json",
                 content: JSON.stringify({
                     name: this.name,
-                    version: "0.0.1",
-                    type: "module",
+                    version: this._version,
+                    type: this._type,
+                    ...this._rest,
                     scripts: this._scripts,
                     dependencies: this._dependencies,
                     devDependencies: this._devDependencies
@@ -72,5 +115,19 @@ class PackageJson {
         ];
     }
 }
+function stripApiSuffix(name) {
+    return name.endsWith(".api") ? name.slice(0, -".api".length) : name;
+}
+function asStringMap(value) {
+    if (value == null || typeof value !== "object") return {};
+    const result = {};
+    for (const [key, entry] of Object.entries(value)){
+        if (typeof entry === "string") result[key] = entry;
+    }
+    return result;
+}
+function fluxDevScript(workspaceName, apiName, port) {
+    return `PORT=${port} flux serve --project ${(0, _const.webapiPackageName)(workspaceName, apiName)}`;
+}
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/models/package-json.model.ts"],"sourcesContent":["import { readFileSync } from \"node:fs\";\nimport { CREATE_VERSION } from \"../version.js\";\nimport {\n\tDEFAULT_WEBAPI_NAME,\n\twebapiPackageName,\n\twebapiPort,\n\twebapiReleaseEntry,\n} from \"../webapi/const.js\";\nimport { WELL_KNOWN_FILES } from \"./const.js\";\nimport type { KeyedModel, SourceFile } from \"./source-file.js\";\n\nexport type PackageJsonOptions = {\n\tstartEntry?: string;\n\t/** API slugs in this workspace. Drives `start:<name>` / `dev:<name>`. */\n\tapiNames?: readonly string[];\n\t/** Host workspace name used in `@<workspace>/<api>` for flux `--project`. */\n\tworkspaceName?: string;\n};\n\n/**\n * Builder for the root `package.json`.\n *\n * Starts with the core API dependencies. Features call `addDependency` /\n * `addDevDependency` during their scaffold phase to inject their own deps\n * before `files()` is called at render time.\n */\nexport class PackageJson implements KeyedModel {\n\tpublic readonly key = WELL_KNOWN_FILES.PACKAGE_JSON;\n\n\tprivate _dependencies: Record<string, string>;\n\tprivate _devDependencies: Record<string, string>;\n\tprivate _scripts: Record<string, string>;\n\tprivate _version = \"0.0.1\";\n\tprivate _type = \"module\";\n\tprivate _rest: Record<string, unknown> = {};\n\n\tpublic constructor(\n\t\tprivate readonly name: string,\n\t\toptions?: PackageJsonOptions,\n\t) {\n\t\tconst apiNames = options?.apiNames ?? [DEFAULT_WEBAPI_NAME];\n\t\tconst first = apiNames[0] ?? DEFAULT_WEBAPI_NAME;\n\t\tconst startEntry = options?.startEntry ?? webapiReleaseEntry(first);\n\t\tconst workspaceName = options?.workspaceName ?? stripApiSuffix(name);\n\t\tconst namedOrMany = apiNames.length > 1 || first !== DEFAULT_WEBAPI_NAME;\n\n\t\tthis._scripts = {\n\t\t\tbuild: \"forge build --configuration release\",\n\t\t\t\"build:watch\": \"forge build --watch\",\n\t\t\tstart: `node ${startEntry}`,\n\t\t\tdev: namedOrMany ? fluxDevScript(workspaceName, first, webapiPort(0)) : \"flux serve\",\n\t\t\t\"lint:check\": \"biome check .\",\n\t\t\ttypecheck: \"tsc --noEmit\",\n\t\t\ttest: \"vitest run --passWithNoTests\",\n\t\t};\n\t\tfor (const [index, apiName] of apiNames.entries()) {\n\t\t\tthis._scripts[`start:${apiName}`] = `node ${webapiReleaseEntry(apiName)}`;\n\t\t\tthis._scripts[`dev:${apiName}`] = fluxDevScript(\n\t\t\t\tworkspaceName,\n\t\t\t\tapiName,\n\t\t\t\twebapiPort(index),\n\t\t\t);\n\t\t}\n\t\tthis._dependencies = {\n\t\t\t\"@decohere/cortex\": CREATE_VERSION,\n\t\t\t\"@decohere/crucible\": CREATE_VERSION,\n\t\t\t\"@decohere/nexus\": CREATE_VERSION,\n\t\t\t\"@decohere/protocol\": CREATE_VERSION,\n\t\t\t\"@decohere/scribe\": CREATE_VERSION,\n\t\t\t\"@decohere/scribe-pino\": CREATE_VERSION,\n\t\t\t\"pino-pretty\": \"^13.0.0\",\n\t\t};\n\t\tthis._devDependencies = {\n\t\t\t\"@decohere/terminal\": CREATE_VERSION,\n\t\t\ttypescript: \"^6.0.3\",\n\t\t\t\"@biomejs/biome\": \"^2.0.0\",\n\t\t\tvitest: \"^3.2.4\",\n\t\t};\n\t}\n\n\t/** Load an existing root package.json so `webapi add` can merge scripts/deps. */\n\tpublic static fromFile(filePath: string): PackageJson {\n\t\tconst raw = JSON.parse(readFileSync(filePath, \"utf8\")) as Record<string, unknown>;\n\t\tconst pkg = new PackageJson(typeof raw.name === \"string\" ? raw.name : \"app\", {\n\t\t\tapiNames: [],\n\t\t});\n\t\tpkg._version = typeof raw.version === \"string\" ? raw.version : \"0.0.1\";\n\t\tpkg._type = typeof raw.type === \"string\" ? raw.type : \"module\";\n\t\tpkg._scripts = { ...asStringMap(raw.scripts) };\n\t\tpkg._dependencies = { ...asStringMap(raw.dependencies) };\n\t\tpkg._devDependencies = { ...asStringMap(raw.devDependencies) };\n\t\tconst reserved = new Set([\n\t\t\t\"name\",\n\t\t\t\"version\",\n\t\t\t\"type\",\n\t\t\t\"scripts\",\n\t\t\t\"dependencies\",\n\t\t\t\"devDependencies\",\n\t\t]);\n\t\tpkg._rest = Object.fromEntries(Object.entries(raw).filter(([key]) => !reserved.has(key)));\n\t\treturn pkg;\n\t}\n\n\tpublic addDependency(name: string, version: string): this {\n\t\tthis._dependencies[name] = version;\n\t\treturn this;\n\t}\n\n\tpublic addDevDependency(name: string, version: string): this {\n\t\tthis._devDependencies[name] = version;\n\t\treturn this;\n\t}\n\n\tpublic addScript(name: string, command: string): this {\n\t\tthis._scripts[name] = command;\n\t\treturn this;\n\t}\n\n\tpublic files(): SourceFile[] {\n\t\treturn [\n\t\t\t{\n\t\t\t\tfilePath: \"package.json\",\n\t\t\t\tcontent: JSON.stringify(\n\t\t\t\t\t{\n\t\t\t\t\t\tname: this.name,\n\t\t\t\t\t\tversion: this._version,\n\t\t\t\t\t\ttype: this._type,\n\t\t\t\t\t\t...this._rest,\n\t\t\t\t\t\tscripts: this._scripts,\n\t\t\t\t\t\tdependencies: this._dependencies,\n\t\t\t\t\t\tdevDependencies: this._devDependencies,\n\t\t\t\t\t},\n\t\t\t\t\tnull,\n\t\t\t\t\t2,\n\t\t\t\t),\n\t\t\t},\n\t\t];\n\t}\n}\n\nfunction stripApiSuffix(name: string): string {\n\treturn name.endsWith(\".api\") ? name.slice(0, -\".api\".length) : name;\n}\n\nfunction asStringMap(value: unknown): Record<string, string> {\n\tif (value == null || typeof value !== \"object\") return {};\n\tconst result: Record<string, string> = {};\n\tfor (const [key, entry] of Object.entries(value)) {\n\t\tif (typeof entry === \"string\") result[key] = entry;\n\t}\n\treturn result;\n}\n\nfunction fluxDevScript(workspaceName: string, apiName: string, port: number): string {\n\treturn `PORT=${port} flux serve --project ${webapiPackageName(workspaceName, apiName)}`;\n}\n"],"names":["PackageJson","key","WELL_KNOWN_FILES","PACKAGE_JSON","_dependencies","_devDependencies","_scripts","_version","_type","_rest","name","options","apiNames","DEFAULT_WEBAPI_NAME","first","startEntry","webapiReleaseEntry","workspaceName","stripApiSuffix","namedOrMany","length","build","start","dev","fluxDevScript","webapiPort","typecheck","test","index","apiName","entries","CREATE_VERSION","typescript","vitest","fromFile","filePath","raw","JSON","parse","readFileSync","pkg","version","type","asStringMap","scripts","dependencies","devDependencies","reserved","Set","Object","fromEntries","filter","has","addDependency","addDevDependency","addScript","command","files","content","stringify","endsWith","slice","value","result","entry","port","webapiPackageName"],"mappings":"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"}

package/commonjs/src/models/project.model.js

@@ -83,6 +83,9 @@ class MonoRepoScaffold extends WorkspaceScaffold {
     /** Retrieve a previously-registered project by its directory path. */ getProject(dir) {
         return this._projects.find((p)=>p.dir === dir);
     }
+    /** All registered projects, in registration order. */ getProjects() {
+        return this._projects;
+    }
     /** Register a named model at workspace level. */ addModel(model) {
         this._models.set(model.key, model);
         return model;
@@ -128,4 +131,4 @@ class MonoRepoScaffold extends WorkspaceScaffold {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/models/project.model.ts"],"sourcesContent":["import { mkdir, writeFile } from \"node:fs/promises\";\nimport { basename, dirname, join } from \"node:path\";\nimport type { KeyedModel, SourceFile, SourceFileProvider } from \"./source-file.js\";\n\n/**\n * A sub-unit of the monorepo (e.g. `projects/api`).\n *\n * Models and files registered here produce paths relative to `dir`. The parent\n * `MonoRepoScaffold` calls `files()` and prepends `dir/` to every path, so\n * models remain unaware of where they live in the repo.\n */\nexport class ProjectScaffold {\n\tprivate readonly _models = new Map<string, SourceFileProvider>();\n\tprivate readonly _files: SourceFile[] = [];\n\n\tpublic constructor(public readonly dir: string) {}\n\n\tpublic addModel<T extends KeyedModel>(model: T): T {\n\t\tthis._models.set(model.key, model);\n\t\treturn model;\n\t}\n\n\tpublic addFile(provider: SourceFileProvider): this {\n\t\tthis._files.push(...provider.files());\n\t\treturn this;\n\t}\n\n\tpublic getModel<T extends SourceFileProvider>(key: string): T | undefined {\n\t\treturn this._models.get(key) as T | undefined;\n\t}\n\n\tpublic getModels<T extends SourceFileProvider>(ctor: new (...args: never[]) => T): T[] {\n\t\treturn [...this._models.values()].filter((m): m is T => m instanceof ctor);\n\t}\n\n\t/** Returns all files with `dir/` prepended to each path. */\n\tpublic files(): SourceFile[] {\n\t\tconst all = [...this._files, ...[...this._models.values()].flatMap((m) => m.files())];\n\t\treturn all.map((f) => ({ filePath: `${this.dir}/${f.filePath}`, content: f.content }));\n\t}\n}\n\nexport abstract class WorkspaceScaffold {\n\tpublic readonly files: SourceFile[] = [];\n\tpublic targetDir: string = process.cwd();\n\tprivate _name: string | undefined;\n\n\t/** Project name — host directory basename, not the in-container mount path. */\n\tpublic get name(): string {\n\t\treturn this._name ?? basename(this.targetDir);\n\t}\n\n\tpublic setName(name: string): this {\n\t\tthis._name = name;\n\t\treturn this;\n\t}\n\n\t/** Add an ad-hoc file provider whose output is included at render time. */\n\tpublic addFile(provider: SourceFileProvider): this {\n\t\tthis.files.push(...provider.files());\n\t\treturn this;\n\t}\n\n\tpublic abstract addModel<T extends KeyedModel>(model: T): T;\n\tpublic abstract getModel<T extends SourceFileProvider>(key: string): T | undefined;\n\tpublic abstract getModels<T extends SourceFileProvider>(\n\t\tctor: new (...args: never[]) => T,\n\t): T[];\n\tpublic abstract getProject(dir: string): ProjectScaffold | undefined;\n\tpublic abstract scaffold(): Promise<void> | void;\n}\n\nexport class MonoRepoScaffold extends WorkspaceScaffold {\n\tprivate readonly _models = new Map<string, SourceFileProvider>();\n\tprivate readonly _projects: ProjectScaffold[] = [];\n\n\t/** Register a named project. */\n\tpublic addProject(project: ProjectScaffold): ProjectScaffold {\n\t\tthis._projects.push(project);\n\t\treturn project;\n\t}\n\n\t/** Retrieve a previously-registered project by its directory path. */\n\tpublic getProject(dir: string): ProjectScaffold | undefined {\n\t\treturn this._projects.find((p) => p.dir === dir);\n\t}\n\n\t/** Register a named model at workspace level. */\n\tpublic addModel<T extends KeyedModel>(model: T): T {\n\t\tthis._models.set(model.key, model);\n\t\treturn model;\n\t}\n\n\t/**\n\t * Retrieve a model by key. Searches workspace models first, then all\n\t * registered projects in order.\n\t */\n\tpublic getModel<T extends SourceFileProvider>(key: string): T | undefined {\n\t\tconst m = this._models.get(key) as T | undefined;\n\t\tif (m !== undefined) return m;\n\t\tfor (const project of this._projects) {\n\t\t\tconst pm = project.getModel<T>(key);\n\t\t\tif (pm !== undefined) return pm;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Retrieve all models of a given type. Searches workspace models and all\n\t * projects, so features can discover controllers across multiple projects.\n\t */\n\tpublic getModels<T extends SourceFileProvider>(ctor: new (...args: never[]) => T): T[] {\n\t\treturn [\n\t\t\t...[...this._models.values()].filter((m): m is T => m instanceof ctor),\n\t\t\t...this._projects.flatMap((p) => p.getModels(ctor)),\n\t\t];\n\t}\n\n\t/** Render all models and projects into files, then write everything to disk. */\n\tpublic async scaffold(): Promise<void> {\n\t\tconst allFiles = [\n\t\t\t...this.files,\n\t\t\t...[...this._models.values()].flatMap((m) => m.files()),\n\t\t\t...this._projects.flatMap((p) => p.files()),\n\t\t];\n\n\t\tawait Promise.all(\n\t\t\tallFiles.map(async (file) => {\n\t\t\t\tconst fullPath = join(this.targetDir, file.filePath);\n\t\t\t\tawait mkdir(dirname(fullPath), { recursive: true });\n\t\t\t\tawait writeFile(fullPath, file.content);\n\t\t\t}),\n\t\t);\n\t}\n}\n"],"names":["MonoRepoScaffold","ProjectScaffold","WorkspaceScaffold","_models","Map","_files","dir","addModel","model","set","key","addFile","provider","push","files","getModel","get","getModels","ctor","values","filter","m","all","flatMap","map","f","filePath","content","targetDir","process","cwd","_name","name","basename","setName","_projects","addProject","project","getProject","find","p","undefined","pm","scaffold","allFiles","Promise","file","fullPath","join","mkdir","dirname","recursive","writeFile"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/models/project.model.ts"],"sourcesContent":["import { mkdir, writeFile } from \"node:fs/promises\";\nimport { basename, dirname, join } from \"node:path\";\nimport type { KeyedModel, SourceFile, SourceFileProvider } from \"./source-file.js\";\n\n/**\n * A sub-unit of the monorepo (e.g. `projects/api`).\n *\n * Models and files registered here produce paths relative to `dir`. The parent\n * `MonoRepoScaffold` calls `files()` and prepends `dir/` to every path, so\n * models remain unaware of where they live in the repo.\n */\nexport class ProjectScaffold {\n\tprivate readonly _models = new Map<string, SourceFileProvider>();\n\tprivate readonly _files: SourceFile[] = [];\n\n\tpublic constructor(public readonly dir: string) {}\n\n\tpublic addModel<T extends KeyedModel>(model: T): T {\n\t\tthis._models.set(model.key, model);\n\t\treturn model;\n\t}\n\n\tpublic addFile(provider: SourceFileProvider): this {\n\t\tthis._files.push(...provider.files());\n\t\treturn this;\n\t}\n\n\tpublic getModel<T extends SourceFileProvider>(key: string): T | undefined {\n\t\treturn this._models.get(key) as T | undefined;\n\t}\n\n\tpublic getModels<T extends SourceFileProvider>(ctor: new (...args: never[]) => T): T[] {\n\t\treturn [...this._models.values()].filter((m): m is T => m instanceof ctor);\n\t}\n\n\t/** Returns all files with `dir/` prepended to each path. */\n\tpublic files(): SourceFile[] {\n\t\tconst all = [...this._files, ...[...this._models.values()].flatMap((m) => m.files())];\n\t\treturn all.map((f) => ({ filePath: `${this.dir}/${f.filePath}`, content: f.content }));\n\t}\n}\n\nexport abstract class WorkspaceScaffold {\n\tpublic readonly files: SourceFile[] = [];\n\tpublic targetDir: string = process.cwd();\n\tprivate _name: string | undefined;\n\n\t/** Project name — host directory basename, not the in-container mount path. */\n\tpublic get name(): string {\n\t\treturn this._name ?? basename(this.targetDir);\n\t}\n\n\tpublic setName(name: string): this {\n\t\tthis._name = name;\n\t\treturn this;\n\t}\n\n\t/** Add an ad-hoc file provider whose output is included at render time. */\n\tpublic addFile(provider: SourceFileProvider): this {\n\t\tthis.files.push(...provider.files());\n\t\treturn this;\n\t}\n\n\tpublic abstract addModel<T extends KeyedModel>(model: T): T;\n\tpublic abstract getModel<T extends SourceFileProvider>(key: string): T | undefined;\n\tpublic abstract getModels<T extends SourceFileProvider>(\n\t\tctor: new (...args: never[]) => T,\n\t): T[];\n\tpublic abstract getProject(dir: string): ProjectScaffold | undefined;\n\tpublic abstract getProjects(): readonly ProjectScaffold[];\n\tpublic abstract scaffold(): Promise<void> | void;\n}\n\nexport class MonoRepoScaffold extends WorkspaceScaffold {\n\tprivate readonly _models = new Map<string, SourceFileProvider>();\n\tprivate readonly _projects: ProjectScaffold[] = [];\n\n\t/** Register a named project. */\n\tpublic addProject(project: ProjectScaffold): ProjectScaffold {\n\t\tthis._projects.push(project);\n\t\treturn project;\n\t}\n\n\t/** Retrieve a previously-registered project by its directory path. */\n\tpublic getProject(dir: string): ProjectScaffold | undefined {\n\t\treturn this._projects.find((p) => p.dir === dir);\n\t}\n\n\t/** All registered projects, in registration order. */\n\tpublic getProjects(): readonly ProjectScaffold[] {\n\t\treturn this._projects;\n\t}\n\n\t/** Register a named model at workspace level. */\n\tpublic addModel<T extends KeyedModel>(model: T): T {\n\t\tthis._models.set(model.key, model);\n\t\treturn model;\n\t}\n\n\t/**\n\t * Retrieve a model by key. Searches workspace models first, then all\n\t * registered projects in order.\n\t */\n\tpublic getModel<T extends SourceFileProvider>(key: string): T | undefined {\n\t\tconst m = this._models.get(key) as T | undefined;\n\t\tif (m !== undefined) return m;\n\t\tfor (const project of this._projects) {\n\t\t\tconst pm = project.getModel<T>(key);\n\t\t\tif (pm !== undefined) return pm;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Retrieve all models of a given type. Searches workspace models and all\n\t * projects, so features can discover controllers across multiple projects.\n\t */\n\tpublic getModels<T extends SourceFileProvider>(ctor: new (...args: never[]) => T): T[] {\n\t\treturn [\n\t\t\t...[...this._models.values()].filter((m): m is T => m instanceof ctor),\n\t\t\t...this._projects.flatMap((p) => p.getModels(ctor)),\n\t\t];\n\t}\n\n\t/** Render all models and projects into files, then write everything to disk. */\n\tpublic async scaffold(): Promise<void> {\n\t\tconst allFiles = [\n\t\t\t...this.files,\n\t\t\t...[...this._models.values()].flatMap((m) => m.files()),\n\t\t\t...this._projects.flatMap((p) => p.files()),\n\t\t];\n\n\t\tawait Promise.all(\n\t\t\tallFiles.map(async (file) => {\n\t\t\t\tconst fullPath = join(this.targetDir, file.filePath);\n\t\t\t\tawait mkdir(dirname(fullPath), { recursive: true });\n\t\t\t\tawait writeFile(fullPath, file.content);\n\t\t\t}),\n\t\t);\n\t}\n}\n"],"names":["MonoRepoScaffold","ProjectScaffold","WorkspaceScaffold","_models","Map","_files","dir","addModel","model","set","key","addFile","provider","push","files","getModel","get","getModels","ctor","values","filter","m","all","flatMap","map","f","filePath","content","targetDir","process","cwd","_name","name","basename","setName","_projects","addProject","project","getProject","find","p","getProjects","undefined","pm","scaffold","allFiles","Promise","file","fullPath","join","mkdir","dirname","recursive","writeFile"],"mappings":"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"}

package/commonjs/src/program.js

@@ -19,6 +19,7 @@ _export(exports, {
 const _commander = require("commander");
 const _resolvetargetdir = require("./resolve-target-dir.js");
 const _runner = require("./runner.js");
+const _apiname = require("./webapi/api-name.js");
 const _createapi = require("./webapi/create-api.js");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
@@ -61,30 +62,56 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+function collectName(value, previous) {
+    previous.push(value);
+    return previous;
+}
+function addWebapiFeatureOptions(cmd) {
+    return cmd.option("--database <provider>", "Database provider: none | postgres/typeorm").option("--auth <provider>", "Auth provider: none | auth0").option("--postman <provider>", "Postman provider: none | local | api").option("-y, --yes", "Install dependencies without prompting").option("--install <mode>", "Dependency install mode: ask | yes | no", "ask");
+}
+function toApiOptions(directory, opts, extra = {}) {
+    const installMode = String(opts.install ?? "ask").toLowerCase();
+    const names = Array.isArray(opts.name) ? opts.name : typeof opts.name === "string" ? [
+        opts.name
+    ] : extra.names;
+    return {
+        d: (0, _resolvetargetdir.resolveTargetDir)(directory, typeof opts.d === "string" ? opts.d : undefined),
+        databaseProvider: opts.database,
+        authProvider: opts.auth,
+        postmanProvider: opts.postman,
+        installDependencies: opts.yes === true ? "yes" : installMode === "yes" || installMode === "no" ? installMode : undefined,
+        names,
+        ...extra
+    };
+}
+async function runWebapi(normalized) {
+    (0, _apiname.parseApiNames)(normalized.names);
+    if (process.env.DECOHERE_BUILDER !== "1") {
+        (0, _runner.runInBuilder)(normalized);
+        return;
+    }
+    const { closePrompt } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./domain/prompt.js")));
+    try {
+        await (0, _createapi.scaffoldApi)(normalized);
+    } finally{
+        closePrompt();
+    }
+}
 function createProgram() {
     const program = new _commander.Command();
     program.exitOverride();
     program.name("decohere").description("Scaffold a new Decohere project").option("-d <directory>", "Target directory (default: current directory)", ".");
-    program.command("webapi").argument("[directory]", "Target directory (default: -d or current directory)").option("--database <provider>", "Database provider: none | postgres/typeorm").option("--auth <provider>", "Auth provider: none | auth0").option("--postman <provider>", "Postman provider: none | local | api").option("-y, --yes", "Install dependencies without prompting").option("--install <mode>", "Dependency install mode: ask | yes | no", "ask").action(async (directory, _opts, cmd)=>{
-        const opts = cmd.optsWithGlobals();
-        const installMode = String(opts.install ?? "ask").toLowerCase();
-        const normalized = {
-            d: (0, _resolvetargetdir.resolveTargetDir)(directory, typeof opts.d === "string" ? opts.d : undefined),
-            databaseProvider: opts.database,
-            authProvider: opts.auth,
-            postmanProvider: opts.postman,
-            installDependencies: opts.yes === true ? "yes" : installMode === "yes" || installMode === "no" ? installMode : undefined
-        };
-        if (process.env.DECOHERE_BUILDER !== "1") {
-            (0, _runner.runInBuilder)(normalized);
-            return;
-        }
-        const { closePrompt } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./domain/prompt.js")));
-        try {
-            await (0, _createapi.scaffoldApi)(normalized);
-        } finally{
-            closePrompt();
-        }
+    const webapi = addWebapiFeatureOptions(program.command("webapi").argument("[directory]", "Target directory (default: -d or current directory)").option("--name <slug>", "API name under projects/ (repeatable; default: api)", collectName, []));
+    webapi.action(async (directory, _opts, cmd)=>{
+        await runWebapi(toApiOptions(directory, cmd.optsWithGlobals()));
+    });
+    addWebapiFeatureOptions(webapi.command("add").argument("<name>", "API name under projects/")).action(async (name, _opts, cmd)=>{
+        await runWebapi(toApiOptions(undefined, cmd.optsWithGlobals(), {
+            names: [
+                name
+            ],
+            add: true
+        }));
     });
     return program;
 }
@@ -95,10 +122,14 @@ async function runCli(argv = process.argv) {
         if (err instanceof _commander.CommanderError) {
             process.exit(err.exitCode);
         }
+        if (err instanceof _apiname.CreateCliError) {
+            console.error(`\n  ${err.message}\n`);
+            process.exit(1);
+        }
         console.error(err);
         process.exit(1);
     }
     process.exit(process.exitCode ?? 0);
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/program.ts"],"sourcesContent":["import { Command, CommanderError } from \"commander\";\nimport { resolveTargetDir } from \"./resolve-target-dir.js\";\nimport { runInBuilder } from \"./runner.js\";\nimport { CreateCliError, parseApiNames } from \"./webapi/api-name.js\";\nimport type { ApiOptions } from \"./webapi/create-api.js\";\nimport { scaffoldApi } from \"./webapi/create-api.js\";\n\nfunction collectName(value: string, previous: string[]): string[] {\n\tprevious.push(value);\n\treturn previous;\n}\n\nfunction addWebapiFeatureOptions(cmd: Command): Command {\n\treturn cmd\n\t\t.option(\"--database <provider>\", \"Database provider: none | postgres/typeorm\")\n\t\t.option(\"--auth <provider>\", \"Auth provider: none | auth0\")\n\t\t.option(\"--postman <provider>\", \"Postman provider: none | local | api\")\n\t\t.option(\"-y, --yes\", \"Install dependencies without prompting\")\n\t\t.option(\"--install <mode>\", \"Dependency install mode: ask | yes | no\", \"ask\");\n}\n\nfunction toApiOptions(\n\tdirectory: string | undefined,\n\topts: Record<string, unknown>,\n\textra: Partial<ApiOptions> = {},\n): ApiOptions {\n\tconst installMode = String(opts.install ?? \"ask\").toLowerCase();\n\tconst names = Array.isArray(opts.name)\n\t\t? (opts.name as string[])\n\t\t: typeof opts.name === \"string\"\n\t\t\t? [opts.name]\n\t\t\t: extra.names;\n\treturn {\n\t\td: resolveTargetDir(directory, typeof opts.d === \"string\" ? opts.d : undefined),\n\t\tdatabaseProvider: opts.database as ApiOptions[\"databaseProvider\"],\n\t\tauthProvider: opts.auth as ApiOptions[\"authProvider\"],\n\t\tpostmanProvider: opts.postman as ApiOptions[\"postmanProvider\"],\n\t\tinstallDependencies:\n\t\t\topts.yes === true\n\t\t\t\t? \"yes\"\n\t\t\t\t: installMode === \"yes\" || installMode === \"no\"\n\t\t\t\t\t? installMode\n\t\t\t\t\t: undefined,\n\t\tnames,\n\t\t...extra,\n\t};\n}\n\nasync function runWebapi(normalized: ApiOptions): Promise<void> {\n\tparseApiNames(normalized.names);\n\tif (process.env.DECOHERE_BUILDER !== \"1\") {\n\t\trunInBuilder(normalized);\n\t\treturn;\n\t}\n\n\tconst { closePrompt } = await import(\"./domain/prompt.js\");\n\ttry {\n\t\tawait scaffoldApi(normalized);\n\t} finally {\n\t\tclosePrompt();\n\t}\n}\n\nexport function createProgram(): Command {\n\tconst program = new Command();\n\tprogram.exitOverride();\n\tprogram\n\t\t.name(\"decohere\")\n\t\t.description(\"Scaffold a new Decohere project\")\n\t\t.option(\"-d <directory>\", \"Target directory (default: current directory)\", \".\");\n\n\tconst webapi = addWebapiFeatureOptions(\n\t\tprogram\n\t\t\t.command(\"webapi\")\n\t\t\t.argument(\"[directory]\", \"Target directory (default: -d or current directory)\")\n\t\t\t.option(\n\t\t\t\t\"--name <slug>\",\n\t\t\t\t\"API name under projects/ (repeatable; default: api)\",\n\t\t\t\tcollectName,\n\t\t\t\t[] as string[],\n\t\t\t),\n\t);\n\twebapi.action(async (directory: string | undefined, _opts: unknown, cmd: Command) => {\n\t\tawait runWebapi(toApiOptions(directory, cmd.optsWithGlobals()));\n\t});\n\n\taddWebapiFeatureOptions(\n\t\twebapi.command(\"add\").argument(\"<name>\", \"API name under projects/\"),\n\t).action(async (name: string, _opts: unknown, cmd: Command) => {\n\t\tawait runWebapi(\n\t\t\ttoApiOptions(undefined, cmd.optsWithGlobals(), { names: [name], add: true }),\n\t\t);\n\t});\n\n\treturn program;\n}\n\nexport async function runCli(argv: string[] = process.argv): Promise<void> {\n\ttry {\n\t\tawait createProgram().parseAsync(argv);\n\t} catch (err) {\n\t\tif (err instanceof CommanderError) {\n\t\t\tprocess.exit(err.exitCode);\n\t\t}\n\t\tif (err instanceof CreateCliError) {\n\t\t\tconsole.error(`\\n  ${err.message}\\n`);\n\t\t\tprocess.exit(1);\n\t\t}\n\t\tconsole.error(err);\n\t\tprocess.exit(1);\n\t}\n\tprocess.exit(process.exitCode ?? 0);\n}\n"],"names":["createProgram","runCli","collectName","value","previous","push","addWebapiFeatureOptions","cmd","option","toApiOptions","directory","opts","extra","installMode","String","install","toLowerCase","names","Array","isArray","name","d","resolveTargetDir","undefined","databaseProvider","database","authProvider","auth","postmanProvider","postman","installDependencies","yes","runWebapi","normalized","parseApiNames","process","env","DECOHERE_BUILDER","runInBuilder","closePrompt","scaffoldApi","program","Command","exitOverride","description","webapi","command","argument","action","_opts","optsWithGlobals","add","argv","parseAsync","err","CommanderError","exit","exitCode","CreateCliError","console","error","message"],"mappings":"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"}