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

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

@@ -44,6 +44,7 @@ import { WELL_KNOWN_FILES } from "../../models/const.js";
     _entities = [];
     _repositories = [];
     _services = [];
+    _dataSourceName;
     _typeOrmSeed;
     constructor(appName){
         this.appName = appName;
@@ -77,6 +78,13 @@ import { WELL_KNOWN_FILES } from "../../models/const.js";
         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(...)`.
@@ -119,10 +127,11 @@ import { WELL_KNOWN_FILES } from "../../models/const.js";
         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)`);
@@ -149,4 +158,4 @@ import { WELL_KNOWN_FILES } from "../../models/const.js";
     }
 }
 
-//# 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":["WELL_KNOWN_FILES","ImportGroup","_values","_types","add","name","typeOnly","includes","push","typeIdx","indexOf","splice","render","from","values","sort","types","map","n","join","MainSourceFile","key","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":"AAAA,SAASA,gBAAgB,QAAQ,wBAAwB;AAMzD,iFAAiF,GACjF,MAAMC;IACYC,UAAoB,EAAE,CAAC;IACvBC,SAAmB,EAAE,CAAC;IAEhCC,IAAIC,IAAY,EAAEC,WAAW,KAAK,EAAQ;QAChD,IAAIA,UAAU;YACb,kDAAkD;YAClD,IAAI,CAAC,IAAI,CAACJ,OAAO,CAACK,QAAQ,CAACF,SAAS,CAAC,IAAI,CAACF,MAAM,CAACI,QAAQ,CAACF,OAAO;gBAChE,IAAI,CAACF,MAAM,CAACK,IAAI,CAACH;YAClB;QACD,OAAO;YACN,4DAA4D;YAC5D,MAAMI,UAAU,IAAI,CAACN,MAAM,CAACO,OAAO,CAACL;YACpC,IAAII,YAAY,CAAC,GAAG,IAAI,CAACN,MAAM,CAACQ,MAAM,CAACF,SAAS;YAChD,IAAI,CAAC,IAAI,CAACP,OAAO,CAACK,QAAQ,CAACF,OAAO,IAAI,CAACH,OAAO,CAACM,IAAI,CAACH;QACrD;QACA,OAAO,IAAI;IACZ;IAEOO,OAAOC,IAAY,EAAU;QACnC,MAAMC,SAAS;eAAI,IAAI,CAACZ,OAAO;SAAC,CAACa,IAAI;QACrC,MAAMC,QAAQ;eAAI,IAAI,CAACb,MAAM;SAAC,CAACY,IAAI,GAAGE,GAAG,CAAC,CAACC,IAAM,CAAC,KAAK,EAAEA,GAAG;QAC5D,OAAO,CAAC,SAAS,EAAE;eAAIJ;eAAWE;SAAM,CAACG,IAAI,CAAC,MAAM,SAAS,EAAEN,KAAK,EAAE,CAAC;IACxE;AACD;AAEA;;;;;;CAMC,GACD,OAAO,MAAMO;;IACIC,MAAMrB,iBAAiBsB,OAAO,CAAC;IAE9BC,qBAA+B,EAAE,CAAC;IAClCC,gBAAgB,IAAIC,MAA2B;IAC/CC,gBAA0B,EAAE,CAAC;IAC7BC,YAA6B,EAAE,CAAC;IAChCC,gBAAiC,EAAE,CAAC;IACpCC,YAA6B,EAAE,CAAC;IACzCC,aAAiC;IAEzC,YAAmB,AAAiBC,OAAe,CAAE;aAAjBA,UAAAA;IAAkB;IAEtD,kEAAkE,GAClE,AAAOC,oBAAoBC,IAAY,EAAQ;QAC9C,IAAI,CAAC,IAAI,CAACV,kBAAkB,CAAChB,QAAQ,CAAC0B,OAAO,IAAI,CAACV,kBAAkB,CAACf,IAAI,CAACyB;QAC1E,OAAO,IAAI;IACZ;IAEA,2DAA2D,GAC3D,AAAOC,UAAU7B,IAAY,EAAEQ,IAAY,EAAEP,WAAW,KAAK,EAAQ;QACpE,MAAM6B,QAAQ,IAAI,CAACX,aAAa,CAACY,GAAG,CAACvB,SAAS,IAAIZ;QAClDkC,MAAM/B,GAAG,CAACC,MAAMC;QAChB,IAAI,CAACkB,aAAa,CAACa,GAAG,CAACxB,MAAMsB;QAC7B,OAAO,IAAI;IACZ;IAEA;;;EAGC,GACD,AAAOG,eAAeC,IAAY,EAAQ;QACzC,IAAI,CAACb,aAAa,CAAClB,IAAI,CAAC+B;QACxB,OAAO,IAAI;IACZ;IAEA,6EAA6E,GAC7E,AAAOC,UAAUC,MAAqB,EAAQ;QAC7C,IAAI,CAACd,SAAS,CAACnB,IAAI,CAACiC;QACpB,OAAO,IAAI;IACZ;IAEA,qFAAqF,GACrF,AAAOC,cAAcC,IAAmB,EAAQ;QAC/C,IAAI,CAACf,aAAa,CAACpB,IAAI,CAACmC;QACxB,OAAO,IAAI;IACZ;IAEA,oDAAoD,GACpD,AAAOC,WAAWC,OAAsB,EAAQ;QAC/C,IAAI,CAAChB,SAAS,CAACrB,IAAI,CAACqC;QACpB,OAAO,IAAI;IACZ;IAEA;;;EAGC,GACD,AAAOC,eAAeC,QAAgB,EAAQ;QAC7C,IAAI,CAACjB,YAAY,GAAGiB;QACpB,OAAO,IAAI;IACZ;IAEOC,QAAsB;QAC5B,MAAMC,UAAoB;YACzB;YACA;SACA;QAED,KAAK,MAAMhB,QAAQ,IAAI,CAACV,kBAAkB,CAAE;YAC3C0B,QAAQzC,IAAI,CAAC,CAAC,QAAQ,EAAEyB,KAAK,EAAE,CAAC;QACjC;QAEAgB,QAAQzC,IAAI,CACX,gCACA,wDACA,+CACA,iEACA,8CACA;QAGD,KAAK,MAAM0C,KAAK,IAAI,CAACvB,SAAS,CAAE;YAC/BsB,QAAQzC,IAAI,CAAC,CAAC,SAAS,EAAE0C,EAAEC,SAAS,CAAC,SAAS,EAAED,EAAEE,UAAU,CAAC,EAAE,CAAC;QACjE;QAEA,KAAK,MAAMC,KAAK,IAAI,CAACzB,aAAa,CAAE;YACnCqB,QAAQzC,IAAI,CAAC,CAAC,SAAS,EAAE6C,EAAEF,SAAS,CAAC,SAAS,EAAEE,EAAED,UAAU,CAAC,EAAE,CAAC;QACjE;QAEA,KAAK,MAAME,KAAK,IAAI,CAACzB,SAAS,CAAE;YAC/BoB,QAAQzC,IAAI,CAAC,CAAC,SAAS,EAAE8C,EAAEH,SAAS,CAAC,SAAS,EAAEG,EAAEF,UAAU,CAAC,EAAE,CAAC;QACjE;QAEA,KAAK,MAAM,CAACvC,MAAMsB,MAAM,IAAI,IAAI,CAACX,aAAa,CAAE;YAC/CyB,QAAQzC,IAAI,CAAC2B,MAAMvB,MAAM,CAACC;QAC3B;QAEAoC,QAAQzC,IAAI,CAAC;QAEb,MAAM+C,cAAc;YACnB;eACG,IAAI,CAAC1B,SAAS,CAACZ,GAAG,CAAC,CAACqC,IACtBA,EAAEE,KAAK,KAAK,YACT,CAAC,yBAAyB,EAAEF,EAAEH,SAAS,CAAC,EAAE,CAAC,GAC3C,CAAC,qBAAqB,EAAEG,EAAEH,SAAS,CAAC,EAAE,CAAC;SAE3C,CAAChC,IAAI,CAAC;QAEP,MAAMsC,eAAyB;YAC9B,CAAC,oCAAoC,CAAC;YACtC,CAAC,oCAAoC,CAAC;eACnC,IAAI,CAAC/B,aAAa,CAACT,GAAG,CAAC,CAACyC,IAAM,CAAC,EAAE,EAAEA,GAAG;YACzC,CAAC,0BAA0B,EAAEH,YAAY,GAAG,CAAC;SAC7C;QAED,IAAI,IAAI,CAAC5B,SAAS,CAACgC,MAAM,GAAG,GAAG;YAC9B,MAAMC,WAAW,IAAI,CAACjC,SAAS,CAACV,GAAG,CAAC,CAACiC,IAAMA,EAAEC,SAAS,EAAEhC,IAAI,CAAC;YAC7D,MAAM0C,QAAQ,IAAI,CAACjC,aAAa,CAACX,GAAG,CAAC,CAACoC,IAAMA,EAAEF,SAAS,EAAEhC,IAAI,CAAC;YAC9D,IAAI,IAAI,CAACW,YAAY,EAAE;gBACtB2B,aAAajD,IAAI,CAChB,CAAC,4BAA4B,EAAEoD,SAAS,kBAAkB,EAAEC,MAAM,iCAAiC,EAAE,IAAI,CAAC/B,YAAY,CAAC,KAAK,CAAC;YAE/H,OAAO;gBACN2B,aAAajD,IAAI,CAChB,CAAC,4BAA4B,EAAEoD,SAAS,kBAAkB,EAAEC,MAAM,IAAI,CAAC;YAEzE;QACD;QAEAJ,aAAajD,IAAI,CAAC,CAAC,mCAAmC,CAAC;QAEvD,MAAMsD,UAAU;eACZb;YACH;YACA;YACA;YACA,CAAC,qDAAqD,EAAE,IAAI,CAAClB,OAAO,CAAC,IAAI,CAAC;eACvE0B;YACH,CAAC,WAAW,CAAC;YACb;YACA;YACA;YACA;YACA;SACA,CAACtC,IAAI,CAAC;QAEP,OAAO;YACN;gBACC4C,UAAU;gBACVD;YACD;SACA;IACF;AACD"}
+//# 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":["WELL_KNOWN_FILES","ImportGroup","_values","_types","add","name","typeOnly","includes","push","typeIdx","indexOf","splice","render","from","values","sort","types","map","n","join","MainSourceFile","key","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/es6/src/webapi/models/production-dockerfile.model.js

@@ -1,14 +1,57 @@
 import { WELL_KNOWN_FILES } from "../../models/const.js";
-import { WEBAPI_PROJECT_DIR, WEBAPI_RELEASE_ENTRY } from "../const.js";
+import { DEFAULT_WEBAPI_NAME, webapiProjectDir, webapiReleaseEntry } from "../const.js";
 /**
- * Repo-root production Dockerfile for PaaS (Railway/Fly) and local `docker build`.
- * Runs conventional `pnpm run build` / `pnpm start` so Nixpacks and Docker share scripts.
+ * Production Dockerfiles for PaaS (Railway/Fly) and local `docker build`.
+ *
+ * Context is always the **repo root** (`docker build -f Dockerfile.billing .`).
+ * Root `Dockerfile` is the first API (`pnpm start`). Extra or custom-named APIs
+ * also get `Dockerfile.<name>` so each service can be deployed on its own.
  */ export class WebapiProductionDockerfile {
+    apiNames;
+    options;
     key = WELL_KNOWN_FILES.PRODUCTION_DOCKERFILE;
+    constructor(apiNames = [
+        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 : [
+            DEFAULT_WEBAPI_NAME
+        ];
+        const first = names[0] ?? 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 !== DEFAULT_WEBAPI_NAME;
+        if (emitNamed) {
+            for (const name of names){
+                files.push({
+                    filePath: `Dockerfile.${name}`,
+                    content: renderProductionDockerfile(name, `start:${name}`)
+                });
+            }
+        }
+        return files;
+    }
+}
+export function renderProductionDockerfile(apiName, startScript) {
+    const projectDir = webapiProjectDir(apiName);
+    const startCmd = startScript === "start" ? 'CMD ["pnpm", "start"]' : `CMD ["pnpm", "run", "${startScript}"]`;
+    const startEntry = 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 .
@@ -22,7 +65,7 @@ COPY package.json ./
 COPY pnpm-lock.yaml* ./
 COPY tsconfig.json biome.json ./
 COPY config ./config
-COPY ${WEBAPI_PROJECT_DIR} ./${WEBAPI_PROJECT_DIR}
+COPY ${projectDir} ./${projectDir}
 
 ARG NODE_AUTH_TOKEN=
 RUN --mount=type=secret,id=npm_token,required=false \\
@@ -53,39 +96,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/${WEBAPI_PROJECT_DIR}/package.json ./${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 ${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":["WELL_KNOWN_FILES","DEFAULT_WEBAPI_NAME","webapiProjectDir","webapiReleaseEntry","WebapiProductionDockerfile","key","PRODUCTION_DOCKERFILE","apiNames","options","files","names","length","first","namedOnly","push","filePath","content","dockerignoreContent","renderProductionDockerfile","emitNamed","name","apiName","startScript","projectDir","startCmd","startEntry","join"],"mappings":"AAAA,SAASA,gBAAgB,QAAQ,wBAAwB;AAEzD,SAASC,mBAAmB,EAAEC,gBAAgB,EAAEC,kBAAkB,QAAQ,cAAc;AAOxF;;;;;;CAMC,GACD,OAAO,MAAMC;;;IACIC,MAAML,iBAAiBM,qBAAqB,CAAC;IAE7D,YACC,AAAiBC,WAA8B;QAACN;KAAoB,EACpE,AAAiBO,UAAuC,CAAC,CAAC,CACzD;aAFgBD,WAAAA;aACAC,UAAAA;IACf;IAEIC,QAAsB;QAC5B,MAAMC,QAAQ,IAAI,CAACH,QAAQ,CAACI,MAAM,GAAG,IAAI,IAAI,CAACJ,QAAQ,GAAG;YAACN;SAAoB;QAC9E,MAAMW,QAAQF,KAAK,CAAC,EAAE,IAAIT;QAC1B,MAAMQ,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,SAASE,2BAA2BN,OAAO;YAC5C;QACD;QAEA,MAAMO,YACL,IAAI,CAACX,OAAO,CAACK,SAAS,IAAIH,MAAMC,MAAM,GAAG,KAAKC,UAAUX;QACzD,IAAIkB,WAAW;YACd,KAAK,MAAMC,QAAQV,MAAO;gBACzBD,MAAMK,IAAI,CAAC;oBACVC,UAAU,CAAC,WAAW,EAAEK,MAAM;oBAC9BJ,SAASE,2BAA2BE,MAAM,CAAC,MAAM,EAAEA,MAAM;gBAC1D;YACD;QACD;QAEA,OAAOX;IACR;AACD;AAEA,OAAO,SAASS,2BAA2BG,OAAe,EAAEC,WAAmB;IAC9E,MAAMC,aAAarB,iBAAiBmB;IACpC,MAAMG,WACLF,gBAAgB,UACb,0BACA,CAAC,qBAAqB,EAAEA,YAAY,EAAE,CAAC;IAC3C,MAAMG,aAAatB,mBAAmBkB;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,EAAEC,SAAS;kCACuB,EAAEF,YAAY,SAAS,EAAEG,WAAW;AACtE,CAAC;AACD;AAEA,SAASR;IACR,OAAO;QACN;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;KACA,CAACS,IAAI,CAAC;AACR"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/create",
-  "version": "0.0.1-dev.43",
+  "version": "0.0.1-dev.44",
   "description": "Scaffold a new Decohere project — build with Forge, serve with Flux",
   "keywords": [
     "decohere",
@@ -21,7 +21,7 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@decohere/nexus": "0.0.1-dev.43",
+    "@decohere/nexus": "0.0.1-dev.44",
     "commander": "^13.1.0",
     "openapi-to-postmanv2": "^5.0.0"
   },

package/types/src/models/config-yaml.model.d.ts

@@ -12,5 +12,16 @@ export declare class ConfigYaml implements KeyedModel {
     private readonly _sections;
     constructor(key: string, filePath: string, baseContent: string);
     addSection(yaml: string): this;
+    /** True when a datasource with this `name:` already appears in the file. */
+    hasDataSource(name: string): boolean;
+    hasDataSources(): boolean;
+    /**
+     * 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: string): this;
+    static fromFile(key: string, relativePath: string, absolutePath: string): ConfigYaml;
     files(): SourceFile[];
 }
+/** Insert a YAML list item under `dataSources:`; append a new `database:` block if missing. */
+export declare function injectYamlDataSource(yaml: string, item: string): string;

package/types/src/models/env-file.model.d.ts

@@ -10,5 +10,6 @@ export declare class EnvFile implements KeyedModel {
     readonly key: string;
     private readonly _entries;
     addEntry(key: string, value: string): this;
+    static fromFile(absolutePath: string): EnvFile;
     files(): SourceFile[];
 }

package/types/src/models/launch-json.model.d.ts

@@ -1,5 +1,7 @@
 import type { KeyedModel, SourceFile } from "./source-file.js";
 export declare class LaunchJson implements KeyedModel {
+    private readonly apiNames;
     readonly key: string;
+    constructor(apiNames?: readonly string[]);
     files(): SourceFile[];
 }

package/types/src/models/package-json.model.d.ts

@@ -1,4 +1,11 @@
 import type { KeyedModel, SourceFile } from "./source-file.js";
+export type PackageJsonOptions = {
+    startEntry?: string;
+    /** API slugs in this workspace. Drives `start:<name>` / `dev:<name>`. */
+    apiNames?: readonly string[];
+    /** Host workspace name used in `@<workspace>/<api>` for flux `--project`. */
+    workspaceName?: string;
+};
 /**
  * Builder for the root `package.json`.
  *
@@ -9,12 +16,15 @@ import type { KeyedModel, SourceFile } from "./source-file.js";
 export declare class PackageJson implements KeyedModel {
     private readonly name;
     readonly key: string;
-    private readonly _dependencies;
-    private readonly _devDependencies;
-    private readonly _scripts;
-    constructor(name: string, options?: {
-        startEntry?: string;
-    });
+    private _dependencies;
+    private _devDependencies;
+    private _scripts;
+    private _version;
+    private _type;
+    private _rest;
+    constructor(name: string, options?: PackageJsonOptions);
+    /** Load an existing root package.json so `webapi add` can merge scripts/deps. */
+    static fromFile(filePath: string): PackageJson;
     addDependency(name: string, version: string): this;
     addDevDependency(name: string, version: string): this;
     addScript(name: string, command: string): this;

package/types/src/models/project.model.d.ts

@@ -31,6 +31,7 @@ export declare abstract class WorkspaceScaffold {
     abstract getModel<T extends SourceFileProvider>(key: string): T | undefined;
     abstract getModels<T extends SourceFileProvider>(ctor: new (...args: never[]) => T): T[];
     abstract getProject(dir: string): ProjectScaffold | undefined;
+    abstract getProjects(): readonly ProjectScaffold[];
     abstract scaffold(): Promise<void> | void;
 }
 export declare class MonoRepoScaffold extends WorkspaceScaffold {
@@ -40,6 +41,8 @@ export declare class MonoRepoScaffold extends WorkspaceScaffold {
     addProject(project: ProjectScaffold): ProjectScaffold;
     /** Retrieve a previously-registered project by its directory path. */
     getProject(dir: string): ProjectScaffold | undefined;
+    /** All registered projects, in registration order. */
+    getProjects(): readonly ProjectScaffold[];
     /** Register a named model at workspace level. */
     addModel<T extends KeyedModel>(model: T): T;
     /**

package/types/src/webapi/api-name.d.ts

@@ -0,0 +1,14 @@
+/** Lowercase npm-safe directory slug: `billing`, `admin-api`. */
+export declare const API_NAME_PATTERN: RegExp;
+export declare class CreateCliError extends Error {
+    constructor(message: string);
+}
+export declare function assertValidApiName(name: string): void;
+/** Default `["api"]` when the caller omitted `--name`. Rejects duplicates and invalid slugs. */
+export declare function parseApiNames(raw: readonly string[] | undefined): string[];
+export declare function isDecohereWorkspace(dir: string): boolean;
+/** Directory names under `projects/` that already have a `package.json`. */
+export declare function listExistingApiNames(dir: string): string[];
+/** `billing` → `BILLING`, `admin-api` → `ADMIN_API` — prefix for `{PREFIX}_DB_HOST`. */
+export declare function apiEnvPrefix(apiName: string): string;
+export declare function apiNameFromProjectDir(dir: string): string;

package/types/src/webapi/const.d.ts

@@ -1,7 +1,17 @@
-/** Relative path of the scaffolded API project inside the monorepo. */
-export declare const WEBAPI_PROJECT_DIR = "projects/api";
+/** Default API project slug when `--name` is omitted. */
+export declare const DEFAULT_WEBAPI_NAME = "api";
+/** Relative path of an API project inside the monorepo. */
+export declare function webapiProjectDir(name: string): string;
 /**
- * Forge release entry for the scaffolded API (`pack: true` → per-target outDir).
- * Keep in sync with root `package.json` `"start"` and the production Dockerfile.
+ * Forge release entry for a scaffolded API (`pack: true` → per-target outDir).
+ * Keep in sync with root `package.json` `"start"` / `"start:<name>"` and Dockerfiles.
  */
-export declare const WEBAPI_RELEASE_ENTRY = "dist/release/projects/api/es6/src/main.js";
+export declare function webapiReleaseEntry(name: string): string;
+/** npm package name for a scaffolded API (`flux serve --project`). */
+export declare function webapiPackageName(workspaceName: string, apiName: string): string;
+/** Local listen port for the nth API (0-based). Production uses `PORT`. */
+export declare function webapiPort(index: number): number;
+/** @deprecated Use `webapiProjectDir(name)`. Default path for the first API. */
+export declare const WEBAPI_PROJECT_DIR: string;
+/** @deprecated Use `webapiReleaseEntry(name)`. Default start entry for the first API. */
+export declare const WEBAPI_RELEASE_ENTRY: string;

package/types/src/webapi/create-api.d.ts

@@ -3,6 +3,10 @@ export type ApiOptions = {
     d?: string;
     /** Host project name (directory basename). Required when scaffolding into `/workspace`. */
     projectName?: string;
+    /** API slugs under `projects/`. Default `["api"]`. Repeatable `--name`. */
+    names?: string[];
+    /** Add APIs to an existing Decohere workspace instead of creating a new one. */
+    add?: boolean;
     authProvider?: "auth0" | "none";
     databaseProvider?: "none" | "postgres/typeorm";
     postmanProvider?: "api" | "local" | "none";

package/types/src/webapi/features/biome-format.d.ts

@@ -2,4 +2,4 @@
  * Format/lint-fix all files in the scaffolded workspace with Biome.
  * Prefer a global `biome` binary (builder image); fall back to `npx`.
  */
-export declare function formatScaffoldedFiles(targetDir: string): void;
+export declare function formatScaffoldedFiles(targetDir: string, paths?: string[]): void;

package/types/src/webapi/models/api-package-json.model.d.ts

@@ -1,16 +1,17 @@
 import type { KeyedModel, SourceFile } from "../../models/source-file.js";
 /**
- * Builder for `projects/api/package.json`.
+ * Builder for `projects/<api>/package.json`.
  *
  * Starts with the core cortex + crucible deps. Features can call
  * `addDependency` / `addDevDependency` to extend.
  */
 export declare class ApiPackageJson implements KeyedModel {
-    private readonly projectName;
+    private readonly workspaceName;
+    private readonly apiName;
     readonly key: string;
     private readonly _dependencies;
     private readonly _devDependencies;
-    constructor(projectName: string);
+    constructor(workspaceName: string, apiName?: string);
     addDependency(name: string, version: string): this;
     addDevDependency(name: string, version: string): this;
     files(): SourceFile[];

package/types/src/webapi/models/main-source-file.model.d.ts

@@ -22,6 +22,7 @@ export declare class MainSourceFile implements KeyedModel {
     private readonly _entities;
     private readonly _repositories;
     private readonly _services;
+    private _dataSourceName;
     private _typeOrmSeed;
     constructor(appName: string);
     /** Adds a bare side-effect import, e.g. `@decohere/cortex/auth`. */
@@ -39,6 +40,11 @@ export declare class MainSourceFile implements KeyedModel {
     addRepository(repo: TypeOrmImport): this;
     /** Adds a service registered in `.withServices()`. */
     addService(service: ServiceImport): this;
+    /**
+     * Datasource name passed to `withTypeOrm({ name })`. Must match
+     * `database.dataSources[].name` in config.yaml.
+     */
+    setDataSourceName(name: string): this;
     /**
      * Inline seed callback body for `withTypeOrm({ seed })`.
      * Receives `dataSource` in scope. Example: `await dataSource.getRepository(User).save(...)`.

package/types/src/webapi/models/production-dockerfile.model.d.ts

@@ -1,9 +1,20 @@
 import type { KeyedModel, SourceFile } from "../../models/source-file.js";
+export type ProductionDockerfileOptions = {
+    /** When true, only write `Dockerfile.<name>` (existing workspace — do not replace root Dockerfile). */
+    namedOnly?: boolean;
+};
 /**
- * Repo-root production Dockerfile for PaaS (Railway/Fly) and local `docker build`.
- * Runs conventional `pnpm run build` / `pnpm start` so Nixpacks and Docker share scripts.
+ * Production Dockerfiles for PaaS (Railway/Fly) and local `docker build`.
+ *
+ * Context is always the **repo root** (`docker build -f Dockerfile.billing .`).
+ * Root `Dockerfile` is the first API (`pnpm start`). Extra or custom-named APIs
+ * also get `Dockerfile.<name>` so each service can be deployed on its own.
  */
 export declare class WebapiProductionDockerfile implements KeyedModel {
+    private readonly apiNames;
+    private readonly options;
     readonly key: string;
+    constructor(apiNames?: readonly string[], options?: ProductionDockerfileOptions);
     files(): SourceFile[];
 }
+export declare function renderProductionDockerfile(apiName: string, startScript: string): string;