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

package/commonjs/src/webapi/models/main-source-file.model.js

@@ -48,6 +48,7 @@ class MainSourceFile {
     _entities = [];
     _repositories = [];
     _services = [];
+    _dataSourceName;
     _typeOrmSeed;
     constructor(appName){
         this.appName = appName;
@@ -81,6 +82,13 @@ class MainSourceFile {
         this._services.push(service);
         return this;
     }
+    /**
+	 * Datasource name passed to `withTypeOrm({ name })`. Must match
+	 * `database.dataSources[].name` in config.yaml.
+	 */ setDataSourceName(name) {
+        this._dataSourceName = name;
+        return this;
+    }
     /**
 	 * Inline seed callback body for `withTypeOrm({ seed })`.
 	 * Receives `dataSource` in scope. Example: `await dataSource.getRepository(User).save(...)`.
@@ -123,10 +131,11 @@ class MainSourceFile {
         if (this._entities.length > 0) {
             const entities = this._entities.map((e)=>e.className).join(", ");
             const repos = this._repositories.map((r)=>r.className).join(", ");
+            const named = this._dataSourceName != null ? `name: "${this._dataSourceName}", ` : "";
             if (this._typeOrmSeed) {
-                builderCalls.push(`\t.withTypeOrm({ entities: [${entities}], repositories: [${repos}], seed: async (dataSource) => { ${this._typeOrmSeed} } })`);
+                builderCalls.push(`\t.withTypeOrm({ ${named}entities: [${entities}], repositories: [${repos}], seed: async (dataSource) => { ${this._typeOrmSeed} } })`);
             } else {
-                builderCalls.push(`\t.withTypeOrm({ entities: [${entities}], repositories: [${repos}] })`);
+                builderCalls.push(`\t.withTypeOrm({ ${named}entities: [${entities}], repositories: [${repos}] })`);
             }
         }
         builderCalls.push(`\t.withControllers(HelloController)`);
@@ -153,4 +162,4 @@ class MainSourceFile {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/models/main-source-file.model.ts"],"sourcesContent":["import { WELL_KNOWN_FILES } from \"../../models/const.js\";\nimport type { KeyedModel, SourceFile } from \"../../models/source-file.js\";\n\nexport type TypeOrmImport = { className: string; importPath: string };\nexport type ServiceImport = TypeOrmImport & { scope?: \"singleton\" | \"request\" };\n\n/** Tracks named imports from a single module path, split into values and types. */\nclass ImportGroup {\n\tprivate readonly _values: string[] = [];\n\tprivate readonly _types: string[] = [];\n\n\tpublic add(name: string, typeOnly = false): this {\n\t\tif (typeOnly) {\n\t\t\t// Value import already present — value wins, skip\n\t\t\tif (!this._values.includes(name) && !this._types.includes(name)) {\n\t\t\t\tthis._types.push(name);\n\t\t\t}\n\t\t} else {\n\t\t\t// Promote: remove from types if it was previously type-only\n\t\t\tconst typeIdx = this._types.indexOf(name);\n\t\t\tif (typeIdx !== -1) this._types.splice(typeIdx, 1);\n\t\t\tif (!this._values.includes(name)) this._values.push(name);\n\t\t}\n\t\treturn this;\n\t}\n\n\tpublic render(from: string): string {\n\t\tconst values = [...this._values].sort();\n\t\tconst types = [...this._types].sort().map((n) => `type ${n}`);\n\t\treturn `import { ${[...values, ...types].join(\", \")} } from \"${from}\";`;\n\t}\n}\n\n/**\n * Model for `projects/api/src/main.ts`.\n *\n * Starts with the minimal HTTP + YAML config setup. Features mutate the model\n * by calling addSideEffectImport / addImport / addBuilderCall / addEntity /\n * addRepository. files() renders whatever has been accumulated.\n */\nexport class MainSourceFile implements KeyedModel {\n\tpublic readonly key = WELL_KNOWN_FILES.MAIN_TS;\n\n\tprivate readonly _sideEffectImports: string[] = [];\n\tprivate readonly _extraImports = new Map<string, ImportGroup>();\n\tprivate readonly _builderCalls: string[] = [];\n\tprivate readonly _entities: TypeOrmImport[] = [];\n\tprivate readonly _repositories: TypeOrmImport[] = [];\n\tprivate readonly _services: ServiceImport[] = [];\n\tprivate _typeOrmSeed: string | undefined;\n\n\tpublic constructor(private readonly appName: string) {}\n\n\t/** Adds a bare side-effect import, e.g. `@decohere/cortex/auth`. */\n\tpublic addSideEffectImport(path: string): this {\n\t\tif (!this._sideEffectImports.includes(path)) this._sideEffectImports.push(path);\n\t\treturn this;\n\t}\n\n\t/** Adds a named import, e.g. `import { Foo } from \"bar\"`. */\n\tpublic addImport(name: string, from: string, typeOnly = false): this {\n\t\tconst group = this._extraImports.get(from) ?? new ImportGroup();\n\t\tgroup.add(name, typeOnly);\n\t\tthis._extraImports.set(from, group);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a builder call inserted after `.withConfiguration()` and before\n\t * `.withServices()`. Pass the call without leading dot, e.g. `.withAuth()`.\n\t */\n\tpublic addBuilderCall(call: string): this {\n\t\tthis._builderCalls.push(call);\n\t\treturn this;\n\t}\n\n\t/** Adds a TypeORM entity — import and entry in `withTypeOrm({ entities })`. */\n\tpublic addEntity(entity: TypeOrmImport): this {\n\t\tthis._entities.push(entity);\n\t\treturn this;\n\t}\n\n\t/** Adds a TypeORM repository — import and entry in `withTypeOrm({ repositories })`. */\n\tpublic addRepository(repo: TypeOrmImport): this {\n\t\tthis._repositories.push(repo);\n\t\treturn this;\n\t}\n\n\t/** Adds a service registered in `.withServices()`. */\n\tpublic addService(service: ServiceImport): this {\n\t\tthis._services.push(service);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Inline seed callback body for `withTypeOrm({ seed })`.\n\t * Receives `dataSource` in scope. Example: `await dataSource.getRepository(User).save(...)`.\n\t */\n\tpublic setTypeOrmSeed(seedBody: string): this {\n\t\tthis._typeOrmSeed = seedBody;\n\t\treturn this;\n\t}\n\n\tpublic files(): SourceFile[] {\n\t\tconst imports: string[] = [\n\t\t\t'import \"@decohere/scribe-pino\";',\n\t\t\t'import \"@decohere/cortex/http\";',\n\t\t];\n\n\t\tfor (const path of this._sideEffectImports) {\n\t\t\timports.push(`import \"${path}\";`);\n\t\t}\n\n\t\timports.push(\n\t\t\t'import \"@decohere/protocol\";',\n\t\t\t'import { YamlDataSource } from \"@decohere/protocol\";',\n\t\t\t'import { Builder } from \"@decohere/cortex\";',\n\t\t\t'import { FastifyProvider } from \"@decohere/cortex/providers\";',\n\t\t\t'import { scribe } from \"@decohere/scribe\";',\n\t\t\t'import { SampleService } from \"./services/sample.service.js\";',\n\t\t);\n\n\t\tfor (const e of this._entities) {\n\t\t\timports.push(`import { ${e.className} } from \"${e.importPath}\";`);\n\t\t}\n\n\t\tfor (const r of this._repositories) {\n\t\t\timports.push(`import { ${r.className} } from \"${r.importPath}\";`);\n\t\t}\n\n\t\tfor (const s of this._services) {\n\t\t\timports.push(`import { ${s.className} } from \"${s.importPath}\";`);\n\t\t}\n\n\t\tfor (const [from, group] of this._extraImports) {\n\t\t\timports.push(group.render(from));\n\t\t}\n\n\t\timports.push('import { HelloController } from \"./controllers/hello.controller.js\";');\n\n\t\tconst serviceRegs = [\n\t\t\t\"cb.registerSingleton(SampleService);\",\n\t\t\t...this._services.map((s) =>\n\t\t\t\ts.scope === \"request\"\n\t\t\t\t\t? `cb.registerRequestScoped(${s.className});`\n\t\t\t\t\t: `cb.registerSingleton(${s.className});`,\n\t\t\t),\n\t\t].join(\" \");\n\n\t\tconst builderCalls: string[] = [\n\t\t\t`\\t.withHttpProvider(FastifyProvider)`,\n\t\t\t`\\t.withConfiguration(YamlDataSource)`,\n\t\t\t...this._builderCalls.map((c) => `\\t${c}`),\n\t\t\t`\\t.withServices((cb) => { ${serviceRegs} })`,\n\t\t];\n\n\t\tif (this._entities.length > 0) {\n\t\t\tconst entities = this._entities.map((e) => e.className).join(\", \");\n\t\t\tconst repos = this._repositories.map((r) => r.className).join(\", \");\n\t\t\tif (this._typeOrmSeed) {\n\t\t\t\tbuilderCalls.push(\n\t\t\t\t\t`\\t.withTypeOrm({ entities: [${entities}], repositories: [${repos}], seed: async (dataSource) => { ${this._typeOrmSeed} } })`,\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tbuilderCalls.push(\n\t\t\t\t\t`\\t.withTypeOrm({ entities: [${entities}], repositories: [${repos}] })`,\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\n\t\tbuilderCalls.push(`\\t.withControllers(HelloController)`);\n\n\t\tconst content = [\n\t\t\t...imports,\n\t\t\t\"\",\n\t\t\t\"scribe.extend.withPinoPretty();\",\n\t\t\t\"\",\n\t\t\t`const app = await Builder.create({ applicationName: \"${this.appName}\" })`,\n\t\t\t...builderCalls,\n\t\t\t`\\t.build();`,\n\t\t\t\"\",\n\t\t\t\"await app.start({ port: Number(process.env.PORT) || 3000 });\",\n\t\t\t\"\",\n\t\t\t\"export default app;\",\n\t\t\t\"\",\n\t\t].join(\"\\n\");\n\n\t\treturn [\n\t\t\t{\n\t\t\t\tfilePath: \"src/main.ts\",\n\t\t\t\tcontent,\n\t\t\t},\n\t\t];\n\t}\n}\n"],"names":["MainSourceFile","ImportGroup","_values","_types","add","name","typeOnly","includes","push","typeIdx","indexOf","splice","render","from","values","sort","types","map","n","join","key","WELL_KNOWN_FILES","MAIN_TS","_sideEffectImports","_extraImports","Map","_builderCalls","_entities","_repositories","_services","_typeOrmSeed","appName","addSideEffectImport","path","addImport","group","get","set","addBuilderCall","call","addEntity","entity","addRepository","repo","addService","service","setTypeOrmSeed","seedBody","files","imports","e","className","importPath","r","s","serviceRegs","scope","builderCalls","c","length","entities","repos","content","filePath"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/models/main-source-file.model.ts"],"sourcesContent":["import { WELL_KNOWN_FILES } from \"../../models/const.js\";\nimport type { KeyedModel, SourceFile } from \"../../models/source-file.js\";\n\nexport type TypeOrmImport = { className: string; importPath: string };\nexport type ServiceImport = TypeOrmImport & { scope?: \"singleton\" | \"request\" };\n\n/** Tracks named imports from a single module path, split into values and types. */\nclass ImportGroup {\n\tprivate readonly _values: string[] = [];\n\tprivate readonly _types: string[] = [];\n\n\tpublic add(name: string, typeOnly = false): this {\n\t\tif (typeOnly) {\n\t\t\t// Value import already present — value wins, skip\n\t\t\tif (!this._values.includes(name) && !this._types.includes(name)) {\n\t\t\t\tthis._types.push(name);\n\t\t\t}\n\t\t} else {\n\t\t\t// Promote: remove from types if it was previously type-only\n\t\t\tconst typeIdx = this._types.indexOf(name);\n\t\t\tif (typeIdx !== -1) this._types.splice(typeIdx, 1);\n\t\t\tif (!this._values.includes(name)) this._values.push(name);\n\t\t}\n\t\treturn this;\n\t}\n\n\tpublic render(from: string): string {\n\t\tconst values = [...this._values].sort();\n\t\tconst types = [...this._types].sort().map((n) => `type ${n}`);\n\t\treturn `import { ${[...values, ...types].join(\", \")} } from \"${from}\";`;\n\t}\n}\n\n/**\n * Model for `projects/api/src/main.ts`.\n *\n * Starts with the minimal HTTP + YAML config setup. Features mutate the model\n * by calling addSideEffectImport / addImport / addBuilderCall / addEntity /\n * addRepository. files() renders whatever has been accumulated.\n */\nexport class MainSourceFile implements KeyedModel {\n\tpublic readonly key = WELL_KNOWN_FILES.MAIN_TS;\n\n\tprivate readonly _sideEffectImports: string[] = [];\n\tprivate readonly _extraImports = new Map<string, ImportGroup>();\n\tprivate readonly _builderCalls: string[] = [];\n\tprivate readonly _entities: TypeOrmImport[] = [];\n\tprivate readonly _repositories: TypeOrmImport[] = [];\n\tprivate readonly _services: ServiceImport[] = [];\n\tprivate _dataSourceName: string | undefined;\n\tprivate _typeOrmSeed: string | undefined;\n\n\tpublic constructor(private readonly appName: string) {}\n\n\t/** Adds a bare side-effect import, e.g. `@decohere/cortex/auth`. */\n\tpublic addSideEffectImport(path: string): this {\n\t\tif (!this._sideEffectImports.includes(path)) this._sideEffectImports.push(path);\n\t\treturn this;\n\t}\n\n\t/** Adds a named import, e.g. `import { Foo } from \"bar\"`. */\n\tpublic addImport(name: string, from: string, typeOnly = false): this {\n\t\tconst group = this._extraImports.get(from) ?? new ImportGroup();\n\t\tgroup.add(name, typeOnly);\n\t\tthis._extraImports.set(from, group);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a builder call inserted after `.withConfiguration()` and before\n\t * `.withServices()`. Pass the call without leading dot, e.g. `.withAuth()`.\n\t */\n\tpublic addBuilderCall(call: string): this {\n\t\tthis._builderCalls.push(call);\n\t\treturn this;\n\t}\n\n\t/** Adds a TypeORM entity — import and entry in `withTypeOrm({ entities })`. */\n\tpublic addEntity(entity: TypeOrmImport): this {\n\t\tthis._entities.push(entity);\n\t\treturn this;\n\t}\n\n\t/** Adds a TypeORM repository — import and entry in `withTypeOrm({ repositories })`. */\n\tpublic addRepository(repo: TypeOrmImport): this {\n\t\tthis._repositories.push(repo);\n\t\treturn this;\n\t}\n\n\t/** Adds a service registered in `.withServices()`. */\n\tpublic addService(service: ServiceImport): this {\n\t\tthis._services.push(service);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Datasource name passed to `withTypeOrm({ name })`. Must match\n\t * `database.dataSources[].name` in config.yaml.\n\t */\n\tpublic setDataSourceName(name: string): this {\n\t\tthis._dataSourceName = name;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Inline seed callback body for `withTypeOrm({ seed })`.\n\t * Receives `dataSource` in scope. Example: `await dataSource.getRepository(User).save(...)`.\n\t */\n\tpublic setTypeOrmSeed(seedBody: string): this {\n\t\tthis._typeOrmSeed = seedBody;\n\t\treturn this;\n\t}\n\n\tpublic files(): SourceFile[] {\n\t\tconst imports: string[] = [\n\t\t\t'import \"@decohere/scribe-pino\";',\n\t\t\t'import \"@decohere/cortex/http\";',\n\t\t];\n\n\t\tfor (const path of this._sideEffectImports) {\n\t\t\timports.push(`import \"${path}\";`);\n\t\t}\n\n\t\timports.push(\n\t\t\t'import \"@decohere/protocol\";',\n\t\t\t'import { YamlDataSource } from \"@decohere/protocol\";',\n\t\t\t'import { Builder } from \"@decohere/cortex\";',\n\t\t\t'import { FastifyProvider } from \"@decohere/cortex/providers\";',\n\t\t\t'import { scribe } from \"@decohere/scribe\";',\n\t\t\t'import { SampleService } from \"./services/sample.service.js\";',\n\t\t);\n\n\t\tfor (const e of this._entities) {\n\t\t\timports.push(`import { ${e.className} } from \"${e.importPath}\";`);\n\t\t}\n\n\t\tfor (const r of this._repositories) {\n\t\t\timports.push(`import { ${r.className} } from \"${r.importPath}\";`);\n\t\t}\n\n\t\tfor (const s of this._services) {\n\t\t\timports.push(`import { ${s.className} } from \"${s.importPath}\";`);\n\t\t}\n\n\t\tfor (const [from, group] of this._extraImports) {\n\t\t\timports.push(group.render(from));\n\t\t}\n\n\t\timports.push('import { HelloController } from \"./controllers/hello.controller.js\";');\n\n\t\tconst serviceRegs = [\n\t\t\t\"cb.registerSingleton(SampleService);\",\n\t\t\t...this._services.map((s) =>\n\t\t\t\ts.scope === \"request\"\n\t\t\t\t\t? `cb.registerRequestScoped(${s.className});`\n\t\t\t\t\t: `cb.registerSingleton(${s.className});`,\n\t\t\t),\n\t\t].join(\" \");\n\n\t\tconst builderCalls: string[] = [\n\t\t\t`\\t.withHttpProvider(FastifyProvider)`,\n\t\t\t`\\t.withConfiguration(YamlDataSource)`,\n\t\t\t...this._builderCalls.map((c) => `\\t${c}`),\n\t\t\t`\\t.withServices((cb) => { ${serviceRegs} })`,\n\t\t];\n\n\t\tif (this._entities.length > 0) {\n\t\t\tconst entities = this._entities.map((e) => e.className).join(\", \");\n\t\t\tconst repos = this._repositories.map((r) => r.className).join(\", \");\n\t\t\tconst named = this._dataSourceName != null ? `name: \"${this._dataSourceName}\", ` : \"\";\n\t\t\tif (this._typeOrmSeed) {\n\t\t\t\tbuilderCalls.push(\n\t\t\t\t\t`\\t.withTypeOrm({ ${named}entities: [${entities}], repositories: [${repos}], seed: async (dataSource) => { ${this._typeOrmSeed} } })`,\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tbuilderCalls.push(\n\t\t\t\t\t`\\t.withTypeOrm({ ${named}entities: [${entities}], repositories: [${repos}] })`,\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\n\t\tbuilderCalls.push(`\\t.withControllers(HelloController)`);\n\n\t\tconst content = [\n\t\t\t...imports,\n\t\t\t\"\",\n\t\t\t\"scribe.extend.withPinoPretty();\",\n\t\t\t\"\",\n\t\t\t`const app = await Builder.create({ applicationName: \"${this.appName}\" })`,\n\t\t\t...builderCalls,\n\t\t\t`\\t.build();`,\n\t\t\t\"\",\n\t\t\t\"await app.start({ port: Number(process.env.PORT) || 3000 });\",\n\t\t\t\"\",\n\t\t\t\"export default app;\",\n\t\t\t\"\",\n\t\t].join(\"\\n\");\n\n\t\treturn [\n\t\t\t{\n\t\t\t\tfilePath: \"src/main.ts\",\n\t\t\t\tcontent,\n\t\t\t},\n\t\t];\n\t}\n}\n"],"names":["MainSourceFile","ImportGroup","_values","_types","add","name","typeOnly","includes","push","typeIdx","indexOf","splice","render","from","values","sort","types","map","n","join","key","WELL_KNOWN_FILES","MAIN_TS","_sideEffectImports","_extraImports","Map","_builderCalls","_entities","_repositories","_services","_dataSourceName","_typeOrmSeed","appName","addSideEffectImport","path","addImport","group","get","set","addBuilderCall","call","addEntity","entity","addRepository","repo","addService","service","setDataSourceName","setTypeOrmSeed","seedBody","files","imports","e","className","importPath","r","s","serviceRegs","scope","builderCalls","c","length","entities","repos","named","content","filePath"],"mappings":"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"}

package/commonjs/src/webapi/models/production-dockerfile.model.js

@@ -2,20 +2,68 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "WebapiProductionDockerfile", {
-    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 WebapiProductionDockerfile () {
         return WebapiProductionDockerfile;
+    },
+    get renderProductionDockerfile () {
+        return renderProductionDockerfile;
     }
 });
 const _const = require("../../models/const.js");
 const _const1 = require("../const.js");
 class WebapiProductionDockerfile {
+    apiNames;
+    options;
     key = _const.WELL_KNOWN_FILES.PRODUCTION_DOCKERFILE;
+    constructor(apiNames = [
+        _const1.DEFAULT_WEBAPI_NAME
+    ], options = {}){
+        this.apiNames = apiNames;
+        this.options = options;
+    }
     files() {
-        const content = `# syntax=docker/dockerfile:1
+        const names = this.apiNames.length > 0 ? this.apiNames : [
+            _const1.DEFAULT_WEBAPI_NAME
+        ];
+        const first = names[0] ?? _const1.DEFAULT_WEBAPI_NAME;
+        const files = [];
+        if (!this.options.namedOnly) {
+            files.push({
+                filePath: ".dockerignore",
+                content: dockerignoreContent()
+            });
+            files.push({
+                filePath: "Dockerfile",
+                content: renderProductionDockerfile(first, "start")
+            });
+        }
+        const emitNamed = this.options.namedOnly || names.length > 1 || first !== _const1.DEFAULT_WEBAPI_NAME;
+        if (emitNamed) {
+            for (const name of names){
+                files.push({
+                    filePath: `Dockerfile.${name}`,
+                    content: renderProductionDockerfile(name, `start:${name}`)
+                });
+            }
+        }
+        return files;
+    }
+}
+function renderProductionDockerfile(apiName, startScript) {
+    const projectDir = (0, _const1.webapiProjectDir)(apiName);
+    const startCmd = startScript === "start" ? 'CMD ["pnpm", "start"]' : `CMD ["pnpm", "run", "${startScript}"]`;
+    const startEntry = (0, _const1.webapiReleaseEntry)(apiName);
+    return `# syntax=docker/dockerfile:1
 # Self-contained production image: install + forge build happen inside docker build.
 # Hosts (Railway/Fly/etc.) clone git and run \`docker build\` — they do not receive CI dist/.
+# Build from the repo root: docker build -f Dockerfile${startScript === "start" ? "" : `.${apiName}`} .
 #
 # Private @decohere/* packages: pass a BuildKit secret named npm_token (npm auth token), e.g.
 #   docker build --secret id=npm_token,env=NODE_AUTH_TOKEN .
@@ -29,7 +77,7 @@ COPY package.json ./
 COPY pnpm-lock.yaml* ./
 COPY tsconfig.json biome.json ./
 COPY config ./config
-COPY ${_const1.WEBAPI_PROJECT_DIR} ./${_const1.WEBAPI_PROJECT_DIR}
+COPY ${projectDir} ./${projectDir}
 
 ARG NODE_AUTH_TOKEN=
 RUN --mount=type=secret,id=npm_token,required=false \\
@@ -60,39 +108,31 @@ COPY --from=build /app/pnpm-lock.yaml* ./
 COPY --from=build /app/config ./config
 COPY --from=build /app/dist ./dist
 COPY --from=build /app/node_modules ./node_modules
-COPY --from=build /app/${_const1.WEBAPI_PROJECT_DIR}/package.json ./${_const1.WEBAPI_PROJECT_DIR}/package.json
+COPY --from=build /app/${projectDir}/package.json ./${projectDir}/package.json
 
 EXPOSE 3000
-CMD ["pnpm", "start"]
-# Entry resolved by package.json "start" → node ${_const1.WEBAPI_RELEASE_ENTRY}
+${startCmd}
+# Entry resolved by package.json "${startScript}" → node ${startEntry}
 `;
-        return [
-            {
-                filePath: "Dockerfile",
-                content
-            },
-            {
-                filePath: ".dockerignore",
-                content: [
-                    "node_modules",
-                    "dist",
-                    ".git",
-                    ".devcontainer",
-                    ".vscode",
-                    ".github",
-                    "postman",
-                    ".postman",
-                    ".env",
-                    ".env.*",
-                    "!.env.example",
-                    "coverage",
-                    "**/*.spec.ts",
-                    "**/*.test.ts",
-                    ""
-                ].join("\n")
-            }
-        ];
-    }
+}
+function dockerignoreContent() {
+    return [
+        "node_modules",
+        "dist",
+        ".git",
+        ".devcontainer",
+        ".vscode",
+        ".github",
+        "postman",
+        ".postman",
+        ".env",
+        ".env.*",
+        "!.env.example",
+        "coverage",
+        "**/*.spec.ts",
+        "**/*.test.ts",
+        ""
+    ].join("\n");
 }
 
-//# 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/webapi/models/production-dockerfile.model.ts"],"sourcesContent":["import { WELL_KNOWN_FILES } from \"../../models/const.js\";\nimport type { KeyedModel, SourceFile } from \"../../models/source-file.js\";\nimport { DEFAULT_WEBAPI_NAME, webapiProjectDir, webapiReleaseEntry } from \"../const.js\";\n\nexport type ProductionDockerfileOptions = {\n\t/** When true, only write `Dockerfile.<name>` (existing workspace — do not replace root Dockerfile). */\n\tnamedOnly?: boolean;\n};\n\n/**\n * Production Dockerfiles for PaaS (Railway/Fly) and local `docker build`.\n *\n * Context is always the **repo root** (`docker build -f Dockerfile.billing .`).\n * Root `Dockerfile` is the first API (`pnpm start`). Extra or custom-named APIs\n * also get `Dockerfile.<name>` so each service can be deployed on its own.\n */\nexport class WebapiProductionDockerfile implements KeyedModel {\n\tpublic readonly key = WELL_KNOWN_FILES.PRODUCTION_DOCKERFILE;\n\n\tpublic constructor(\n\t\tprivate readonly apiNames: readonly string[] = [DEFAULT_WEBAPI_NAME],\n\t\tprivate readonly options: ProductionDockerfileOptions = {},\n\t) {}\n\n\tpublic files(): SourceFile[] {\n\t\tconst names = this.apiNames.length > 0 ? this.apiNames : [DEFAULT_WEBAPI_NAME];\n\t\tconst first = names[0] ?? DEFAULT_WEBAPI_NAME;\n\t\tconst files: SourceFile[] = [];\n\n\t\tif (!this.options.namedOnly) {\n\t\t\tfiles.push({\n\t\t\t\tfilePath: \".dockerignore\",\n\t\t\t\tcontent: dockerignoreContent(),\n\t\t\t});\n\t\t\tfiles.push({\n\t\t\t\tfilePath: \"Dockerfile\",\n\t\t\t\tcontent: renderProductionDockerfile(first, \"start\"),\n\t\t\t});\n\t\t}\n\n\t\tconst emitNamed =\n\t\t\tthis.options.namedOnly || names.length > 1 || first !== DEFAULT_WEBAPI_NAME;\n\t\tif (emitNamed) {\n\t\t\tfor (const name of names) {\n\t\t\t\tfiles.push({\n\t\t\t\t\tfilePath: `Dockerfile.${name}`,\n\t\t\t\t\tcontent: renderProductionDockerfile(name, `start:${name}`),\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\treturn files;\n\t}\n}\n\nexport function renderProductionDockerfile(apiName: string, startScript: string): string {\n\tconst projectDir = webapiProjectDir(apiName);\n\tconst startCmd =\n\t\tstartScript === \"start\"\n\t\t\t? 'CMD [\"pnpm\", \"start\"]'\n\t\t\t: `CMD [\"pnpm\", \"run\", \"${startScript}\"]`;\n\tconst startEntry = webapiReleaseEntry(apiName);\n\n\treturn `# syntax=docker/dockerfile:1\n# Self-contained production image: install + forge build happen inside docker build.\n# Hosts (Railway/Fly/etc.) clone git and run \\`docker build\\` — they do not receive CI dist/.\n# Build from the repo root: docker build -f Dockerfile${startScript === \"start\" ? \"\" : `.${apiName}`} .\n#\n# Private @decohere/* packages: pass a BuildKit secret named npm_token (npm auth token), e.g.\n#   docker build --secret id=npm_token,env=NODE_AUTH_TOKEN .\n# Or set NODE_AUTH_TOKEN as a build-arg on hosts that only support build-args.\n\nFROM node:24-bookworm AS build\nWORKDIR /app\nRUN corepack enable && corepack prepare pnpm@10 --activate\n\nCOPY package.json ./\nCOPY pnpm-lock.yaml* ./\nCOPY tsconfig.json biome.json ./\nCOPY config ./config\nCOPY ${projectDir} ./${projectDir}\n\nARG NODE_AUTH_TOKEN=\nRUN --mount=type=secret,id=npm_token,required=false \\\\\n\tif [ -f /run/secrets/npm_token ]; then \\\\\n\t\tTOKEN=\"$(cat /run/secrets/npm_token)\"; \\\\\n\telse \\\\\n\t\tTOKEN=\"\\${NODE_AUTH_TOKEN}\"; \\\\\n\tfi; \\\\\n\tif [ -n \"$TOKEN\" ]; then \\\\\n\t\techo \"//registry.npmjs.org/:_authToken=\\${TOKEN}\" > .npmrc; \\\\\n\tfi; \\\\\n\tif [ -f pnpm-lock.yaml ]; then \\\\\n\t\tpnpm install --frozen-lockfile; \\\\\n\telse \\\\\n\t\tpnpm install; \\\\\n\tfi; \\\\\n\trm -f .npmrc\n\nRUN pnpm run build\n\nFROM node:24-bookworm-slim AS run\nWORKDIR /app\nENV NODE_ENV=production\nRUN corepack enable && corepack prepare pnpm@10 --activate\n\nCOPY --from=build /app/package.json ./\nCOPY --from=build /app/pnpm-lock.yaml* ./\nCOPY --from=build /app/config ./config\nCOPY --from=build /app/dist ./dist\nCOPY --from=build /app/node_modules ./node_modules\nCOPY --from=build /app/${projectDir}/package.json ./${projectDir}/package.json\n\nEXPOSE 3000\n${startCmd}\n# Entry resolved by package.json \"${startScript}\" → node ${startEntry}\n`;\n}\n\nfunction dockerignoreContent(): string {\n\treturn [\n\t\t\"node_modules\",\n\t\t\"dist\",\n\t\t\".git\",\n\t\t\".devcontainer\",\n\t\t\".vscode\",\n\t\t\".github\",\n\t\t\"postman\",\n\t\t\".postman\",\n\t\t\".env\",\n\t\t\".env.*\",\n\t\t\"!.env.example\",\n\t\t\"coverage\",\n\t\t\"**/*.spec.ts\",\n\t\t\"**/*.test.ts\",\n\t\t\"\",\n\t].join(\"\\n\");\n}\n"],"names":["WebapiProductionDockerfile","renderProductionDockerfile","key","WELL_KNOWN_FILES","PRODUCTION_DOCKERFILE","apiNames","DEFAULT_WEBAPI_NAME","options","files","names","length","first","namedOnly","push","filePath","content","dockerignoreContent","emitNamed","name","apiName","startScript","projectDir","webapiProjectDir","startCmd","startEntry","webapiReleaseEntry","join"],"mappings":";;;;;;;;;;;QAgBaA;eAAAA;;QAuCGC;eAAAA;;;uBAvDiB;wBAEyC;AAcnE,MAAMD;;;IACIE,MAAMC,uBAAgB,CAACC,qBAAqB,CAAC;IAE7D,YACC,AAAiBC,WAA8B;QAACC,2BAAmB;KAAC,EACpE,AAAiBC,UAAuC,CAAC,CAAC,CACzD;aAFgBF,WAAAA;aACAE,UAAAA;IACf;IAEIC,QAAsB;QAC5B,MAAMC,QAAQ,IAAI,CAACJ,QAAQ,CAACK,MAAM,GAAG,IAAI,IAAI,CAACL,QAAQ,GAAG;YAACC,2BAAmB;SAAC;QAC9E,MAAMK,QAAQF,KAAK,CAAC,EAAE,IAAIH,2BAAmB;QAC7C,MAAME,QAAsB,EAAE;QAE9B,IAAI,CAAC,IAAI,CAACD,OAAO,CAACK,SAAS,EAAE;YAC5BJ,MAAMK,IAAI,CAAC;gBACVC,UAAU;gBACVC,SAASC;YACV;YACAR,MAAMK,IAAI,CAAC;gBACVC,UAAU;gBACVC,SAASd,2BAA2BU,OAAO;YAC5C;QACD;QAEA,MAAMM,YACL,IAAI,CAACV,OAAO,CAACK,SAAS,IAAIH,MAAMC,MAAM,GAAG,KAAKC,UAAUL,2BAAmB;QAC5E,IAAIW,WAAW;YACd,KAAK,MAAMC,QAAQT,MAAO;gBACzBD,MAAMK,IAAI,CAAC;oBACVC,UAAU,CAAC,WAAW,EAAEI,MAAM;oBAC9BH,SAASd,2BAA2BiB,MAAM,CAAC,MAAM,EAAEA,MAAM;gBAC1D;YACD;QACD;QAEA,OAAOV;IACR;AACD;AAEO,SAASP,2BAA2BkB,OAAe,EAAEC,WAAmB;IAC9E,MAAMC,aAAaC,IAAAA,wBAAgB,EAACH;IACpC,MAAMI,WACLH,gBAAgB,UACb,0BACA,CAAC,qBAAqB,EAAEA,YAAY,EAAE,CAAC;IAC3C,MAAMI,aAAaC,IAAAA,0BAAkB,EAACN;IAEtC,OAAO,CAAC;;;sDAG6C,EAAEC,gBAAgB,UAAU,KAAK,CAAC,CAAC,EAAED,SAAS,CAAC;;;;;;;;;;;;;;KAchG,EAAEE,WAAW,GAAG,EAAEA,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA+BX,EAAEA,WAAW,gBAAgB,EAAEA,WAAW;;;AAGjE,EAAEE,SAAS;kCACuB,EAAEH,YAAY,SAAS,EAAEI,WAAW;AACtE,CAAC;AACD;AAEA,SAASR;IACR,OAAO;QACN;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;KACA,CAACU,IAAI,CAAC;AACR"}

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

@@ -1,3 +1,4 @@
+import { readFileSync } from "node:fs";
 /**
  * Builder for a YAML config file (e.g. config/config.yaml or config/config.dev.yaml).
  *
@@ -17,6 +18,25 @@
         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 = readFileSync(absolutePath, "utf8");
+        return new ConfigYaml(key, relativePath, content);
+    }
     files() {
         return [
             {
@@ -26,5 +46,31 @@
         ];
     }
 }
+/** Insert a YAML list item under `dataSources:`; append a new `database:` block if missing. */ export 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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvbW9kZWxzL2NvbmZpZy15YW1sLm1vZGVsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgS2V5ZWRNb2RlbCwgU291cmNlRmlsZSB9IGZyb20gXCIuL3NvdXJjZS1maWxlLmpzXCI7XG5cbi8qKlxuICogQnVpbGRlciBmb3IgYSBZQU1MIGNvbmZpZyBmaWxlIChlLmcuIGNvbmZpZy9jb25maWcueWFtbCBvciBjb25maWcvY29uZmlnLmRldi55YW1sKS5cbiAqXG4gKiBTdGFydHMgd2l0aCBhIGJhc2Ugc2VjdGlvbiBwYXNzZWQgdG8gdGhlIGNvbnN0cnVjdG9yLiBGZWF0dXJlcyBjYWxsXG4gKiBgYWRkU2VjdGlvbih5YW1sKWAgZHVyaW5nIHRoZWlyIHNjYWZmb2xkIHBoYXNlIHRvIGFwcGVuZCB0aGVpciBvd24gYmxvY2suXG4gKiBgZmlsZXMoKWAgam9pbnMgYWxsIHNlY3Rpb25zIHdpdGggYSBibGFuayBsaW5lIHNlcGFyYXRvci5cbiAqL1xuZXhwb3J0IGNsYXNzIENvbmZpZ1lhbWwgaW1wbGVtZW50cyBLZXllZE1vZGVsIHtcblx0cHJpdmF0ZSByZWFkb25seSBfc2VjdGlvbnM6IHN0cmluZ1tdID0gW107XG5cblx0cHVibGljIGNvbnN0cnVjdG9yKFxuXHRcdHB1YmxpYyByZWFkb25seSBrZXk6IHN0cmluZyxcblx0XHRwcml2YXRlIHJlYWRvbmx5IGZpbGVQYXRoOiBzdHJpbmcsXG5cdFx0YmFzZUNvbnRlbnQ6IHN0cmluZyxcblx0KSB7XG5cdFx0dGhpcy5fc2VjdGlvbnMucHVzaChiYXNlQ29udGVudCk7XG5cdH1cblxuXHRwdWJsaWMgYWRkU2VjdGlvbih5YW1sOiBzdHJpbmcpOiB0aGlzIHtcblx0XHR0aGlzLl9zZWN0aW9ucy5wdXNoKHlhbWwpO1xuXHRcdHJldHVybiB0aGlzO1xuXHR9XG5cblx0cHVibGljIGZpbGVzKCk6IFNvdXJjZUZpbGVbXSB7XG5cdFx0cmV0dXJuIFt7IGZpbGVQYXRoOiB0aGlzLmZpbGVQYXRoLCBjb250ZW50OiB0aGlzLl9zZWN0aW9ucy5qb2luKFwiXFxuXCIpIH1dO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiQ29uZmlnWWFtbCIsIl9zZWN0aW9ucyIsImtleSIsImZpbGVQYXRoIiwiYmFzZUNvbnRlbnQiLCJwdXNoIiwiYWRkU2VjdGlvbiIsInlhbWwiLCJmaWxlcyIsImNvbnRlbnQiLCJqb2luIl0sIm1hcHBpbmdzIjoiQUFFQTs7Ozs7O0NBTUMsR0FDRCxPQUFPLE1BQU1BOzs7SUFDS0MsWUFBc0IsRUFBRSxDQUFDO0lBRTFDLFlBQ0MsQUFBZ0JDLEdBQVcsRUFDM0IsQUFBaUJDLFFBQWdCLEVBQ2pDQyxXQUFtQixDQUNsQjthQUhlRixNQUFBQTthQUNDQyxXQUFBQTtRQUdqQixJQUFJLENBQUNGLFNBQVMsQ0FBQ0ksSUFBSSxDQUFDRDtJQUNyQjtJQUVPRSxXQUFXQyxJQUFZLEVBQVE7UUFDckMsSUFBSSxDQUFDTixTQUFTLENBQUNJLElBQUksQ0FBQ0U7UUFDcEIsT0FBTyxJQUFJO0lBQ1o7SUFFT0MsUUFBc0I7UUFDNUIsT0FBTztZQUFDO2dCQUFFTCxVQUFVLElBQUksQ0FBQ0EsUUFBUTtnQkFBRU0sU0FBUyxJQUFJLENBQUNSLFNBQVMsQ0FBQ1MsSUFBSSxDQUFDO1lBQU07U0FBRTtJQUN6RTtBQUNEIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvbW9kZWxzL2NvbmZpZy15YW1sLm1vZGVsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHJlYWRGaWxlU3luYyB9IGZyb20gXCJub2RlOmZzXCI7XG5pbXBvcnQgdHlwZSB7IEtleWVkTW9kZWwsIFNvdXJjZUZpbGUgfSBmcm9tIFwiLi9zb3VyY2UtZmlsZS5qc1wiO1xuXG4vKipcbiAqIEJ1aWxkZXIgZm9yIGEgWUFNTCBjb25maWcgZmlsZSAoZS5nLiBjb25maWcvY29uZmlnLnlhbWwgb3IgY29uZmlnL2NvbmZpZy5kZXYueWFtbCkuXG4gKlxuICogU3RhcnRzIHdpdGggYSBiYXNlIHNlY3Rpb24gcGFzc2VkIHRvIHRoZSBjb25zdHJ1Y3Rvci4gRmVhdHVyZXMgY2FsbFxuICogYGFkZFNlY3Rpb24oeWFtbClgIGR1cmluZyB0aGVpciBzY2FmZm9sZCBwaGFzZSB0byBhcHBlbmQgdGhlaXIgb3duIGJsb2NrLlxuICogYGZpbGVzKClgIGpvaW5zIGFsbCBzZWN0aW9ucyB3aXRoIGEgYmxhbmsgbGluZSBzZXBhcmF0b3IuXG4gKi9cbmV4cG9ydCBjbGFzcyBDb25maWdZYW1sIGltcGxlbWVudHMgS2V5ZWRNb2RlbCB7XG5cdHByaXZhdGUgcmVhZG9ubHkgX3NlY3Rpb25zOiBzdHJpbmdbXSA9IFtdO1xuXG5cdHB1YmxpYyBjb25zdHJ1Y3Rvcihcblx0XHRwdWJsaWMgcmVhZG9ubHkga2V5OiBzdHJpbmcsXG5cdFx0cHJpdmF0ZSByZWFkb25seSBmaWxlUGF0aDogc3RyaW5nLFxuXHRcdGJhc2VDb250ZW50OiBzdHJpbmcsXG5cdCkge1xuXHRcdHRoaXMuX3NlY3Rpb25zLnB1c2goYmFzZUNvbnRlbnQpO1xuXHR9XG5cblx0cHVibGljIGFkZFNlY3Rpb24oeWFtbDogc3RyaW5nKTogdGhpcyB7XG5cdFx0dGhpcy5fc2VjdGlvbnMucHVzaCh5YW1sKTtcblx0XHRyZXR1cm4gdGhpcztcblx0fVxuXG5cdC8qKiBUcnVlIHdoZW4gYSBkYXRhc291cmNlIHdpdGggdGhpcyBgbmFtZTpgIGFscmVhZHkgYXBwZWFycyBpbiB0aGUgZmlsZS4gKi9cblx0cHVibGljIGhhc0RhdGFTb3VyY2UobmFtZTogc3RyaW5nKTogYm9vbGVhbiB7XG5cdFx0cmV0dXJuIHRoaXMuX3NlY3Rpb25zLmpvaW4oXCJcXG5cIikuaW5jbHVkZXMoYG5hbWU6ICR7bmFtZX1cXG5gKTtcblx0fVxuXG5cdHB1YmxpYyBoYXNEYXRhU291cmNlcygpOiBib29sZWFuIHtcblx0XHRyZXR1cm4gdGhpcy5fc2VjdGlvbnMuam9pbihcIlxcblwiKS5pbmNsdWRlcyhcImRhdGFTb3VyY2VzOlwiKTtcblx0fVxuXG5cdC8qKlxuXHQgKiBJbnNlcnQgYSBgZGF0YVNvdXJjZXNgIGxpc3QgaXRlbS4gVXNlZCBieSBgd2ViYXBpIGFkZGAgc28gd2UgZG8gbm90IHdyaXRlIGFcblx0ICogc2Vjb25kIHRvcC1sZXZlbCBgZGF0YWJhc2U6YCBrZXkgKFlBTUwgbGFzdC1rZXktd2lucykuXG5cdCAqL1xuXHRwdWJsaWMgYXBwZW5kRGF0YVNvdXJjZShpdGVtOiBzdHJpbmcpOiB0aGlzIHtcblx0XHRjb25zdCBjdXJyZW50ID0gdGhpcy5fc2VjdGlvbnMuam9pbihcIlxcblwiKTtcblx0XHR0aGlzLl9zZWN0aW9ucy5sZW5ndGggPSAwO1xuXHRcdHRoaXMuX3NlY3Rpb25zLnB1c2goaW5qZWN0WWFtbERhdGFTb3VyY2UoY3VycmVudCwgaXRlbSkpO1xuXHRcdHJldHVybiB0aGlzO1xuXHR9XG5cblx0cHVibGljIHN0YXRpYyBmcm9tRmlsZShrZXk6IHN0cmluZywgcmVsYXRpdmVQYXRoOiBzdHJpbmcsIGFic29sdXRlUGF0aDogc3RyaW5nKTogQ29uZmlnWWFtbCB7XG5cdFx0Y29uc3QgY29udGVudCA9IHJlYWRGaWxlU3luYyhhYnNvbHV0ZVBhdGgsIFwidXRmOFwiKTtcblx0XHRyZXR1cm4gbmV3IENvbmZpZ1lhbWwoa2V5LCByZWxhdGl2ZVBhdGgsIGNvbnRlbnQpO1xuXHR9XG5cblx0cHVibGljIGZpbGVzKCk6IFNvdXJjZUZpbGVbXSB7XG5cdFx0cmV0dXJuIFt7IGZpbGVQYXRoOiB0aGlzLmZpbGVQYXRoLCBjb250ZW50OiB0aGlzLl9zZWN0aW9ucy5qb2luKFwiXFxuXCIpIH1dO1xuXHR9XG59XG5cbi8qKiBJbnNlcnQgYSBZQU1MIGxpc3QgaXRlbSB1bmRlciBgZGF0YVNvdXJjZXM6YDsgYXBwZW5kIGEgbmV3IGBkYXRhYmFzZTpgIGJsb2NrIGlmIG1pc3NpbmcuICovXG5leHBvcnQgZnVuY3Rpb24gaW5qZWN0WWFtbERhdGFTb3VyY2UoeWFtbDogc3RyaW5nLCBpdGVtOiBzdHJpbmcpOiBzdHJpbmcge1xuXHRjb25zdCBibG9jayA9IGl0ZW0ucmVwbGFjZSgvXFxuJC8sIFwiXCIpO1xuXHRpZiAoIXlhbWwuaW5jbHVkZXMoXCJkYXRhU291cmNlczpcIikpIHtcblx0XHRjb25zdCBwcmVmaXggPSB5YW1sLnRyaW1FbmQoKTtcblx0XHRjb25zdCBzZWN0aW9uID0gYGRhdGFiYXNlOlxcbiAgZGF0YVNvdXJjZXM6XFxuJHtibG9ja31cXG5gO1xuXHRcdHJldHVybiBwcmVmaXgubGVuZ3RoID4gMCA/IGAke3ByZWZpeH1cXG5cXG4ke3NlY3Rpb259YCA6IHNlY3Rpb247XG5cdH1cblx0Y29uc3QgbGluZXMgPSB5YW1sLnNwbGl0KFwiXFxuXCIpO1xuXHRjb25zdCBkc0luZGV4ID0gbGluZXMuZmluZEluZGV4KChsaW5lKSA9PiAvXlxccypkYXRhU291cmNlczpcXHMqJC8udGVzdChsaW5lKSk7XG5cdGlmIChkc0luZGV4IDwgMCkge1xuXHRcdHJldHVybiBgJHt5YW1sLnRyaW1FbmQoKX1cXG5cXG5kYXRhYmFzZTpcXG4gIGRhdGFTb3VyY2VzOlxcbiR7YmxvY2t9XFxuYDtcblx0fVxuXHRsZXQgaW5zZXJ0QXQgPSBsaW5lcy5sZW5ndGg7XG5cdGZvciAobGV0IGkgPSBkc0luZGV4ICsgMTsgaSA8IGxpbmVzLmxlbmd0aDsgaSsrKSB7XG5cdFx0aWYgKC9eW0EtWmEtel0vLnRlc3QobGluZXNbaV0gPz8gXCJcIikpIHtcblx0XHRcdGluc2VydEF0ID0gaTtcblx0XHRcdGJyZWFrO1xuXHRcdH1cblx0fVxuXHRjb25zdCBpbnNlcnRMaW5lcyA9IGJsb2NrLnNwbGl0KFwiXFxuXCIpO1xuXHRpZiAoaW5zZXJ0QXQgPCBsaW5lcy5sZW5ndGggJiYgbGluZXNbaW5zZXJ0QXQgLSAxXSAhPT0gXCJcIikge1xuXHRcdGluc2VydExpbmVzLnB1c2goXCJcIik7XG5cdH1cblx0bGluZXMuc3BsaWNlKGluc2VydEF0LCAwLCAuLi5pbnNlcnRMaW5lcyk7XG5cdHJldHVybiBsaW5lcy5qb2luKFwiXFxuXCIpO1xufVxuIl0sIm5hbWVzIjpbInJlYWRGaWxlU3luYyIsIkNvbmZpZ1lhbWwiLCJfc2VjdGlvbnMiLCJrZXkiLCJmaWxlUGF0aCIsImJhc2VDb250ZW50IiwicHVzaCIsImFkZFNlY3Rpb24iLCJ5YW1sIiwiaGFzRGF0YVNvdXJjZSIsIm5hbWUiLCJqb2luIiwiaW5jbHVkZXMiLCJoYXNEYXRhU291cmNlcyIsImFwcGVuZERhdGFTb3VyY2UiLCJpdGVtIiwiY3VycmVudCIsImxlbmd0aCIsImluamVjdFlhbWxEYXRhU291cmNlIiwiZnJvbUZpbGUiLCJyZWxhdGl2ZVBhdGgiLCJhYnNvbHV0ZVBhdGgiLCJjb250ZW50IiwiZmlsZXMiLCJibG9jayIsInJlcGxhY2UiLCJwcmVmaXgiLCJ0cmltRW5kIiwic2VjdGlvbiIsImxpbmVzIiwic3BsaXQiLCJkc0luZGV4IiwiZmluZEluZGV4IiwibGluZSIsInRlc3QiLCJpbnNlcnRBdCIsImkiLCJpbnNlcnRMaW5lcyIsInNwbGljZSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsWUFBWSxRQUFRLFVBQVU7QUFHdkM7Ozs7OztDQU1DLEdBQ0QsT0FBTyxNQUFNQzs7O0lBQ0tDLFlBQXNCLEVBQUUsQ0FBQztJQUUxQyxZQUNDLEFBQWdCQyxHQUFXLEVBQzNCLEFBQWlCQyxRQUFnQixFQUNqQ0MsV0FBbUIsQ0FDbEI7YUFIZUYsTUFBQUE7YUFDQ0MsV0FBQUE7UUFHakIsSUFBSSxDQUFDRixTQUFTLENBQUNJLElBQUksQ0FBQ0Q7SUFDckI7SUFFT0UsV0FBV0MsSUFBWSxFQUFRO1FBQ3JDLElBQUksQ0FBQ04sU0FBUyxDQUFDSSxJQUFJLENBQUNFO1FBQ3BCLE9BQU8sSUFBSTtJQUNaO0lBRUEsMEVBQTBFLEdBQzFFLEFBQU9DLGNBQWNDLElBQVksRUFBVztRQUMzQyxPQUFPLElBQUksQ0FBQ1IsU0FBUyxDQUFDUyxJQUFJLENBQUMsTUFBTUMsUUFBUSxDQUFDLENBQUMsTUFBTSxFQUFFRixLQUFLLEVBQUUsQ0FBQztJQUM1RDtJQUVPRyxpQkFBMEI7UUFDaEMsT0FBTyxJQUFJLENBQUNYLFNBQVMsQ0FBQ1MsSUFBSSxDQUFDLE1BQU1DLFFBQVEsQ0FBQztJQUMzQztJQUVBOzs7RUFHQyxHQUNELEFBQU9FLGlCQUFpQkMsSUFBWSxFQUFRO1FBQzNDLE1BQU1DLFVBQVUsSUFBSSxDQUFDZCxTQUFTLENBQUNTLElBQUksQ0FBQztRQUNwQyxJQUFJLENBQUNULFNBQVMsQ0FBQ2UsTUFBTSxHQUFHO1FBQ3hCLElBQUksQ0FBQ2YsU0FBUyxDQUFDSSxJQUFJLENBQUNZLHFCQUFxQkYsU0FBU0Q7UUFDbEQsT0FBTyxJQUFJO0lBQ1o7SUFFQSxPQUFjSSxTQUFTaEIsR0FBVyxFQUFFaUIsWUFBb0IsRUFBRUMsWUFBb0IsRUFBYztRQUMzRixNQUFNQyxVQUFVdEIsYUFBYXFCLGNBQWM7UUFDM0MsT0FBTyxJQUFJcEIsV0FBV0UsS0FBS2lCLGNBQWNFO0lBQzFDO0lBRU9DLFFBQXNCO1FBQzVCLE9BQU87WUFBQztnQkFBRW5CLFVBQVUsSUFBSSxDQUFDQSxRQUFRO2dCQUFFa0IsU0FBUyxJQUFJLENBQUNwQixTQUFTLENBQUNTLElBQUksQ0FBQztZQUFNO1NBQUU7SUFDekU7QUFDRDtBQUVBLDZGQUE2RixHQUM3RixPQUFPLFNBQVNPLHFCQUFxQlYsSUFBWSxFQUFFTyxJQUFZO0lBQzlELE1BQU1TLFFBQVFULEtBQUtVLE9BQU8sQ0FBQyxPQUFPO0lBQ2xDLElBQUksQ0FBQ2pCLEtBQUtJLFFBQVEsQ0FBQyxpQkFBaUI7UUFDbkMsTUFBTWMsU0FBU2xCLEtBQUttQixPQUFPO1FBQzNCLE1BQU1DLFVBQVUsQ0FBQywyQkFBMkIsRUFBRUosTUFBTSxFQUFFLENBQUM7UUFDdkQsT0FBT0UsT0FBT1QsTUFBTSxHQUFHLElBQUksR0FBR1MsT0FBTyxJQUFJLEVBQUVFLFNBQVMsR0FBR0E7SUFDeEQ7SUFDQSxNQUFNQyxRQUFRckIsS0FBS3NCLEtBQUssQ0FBQztJQUN6QixNQUFNQyxVQUFVRixNQUFNRyxTQUFTLENBQUMsQ0FBQ0MsT0FBUyx1QkFBdUJDLElBQUksQ0FBQ0Q7SUFDdEUsSUFBSUYsVUFBVSxHQUFHO1FBQ2hCLE9BQU8sR0FBR3ZCLEtBQUttQixPQUFPLEdBQUcsK0JBQStCLEVBQUVILE1BQU0sRUFBRSxDQUFDO0lBQ3BFO0lBQ0EsSUFBSVcsV0FBV04sTUFBTVosTUFBTTtJQUMzQixJQUFLLElBQUltQixJQUFJTCxVQUFVLEdBQUdLLElBQUlQLE1BQU1aLE1BQU0sRUFBRW1CLElBQUs7UUFDaEQsSUFBSSxZQUFZRixJQUFJLENBQUNMLEtBQUssQ0FBQ08sRUFBRSxJQUFJLEtBQUs7WUFDckNELFdBQVdDO1lBQ1g7UUFDRDtJQUNEO0lBQ0EsTUFBTUMsY0FBY2IsTUFBTU0sS0FBSyxDQUFDO0lBQ2hDLElBQUlLLFdBQVdOLE1BQU1aLE1BQU0sSUFBSVksS0FBSyxDQUFDTSxXQUFXLEVBQUUsS0FBSyxJQUFJO1FBQzFERSxZQUFZL0IsSUFBSSxDQUFDO0lBQ2xCO0lBQ0F1QixNQUFNUyxNQUFNLENBQUNILFVBQVUsTUFBTUU7SUFDN0IsT0FBT1IsTUFBTWxCLElBQUksQ0FBQztBQUNuQiJ9

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

@@ -1,3 +1,4 @@
+import { readFileSync } from "node:fs";
 import { WELL_KNOWN_FILES } from "./const.js";
 /**
  * Accumulates key=value pairs and renders them as a `.env` file.
@@ -12,6 +13,18 @@ import { WELL_KNOWN_FILES } from "./const.js";
         this._entries.set(key, value);
         return this;
     }
+    static fromFile(absolutePath) {
+        const env = new EnvFile();
+        const raw = 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 = [
@@ -27,4 +40,4 @@ import { WELL_KNOWN_FILES } from "./const.js";
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,42 +1,64 @@
 import { WELL_KNOWN_FILES } from "./const.js";
 export class LaunchJson {
+    apiNames;
     key = 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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