@decohere/scaffold 0.0.1-dev.18 → 0.0.1-dev.80

package/es6/src/webapi/models/github-ci.model.js

@@ -0,0 +1,186 @@
+import { WELL_KNOWN_FILES } from "../../models/const.js";
+/**
+ * Minimal GitHub Actions for scaffolded apps: lint ∥ test, build gate on default branch,
+ * npm publish after CI (skips private packages). No default forge docker --push.
+ */ export class GithubCiWorkflows {
+    key = WELL_KNOWN_FILES.GITHUB_CI;
+    files() {
+        return [
+            {
+                filePath: ".github/actions/setup-node-pnpm/action.yml",
+                content: `name: Setup Node + pnpm
+description: Install pnpm and Node, configure npm registry auth, install deps
+inputs:
+  node-version:
+    description: Node.js version
+    required: false
+    default: "24"
+  pnpm-version:
+    description: pnpm version
+    required: false
+    default: "10"
+  install:
+    description: Run pnpm install --frozen-lockfile
+    required: false
+    default: "true"
+
+runs:
+  using: composite
+  steps:
+    - uses: pnpm/action-setup@v4
+      with:
+        version: \${{ inputs.pnpm-version }}
+
+    - uses: actions/setup-node@v4
+      with:
+        node-version: \${{ inputs.node-version }}
+        cache: pnpm
+        cache-dependency-path: pnpm-lock.yaml
+
+    - name: Configure npm auth
+      shell: bash
+      run: |
+        if [[ -n "\${NODE_AUTH_TOKEN:-}" ]]; then
+          echo "//registry.npmjs.org/:_authToken=\${NODE_AUTH_TOKEN}" >> .npmrc
+        fi
+
+    - name: Install dependencies
+      if: inputs.install == 'true'
+      shell: bash
+      run: |
+        if [[ -f pnpm-lock.yaml ]]; then
+          pnpm install --frozen-lockfile
+        else
+          pnpm install
+        fi
+`
+            },
+            {
+                filePath: ".github/workflows/ci.yml",
+                content: `name: CI
+on:
+  push:
+    branches:
+      - "*"
+  pull_request:
+  workflow_dispatch:
+concurrency:
+  group: ci-\${{ github.ref }}
+  cancel-in-progress: true
+env:
+  NODE_AUTH_TOKEN: \${{ secrets.NODE_AUTH_TOKEN }}
+  SCRIBE_LOG_LEVEL: info
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - uses: ./.github/actions/setup-node-pnpm
+
+      - name: Lint and typecheck
+        run: |
+          set +e
+          pnpm run lint:check &
+          lint_pid=$!
+          pnpm run typecheck &
+          tsc_pid=$!
+          wait "$lint_pid"
+          lint_code=$?
+          wait "$tsc_pid"
+          tsc_code=$?
+          set -e
+          if [[ "$lint_code" -ne 0 || "$tsc_code" -ne 0 ]]; then
+            exit 1
+          fi
+
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - uses: ./.github/actions/setup-node-pnpm
+
+      - name: Test
+        run: pnpm test
+
+      - name: Build (default branch)
+        if: github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+        run: pnpm run build
+
+  ci:
+    needs: [lint, test]
+    if: always()
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - name: Aggregate
+        run: |
+          if [[ "\${{ needs.lint.result }}" != "success" || "\${{ needs.test.result }}" != "success" ]]; then
+            echo "CI failed (lint=\${{ needs.lint.result }} test=\${{ needs.test.result }})"
+            exit 1
+          fi
+          echo "CI passed"
+`
+            },
+            {
+                filePath: ".github/workflows/publish.yml",
+                content: `name: Publish
+
+on:
+  workflow_run:
+    workflows: ["CI"]
+    types: [completed]
+
+concurrency:
+  group: publish-\${{ github.event.workflow_run.head_branch }}
+  cancel-in-progress: false
+
+env:
+  NODE_AUTH_TOKEN: \${{ secrets.NODE_AUTH_TOKEN }}
+  SCRIBE_LOG_LEVEL: info
+
+jobs:
+  publish:
+    if: >
+      github.event.workflow_run.conclusion == 'success' &&
+      github.event.workflow_run.head_branch == github.event.repository.default_branch
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: \${{ github.event.workflow_run.head_sha }}
+          fetch-depth: 1
+
+      - uses: ./.github/actions/setup-node-pnpm
+
+      - name: Build release
+        run: pnpm run build
+
+      - name: Publish packages
+        run: pnpm exec forge publish --configuration release
+        # Skips packages with "private": true (e.g. the webapi app).
+        # Optional registry images: add \`pnpm exec forge docker --configuration release --push\`
+        # after configuring GHCR/OIDC — not enabled by default (PaaS builds the Dockerfile).
+`
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,163 @@
+import { WELL_KNOWN_FILES } from "../../models/const.js";
+/** Tracks named imports from a single module path, split into values and types. */ class ImportGroup {
+    _values = [];
+    _types = [];
+    add(name, typeOnly = false) {
+        if (typeOnly) {
+            // Value import already present — value wins, skip
+            if (!this._values.includes(name) && !this._types.includes(name)) {
+                this._types.push(name);
+            }
+        } else {
+            // Promote: remove from types if it was previously type-only
+            const typeIdx = this._types.indexOf(name);
+            if (typeIdx !== -1) this._types.splice(typeIdx, 1);
+            if (!this._values.includes(name)) this._values.push(name);
+        }
+        return this;
+    }
+    render(from) {
+        const values = [
+            ...this._values
+        ].sort();
+        const types = [
+            ...this._types
+        ].sort().map((n)=>`type ${n}`);
+        return `import { ${[
+            ...values,
+            ...types
+        ].join(", ")} } from "${from}";`;
+    }
+}
+/**
+ * Model for `projects/api/src/main.ts`.
+ *
+ * Starts with the minimal HTTP + YAML config setup. Features mutate the model
+ * by calling addSideEffectImport / addImport / addBuilderCall / addEntity /
+ * addRepository. files() renders whatever has been accumulated.
+ */ export class MainSourceFile {
+    appName;
+    key = WELL_KNOWN_FILES.MAIN_TS;
+    _sideEffectImports = [];
+    _extraImports = new Map();
+    _builderCalls = [];
+    _entities = [];
+    _repositories = [];
+    _services = [];
+    _dataSourceName;
+    _typeOrmSeed;
+    constructor(appName){
+        this.appName = appName;
+    }
+    /** Adds a bare side-effect import, e.g. `@decohere/cortex/auth`. */ addSideEffectImport(path) {
+        if (!this._sideEffectImports.includes(path)) this._sideEffectImports.push(path);
+        return this;
+    }
+    /** Adds a named import, e.g. `import { Foo } from "bar"`. */ addImport(name, from, typeOnly = false) {
+        const group = this._extraImports.get(from) ?? new ImportGroup();
+        group.add(name, typeOnly);
+        this._extraImports.set(from, group);
+        return this;
+    }
+    /**
+	 * Adds a builder call inserted after `.withConfiguration()` and before
+	 * `.withServices()`. Pass the call without leading dot, e.g. `.withAuth()`.
+	 */ addBuilderCall(call) {
+        this._builderCalls.push(call);
+        return this;
+    }
+    /** Adds a TypeORM entity — import and entry in `withTypeOrm({ entities })`. */ addEntity(entity) {
+        this._entities.push(entity);
+        return this;
+    }
+    /** Adds a TypeORM repository — import and entry in `withTypeOrm({ repositories })`. */ addRepository(repo) {
+        this._repositories.push(repo);
+        return this;
+    }
+    /** Adds a service registered in `.withServices()`. */ addService(service) {
+        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(...)`.
+	 */ setTypeOrmSeed(seedBody) {
+        this._typeOrmSeed = seedBody;
+        return this;
+    }
+    files() {
+        const imports = [
+            'import "@decohere/scribe-pino";',
+            'import "@decohere/cortex/http";'
+        ];
+        for (const path of this._sideEffectImports){
+            imports.push(`import "${path}";`);
+        }
+        imports.push('import "@decohere/protocol";', 'import { YamlDataSource } from "@decohere/protocol";', 'import { Builder } from "@decohere/cortex";', 'import { FastifyProvider } from "@decohere/cortex/providers";', 'import { scribe } from "@decohere/scribe";', 'import { SampleService } from "./services/sample.service.js";');
+        for (const e of this._entities){
+            imports.push(`import { ${e.className} } from "${e.importPath}";`);
+        }
+        for (const r of this._repositories){
+            imports.push(`import { ${r.className} } from "${r.importPath}";`);
+        }
+        for (const s of this._services){
+            imports.push(`import { ${s.className} } from "${s.importPath}";`);
+        }
+        for (const [from, group] of this._extraImports){
+            imports.push(group.render(from));
+        }
+        imports.push('import { HelloController } from "./controllers/hello.controller.js";');
+        const serviceRegs = [
+            "cb.registerSingleton(SampleService);",
+            ...this._services.map((s)=>s.scope === "request" ? `cb.registerRequestScoped(${s.className});` : `cb.registerSingleton(${s.className});`)
+        ].join(" ");
+        const builderCalls = [
+            `\t.withHttp(FastifyProvider)`,
+            `\t.withConfiguration(YamlDataSource)`,
+            `\t.withHealth()`,
+            `\t.withOpenApi({ info: { title: "${this.appName}", version: "1.0.0" } })`,
+            ...this._builderCalls.map((c)=>`\t${c}`),
+            `\t.withServices((cb) => { ${serviceRegs} })`
+        ];
+        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({ ${named}entities: [${entities}], repositories: [${repos}], seed: async (dataSource) => { ${this._typeOrmSeed} } })`);
+            } else {
+                builderCalls.push(`\t.withTypeOrm({ ${named}entities: [${entities}], repositories: [${repos}] })`);
+            }
+        }
+        builderCalls.push(`\t.withControllers(HelloController)`);
+        const content = [
+            ...imports,
+            "",
+            `scribe.withPinoPretty().and.withPinoRoll({ file: "logs/${this.appName}.log" });`,
+            "",
+            `const app = await Builder.create({ applicationName: "${this.appName}" })`,
+            ...builderCalls,
+            `\t.build();`,
+            "",
+            "await app.start({ port: Number(process.env.PORT ?? 3000) });",
+            "",
+            "export default app;",
+            ""
+        ].join("\n");
+        return [
+            {
+                filePath: "src/main.ts",
+                content
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/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.withHttp(FastifyProvider)`,\n\t\t\t`\\t.withConfiguration(YamlDataSource)`,\n\t\t\t`\\t.withHealth()`,\n\t\t\t`\\t.withOpenApi({ info: { title: \"${this.appName}\", version: \"1.0.0\" } })`,\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.withPinoPretty().and.withPinoRoll({ file: \"logs/${this.appName}.log\" });`,\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

@@ -0,0 +1,148 @@
+import { WELL_KNOWN_FILES } from "../../models/const.js";
+import { DEFAULT_WEBAPI_NAME, webapiProjectDir, webapiReleaseEntry } from "../const.js";
+/**
+ * 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.
+ *
+ * Runtime `node_modules` come from a **prod-deps** stage (`pnpm install --prod`),
+ * not the full build install (Forge, TypeScript, Biome, Vitest).
+ */ 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 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);
+    const dockerfileFlag = startScript === "start" ? "" : `.${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${dockerfileFlag} .
+#
+# Runtime node_modules are a production-only install (prod-deps). The build stage's
+# full install (Forge, TypeScript, Biome, Vitest) is not copied into the run image.
+#
+# 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 .
+# Or set NODE_AUTH_TOKEN as a build-arg on hosts that only support build-args.
+
+FROM node:24-bookworm AS build
+WORKDIR /app
+RUN corepack enable && corepack prepare pnpm@10 --activate
+
+COPY package.json ./
+COPY pnpm-lock.yaml* ./
+COPY tsconfig.json biome.json ./
+COPY config ./config
+COPY ${projectDir} ./${projectDir}
+
+${renderPnpmInstall("all")}
+
+RUN pnpm run build
+
+FROM node:24-bookworm AS prod-deps
+WORKDIR /app
+ENV NODE_ENV=production
+RUN corepack enable && corepack prepare pnpm@10 --activate
+
+COPY package.json ./
+COPY pnpm-lock.yaml* ./
+COPY ${projectDir}/package.json ./${projectDir}/package.json
+
+${renderPnpmInstall("prod")}
+
+FROM node:24-bookworm-slim AS run
+WORKDIR /app
+ENV NODE_ENV=production
+RUN corepack enable && corepack prepare pnpm@10 --activate
+
+COPY --from=prod-deps /app/package.json ./
+COPY --from=prod-deps /app/pnpm-lock.yaml* ./
+COPY --from=build /app/config ./config
+COPY --from=build /app/dist ./dist
+COPY --from=prod-deps /app/node_modules ./node_modules
+COPY --from=prod-deps /app/${projectDir}/package.json ./${projectDir}/package.json
+
+EXPOSE 3000
+${startCmd}
+# Entry resolved by package.json "${startScript}" → node ${startEntry}
+`;
+}
+/** npm auth + pnpm install. Token is required again in prod-deps (separate stage, no store). */ function renderPnpmInstall(mode) {
+    const flags = mode === "prod" ? " --prod" : "";
+    return `ARG NODE_AUTH_TOKEN=
+RUN --mount=type=secret,id=npm_token,required=false \\
+	if [ -f /run/secrets/npm_token ]; then \\
+		TOKEN="$(cat /run/secrets/npm_token)"; \\
+	else \\
+		TOKEN="\${NODE_AUTH_TOKEN}"; \\
+	fi; \\
+	if [ -n "$TOKEN" ]; then \\
+		echo "//registry.npmjs.org/:_authToken=\${TOKEN}" > .npmrc; \\
+	fi; \\
+	if [ -f pnpm-lock.yaml ]; then \\
+		pnpm install --frozen-lockfile${flags}; \\
+	else \\
+		pnpm install${flags}; \\
+	fi; \\
+	rm -f .npmrc`;
+}
+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,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/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 *\n * Runtime `node_modules` come from a **prod-deps** stage (`pnpm install --prod`),\n * not the full build install (Forge, TypeScript, Biome, Vitest).\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\tconst dockerfileFlag = startScript === \"start\" ? \"\" : `.${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${dockerfileFlag} .\n#\n# Runtime node_modules are a production-only install (prod-deps). The build stage's\n# full install (Forge, TypeScript, Biome, Vitest) is not copied into the run image.\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\n${renderPnpmInstall(\"all\")}\n\nRUN pnpm run build\n\nFROM node:24-bookworm AS prod-deps\nWORKDIR /app\nENV NODE_ENV=production\nRUN corepack enable && corepack prepare pnpm@10 --activate\n\nCOPY package.json ./\nCOPY pnpm-lock.yaml* ./\nCOPY ${projectDir}/package.json ./${projectDir}/package.json\n\n${renderPnpmInstall(\"prod\")}\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=prod-deps /app/package.json ./\nCOPY --from=prod-deps /app/pnpm-lock.yaml* ./\nCOPY --from=build /app/config ./config\nCOPY --from=build /app/dist ./dist\nCOPY --from=prod-deps /app/node_modules ./node_modules\nCOPY --from=prod-deps /app/${projectDir}/package.json ./${projectDir}/package.json\n\nEXPOSE 3000\n${startCmd}\n# Entry resolved by package.json \"${startScript}\" → node ${startEntry}\n`;\n}\n\n/** npm auth + pnpm install. Token is required again in prod-deps (separate stage, no store). */\nfunction renderPnpmInstall(mode: \"all\" | \"prod\"): string {\n\tconst flags = mode === \"prod\" ? \" --prod\" : \"\";\n\treturn `ARG 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${flags}; \\\\\n\telse \\\\\n\t\tpnpm install${flags}; \\\\\n\tfi; \\\\\n\trm -f .npmrc`;\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","dockerfileFlag","renderPnpmInstall","mode","flags","join"],"mappings":"AAAA,SAASA,gBAAgB,QAAQ,wBAAwB;AAEzD,SAASC,mBAAmB,EAAEC,gBAAgB,EAAEC,kBAAkB,QAAQ,cAAc;AAOxF;;;;;;;;;CASC,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;IACtC,MAAMK,iBAAiBJ,gBAAgB,UAAU,KAAK,CAAC,CAAC,EAAED,SAAS;IAEnE,OAAO,CAAC;;;sDAG6C,EAAEK,eAAe;;;;;;;;;;;;;;;;;KAiBlE,EAAEH,WAAW,GAAG,EAAEA,WAAW;;AAElC,EAAEI,kBAAkB,OAAO;;;;;;;;;;;KAWtB,EAAEJ,WAAW,gBAAgB,EAAEA,WAAW;;AAE/C,EAAEI,kBAAkB,QAAQ;;;;;;;;;;;;2BAYD,EAAEJ,WAAW,gBAAgB,EAAEA,WAAW;;;AAGrE,EAAEC,SAAS;kCACuB,EAAEF,YAAY,SAAS,EAAEG,WAAW;AACtE,CAAC;AACD;AAEA,8FAA8F,GAC9F,SAASE,kBAAkBC,IAAoB;IAC9C,MAAMC,QAAQD,SAAS,SAAS,YAAY;IAC5C,OAAO,CAAC;;;;;;;;;;;gCAWuB,EAAEC,MAAM;;cAE1B,EAAEA,MAAM;;aAET,CAAC;AACd;AAEA,SAASZ;IACR,OAAO;QACN;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;KACA,CAACa,IAAI,CAAC;AACR"}

package/es6/src/webapi/models/sample-files.model.js

@@ -0,0 +1,42 @@
+const SAMPLE_CONFIG_CONTENT = `export class SampleConfig {\n\tpublic greeting: string = "";\n}\n`;
+const SAMPLE_SERVICE_CONTENT = [
+    `import { inject, injectable } from "@decohere/crucible/decorators";`,
+    `import { ConfigurationServiceToken } from "@decohere/nexus/configuration";`,
+    `import type { IConfigurationService } from "@decohere/nexus/configuration";`,
+    `import { SampleConfig } from "../sample.config.js";`,
+    ``,
+    `@injectable()`,
+    `export class SampleService {`,
+    `\tpublic constructor(`,
+    `\t\t@inject(ConfigurationServiceToken) private readonly config: IConfigurationService,`,
+    `\t) {}`,
+    ``,
+    `\tpublic async getGreeting(): Promise<string> {`,
+    `\t\tconst config = await this.config.get(SampleConfig);`,
+    `\t\treturn config.greeting;`,
+    `\t}`,
+    `}`,
+    ``
+].join("\n");
+export class SampleConfigModel {
+    files() {
+        return [
+            {
+                filePath: "src/sample.config.ts",
+                content: SAMPLE_CONFIG_CONTENT
+            }
+        ];
+    }
+}
+export class SampleServiceModel {
+    files() {
+        return [
+            {
+                filePath: "src/services/sample.service.ts",
+                content: SAMPLE_SERVICE_CONTENT
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/webapi/models/webapi-image.model.js

@@ -0,0 +1,20 @@
+import { DockerfileModel } from "../../models/docker-image.model.js";
+import { CREATE_VERSION, DEVCONTAINER_IMAGE_REPOSITORY } from "../../version.js";
+/**
+ * Scaffolded app `.devcontainer/Dockerfile` — thin `FROM` the published base image.
+ * Optional feature layers (e.g. postgresql-client) append via `addLayer`.
+ */ export class WebapiDevContainer extends DockerfileModel {
+    constructor(baseImage = `${DEVCONTAINER_IMAGE_REPOSITORY}:${CREATE_VERSION}`){
+        super(baseImage);
+    }
+    files() {
+        return [
+            {
+                filePath: ".devcontainer/Dockerfile",
+                content: this.build()
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy93ZWJhcGkvbW9kZWxzL3dlYmFwaS1pbWFnZS5tb2RlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEb2NrZXJmaWxlTW9kZWwgfSBmcm9tIFwiLi4vLi4vbW9kZWxzL2RvY2tlci1pbWFnZS5tb2RlbC5qc1wiO1xuaW1wb3J0IHsgQ1JFQVRFX1ZFUlNJT04sIERFVkNPTlRBSU5FUl9JTUFHRV9SRVBPU0lUT1JZIH0gZnJvbSBcIi4uLy4uL3ZlcnNpb24uanNcIjtcblxuLyoqXG4gKiBTY2FmZm9sZGVkIGFwcCBgLmRldmNvbnRhaW5lci9Eb2NrZXJmaWxlYCDigJQgdGhpbiBgRlJPTWAgdGhlIHB1Ymxpc2hlZCBiYXNlIGltYWdlLlxuICogT3B0aW9uYWwgZmVhdHVyZSBsYXllcnMgKGUuZy4gcG9zdGdyZXNxbC1jbGllbnQpIGFwcGVuZCB2aWEgYGFkZExheWVyYC5cbiAqL1xuZXhwb3J0IGNsYXNzIFdlYmFwaURldkNvbnRhaW5lciBleHRlbmRzIERvY2tlcmZpbGVNb2RlbCB7XG5cdHB1YmxpYyBjb25zdHJ1Y3RvcihiYXNlSW1hZ2UgPSBgJHtERVZDT05UQUlORVJfSU1BR0VfUkVQT1NJVE9SWX06JHtDUkVBVEVfVkVSU0lPTn1gKSB7XG5cdFx0c3VwZXIoYmFzZUltYWdlKTtcblx0fVxuXG5cdHB1YmxpYyBmaWxlcygpIHtcblx0XHRyZXR1cm4gW1xuXHRcdFx0e1xuXHRcdFx0XHRmaWxlUGF0aDogXCIuZGV2Y29udGFpbmVyL0RvY2tlcmZpbGVcIixcblx0XHRcdFx0Y29udGVudDogdGhpcy5idWlsZCgpLFxuXHRcdFx0fSxcblx0XHRdO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiRG9ja2VyZmlsZU1vZGVsIiwiQ1JFQVRFX1ZFUlNJT04iLCJERVZDT05UQUlORVJfSU1BR0VfUkVQT1NJVE9SWSIsIldlYmFwaURldkNvbnRhaW5lciIsImJhc2VJbWFnZSIsImZpbGVzIiwiZmlsZVBhdGgiLCJjb250ZW50IiwiYnVpbGQiXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLGVBQWUsUUFBUSxxQ0FBcUM7QUFDckUsU0FBU0MsY0FBYyxFQUFFQyw2QkFBNkIsUUFBUSxtQkFBbUI7QUFFakY7OztDQUdDLEdBQ0QsT0FBTyxNQUFNQywyQkFBMkJIO0lBQ3ZDLFlBQW1CSSxZQUFZLEdBQUdGLDhCQUE4QixDQUFDLEVBQUVELGdCQUFnQixDQUFFO1FBQ3BGLEtBQUssQ0FBQ0c7SUFDUDtJQUVPQyxRQUFRO1FBQ2QsT0FBTztZQUNOO2dCQUNDQyxVQUFVO2dCQUNWQyxTQUFTLElBQUksQ0FBQ0MsS0FBSztZQUNwQjtTQUNBO0lBQ0Y7QUFDRCJ9