@decohere/create 0.0.1-dev.21 → 0.0.1-dev.22

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

@@ -0,0 +1,176 @@
+import { WELL_KNOWN_FILES } from "./const.js";
+export class DockerStep {
+    key;
+    content;
+    order;
+    constructor(key, content, order = 0){
+        this.key = key;
+        this.content = content;
+        this.order = order;
+    }
+    static run(key, command, order = 0) {
+        return new DockerStep(key, `RUN ${command}`, order);
+    }
+    static raw(key, content, order = 0) {
+        return new DockerStep(key, content, order);
+    }
+    static entrypoint(key, value, order = 0) {
+        const content = typeof value === "string" ? `ENTRYPOINT ${value}` : `ENTRYPOINT ${JSON.stringify(value)}`;
+        return new DockerStep(key, content, order);
+    }
+}
+const StepOrder = {
+    base: 1_000,
+    features: 5_000,
+    user: 9_000,
+    entrypoint: 10_000
+};
+const VSCODE_BOOTLOADER_FIX_BASH_SNIPPET = `if [[ -n "\${NODE_OPTIONS:-}" && "\${NODE_OPTIONS}" == *"bootloader.js"* ]]; then
+    _bootloader_path="$(printf '%s\\n' "$NODE_OPTIONS" | sed -n 's/.*--require[= ]\\([^[:space:]]*bootloader\\.js\\).*/\\1/p')"
+    if [[ -n "\${_bootloader_path}" && ! -f "\${_bootloader_path}" ]]; then
+        _stable_bootloader="$(find /vscode/vscode-server /home/node/.vscode-server/extensions -name "bootloader.js" -path "*/ms-vscode.js-debug/*" 2>/dev/null | head -1)"
+        if [[ -n "\${_stable_bootloader}" ]]; then
+            NODE_OPTIONS="\${NODE_OPTIONS//\${_bootloader_path}/\${_stable_bootloader}}"
+        else
+            NODE_OPTIONS="$(printf '%s\\n' "$NODE_OPTIONS" | sed -E 's#(^| )--require(=| )[[:graph:]]*bootloader\\.js( |$)# #g; s#  +# #g; s#^ ##; s# $##')"
+            unset VSCODE_INSPECTOR_OPTIONS
+        fi
+        export NODE_OPTIONS
+        if [[ -z "$NODE_OPTIONS" ]]; then
+            unset NODE_OPTIONS
+        fi
+    fi
+    unset _bootloader_path _stable_bootloader
+fi`;
+export function withCommandHistory(options) {
+    const historyDir = options?.historyDir ?? "/commandhistory";
+    const historyFileName = options?.historyFileName ?? ".bash_history";
+    const order = options?.order ?? StepOrder.base;
+    const historyFile = `${historyDir}/${historyFileName}`;
+    return (dockerfile)=>{
+        dockerfile.addStep(DockerStep.run("history-dir", `mkdir -p ${historyDir} && touch ${historyFile}`, order)).addStep(DockerStep.raw("history-env", `ENV HISTFILE=${historyFile}`, order + 1));
+    };
+}
+export function withNodeUser(options) {
+    const username = options?.username ?? "node";
+    const includeUserInstruction = options?.includeUserInstruction ?? true;
+    const order = options?.order ?? StepOrder.features;
+    return (dockerfile)=>{
+        dockerfile.addStep(DockerStep.raw("arg-username", `ARG USERNAME=${username}`, order));
+        if (includeUserInstruction) {
+            dockerfile.addStep(DockerStep.raw("user", "USER ${USERNAME}", StepOrder.user));
+        }
+    };
+}
+export function withPnpm(options) {
+    const version = options?.version ?? "10";
+    const usernameExpr = options?.usernameExpr ?? "${USERNAME}";
+    const order = options?.order ?? StepOrder.features + 100;
+    return (dockerfile)=>{
+        dockerfile.addStep(DockerStep.run("pnpm-install", `npm install --global npm@latest && npm add --global pnpm@${version}`, order)).addStep(DockerStep.run("pnpm-config", `mkdir -p /home/${usernameExpr}/.config/pnpm /home/${usernameExpr}/.pnpm-store && chown -R ${usernameExpr}:${usernameExpr} /home/${usernameExpr}/.config /home/${usernameExpr}/.pnpm-store && printf "store-dir=/home/${usernameExpr}/.pnpm-store\\n" > /home/${usernameExpr}/.config/pnpm/rc`, order + 1));
+    };
+}
+export function withWorkspaceNodeModulesOwnership(options) {
+    const workspaceDir = options?.workspaceDir ?? "/workspace";
+    const usernameExpr = options?.usernameExpr ?? "${USERNAME}";
+    const order = options?.order ?? StepOrder.features + 200;
+    return (dockerfile)=>{
+        dockerfile.addStep(DockerStep.raw("workspace-node-modules", `RUN mkdir -p ${workspaceDir}/node_modules && chown ${usernameExpr}:${usernameExpr} ${workspaceDir}/node_modules`, order));
+    };
+}
+export function withVsCodeJsDebugBootloaderFix(options) {
+    const bashrcPath = options?.bashrcPath ?? "/home/${USERNAME}/.bashrc";
+    const order = options?.order ?? StepOrder.features + 300;
+    return (dockerfile)=>{
+        dockerfile.addStep(DockerStep.raw("vscode-bootloader-fix", `RUN cat <<'EOF' >> "${bashrcPath}"\n${VSCODE_BOOTLOADER_FIX_BASH_SNIPPET}\nEOF`, order));
+    };
+}
+export class DockerfileModel {
+    key = WELL_KNOWN_FILES.DOCKERFILE;
+    _steps = new Map();
+    _layerWriters = [];
+    _fromImage;
+    _layerCounter = 0;
+    constructor(baseImage){
+        this._fromImage = baseImage;
+        this.registerBaseLayers();
+    }
+    from(baseImage) {
+        this._fromImage = baseImage;
+        return this;
+    }
+    addLayer(layer, order = StepOrder.features) {
+        if (typeof layer === "string") {
+            const idx = ++this._layerCounter;
+            const key = `layer-run-${idx}`;
+            this._layerWriters.push((dockerfile)=>{
+                dockerfile.addStep(DockerStep.run(key, layer, order + idx));
+            });
+            return this;
+        }
+        this._layerWriters.push(layer);
+        return this;
+    }
+    addStep(step) {
+        this._steps.set(step.key, step);
+        return this;
+    }
+    removeStep(key) {
+        this._steps.delete(key);
+        return this;
+    }
+    entrypoint(value, order = StepOrder.entrypoint) {
+        this.addStep(DockerStep.entrypoint("entrypoint", value, order));
+        return this;
+    }
+    addRunStep(cmd) {
+        return this.addLayer(cmd);
+    }
+    build() {
+        for (const layerWriter of this._layerWriters){
+            layerWriter(this);
+        }
+        const lines = [
+            `FROM ${this._fromImage}`
+        ];
+        const sortedSteps = [
+            ...this._steps.values()
+        ].sort((left, right)=>{
+            if (left.order !== right.order) {
+                return left.order - right.order;
+            }
+            return left.key.localeCompare(right.key, "en");
+        });
+        for (const step of sortedSteps){
+            lines.push("", step.content);
+        }
+        return `${lines.join("\n")}\n`;
+    }
+    registerBaseLayers() {
+    // Generic base model intentionally has no default layers.
+    }
+    files() {
+        return [
+            {
+                filePath: "./Dockerfile",
+                content: this.build()
+            }
+        ];
+    }
+}
+export class DevContainerImageModel extends DockerfileModel {
+    registerBaseLayers() {
+        super.registerBaseLayers();
+        this.addLayer(withCommandHistory()).addLayer(withVsCodeJsDebugBootloaderFix());
+    }
+    files() {
+        return [
+            {
+                filePath: ".devcontainer/Dockerfile",
+                content: this.build()
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/models/docker-image.model.ts"],"sourcesContent":["import { WELL_KNOWN_FILES } from \"./const.js\";\nimport type { KeyedModel, SourceFile } from \"./source-file.js\";\n\nexport type LayerWriter = (dockerfile: DockerfileModel) => void;\n\nexport class DockerStep {\n\tpublic constructor(\n\t\tpublic readonly key: string,\n\t\tpublic readonly content: string,\n\t\tpublic readonly order = 0,\n\t) {}\n\n\tpublic static run(key: string, command: string, order = 0) {\n\t\treturn new DockerStep(key, `RUN ${command}`, order);\n\t}\n\n\tpublic static raw(key: string, content: string, order = 0) {\n\t\treturn new DockerStep(key, content, order);\n\t}\n\n\tpublic static entrypoint(key: string, value: string | readonly string[], order = 0) {\n\t\tconst content =\n\t\t\ttypeof value === \"string\"\n\t\t\t\t? `ENTRYPOINT ${value}`\n\t\t\t\t: `ENTRYPOINT ${JSON.stringify(value)}`;\n\t\treturn new DockerStep(key, content, order);\n\t}\n}\n\nconst StepOrder = {\n\tbase: 1_000,\n\tfeatures: 5_000,\n\tuser: 9_000,\n\tentrypoint: 10_000,\n} as const;\n\nconst VSCODE_BOOTLOADER_FIX_BASH_SNIPPET = `if [[ -n \"\\${NODE_OPTIONS:-}\" && \"\\${NODE_OPTIONS}\" == *\"bootloader.js\"* ]]; then\n    _bootloader_path=\"$(printf '%s\\\\n' \"$NODE_OPTIONS\" | sed -n 's/.*--require[= ]\\\\([^[:space:]]*bootloader\\\\.js\\\\).*/\\\\1/p')\"\n    if [[ -n \"\\${_bootloader_path}\" && ! -f \"\\${_bootloader_path}\" ]]; then\n        _stable_bootloader=\"$(find /vscode/vscode-server /home/node/.vscode-server/extensions -name \"bootloader.js\" -path \"*/ms-vscode.js-debug/*\" 2>/dev/null | head -1)\"\n        if [[ -n \"\\${_stable_bootloader}\" ]]; then\n            NODE_OPTIONS=\"\\${NODE_OPTIONS//\\${_bootloader_path}/\\${_stable_bootloader}}\"\n        else\n            NODE_OPTIONS=\"$(printf '%s\\\\n' \"$NODE_OPTIONS\" | sed -E 's#(^| )--require(=| )[[:graph:]]*bootloader\\\\.js( |$)# #g; s#  +# #g; s#^ ##; s# $##')\"\n            unset VSCODE_INSPECTOR_OPTIONS\n        fi\n        export NODE_OPTIONS\n        if [[ -z \"$NODE_OPTIONS\" ]]; then\n            unset NODE_OPTIONS\n        fi\n    fi\n    unset _bootloader_path _stable_bootloader\nfi`;\n\nexport function withCommandHistory(options?: {\n\thistoryDir?: string;\n\thistoryFileName?: string;\n\torder?: number;\n}): LayerWriter {\n\tconst historyDir = options?.historyDir ?? \"/commandhistory\";\n\tconst historyFileName = options?.historyFileName ?? \".bash_history\";\n\tconst order = options?.order ?? StepOrder.base;\n\tconst historyFile = `${historyDir}/${historyFileName}`;\n\n\treturn (dockerfile) => {\n\t\tdockerfile\n\t\t\t.addStep(\n\t\t\t\tDockerStep.run(\"history-dir\", `mkdir -p ${historyDir} && touch ${historyFile}`, order),\n\t\t\t)\n\t\t\t.addStep(DockerStep.raw(\"history-env\", `ENV HISTFILE=${historyFile}`, order + 1));\n\t};\n}\n\nexport function withNodeUser(options?: {\n\tusername?: string;\n\tincludeUserInstruction?: boolean;\n\torder?: number;\n}): LayerWriter {\n\tconst username = options?.username ?? \"node\";\n\tconst includeUserInstruction = options?.includeUserInstruction ?? true;\n\tconst order = options?.order ?? StepOrder.features;\n\n\treturn (dockerfile) => {\n\t\tdockerfile.addStep(DockerStep.raw(\"arg-username\", `ARG USERNAME=${username}`, order));\n\n\t\tif (includeUserInstruction) {\n\t\t\tdockerfile.addStep(DockerStep.raw(\"user\", \"USER ${USERNAME}\", StepOrder.user));\n\t\t}\n\t};\n}\n\nexport function withPnpm(options?: {\n\tversion?: string;\n\tusernameExpr?: string;\n\torder?: number;\n}): LayerWriter {\n\tconst version = options?.version ?? \"10\";\n\tconst usernameExpr = options?.usernameExpr ?? \"${USERNAME}\";\n\tconst order = options?.order ?? StepOrder.features + 100;\n\n\treturn (dockerfile) => {\n\t\tdockerfile\n\t\t\t.addStep(\n\t\t\t\tDockerStep.run(\n\t\t\t\t\t\"pnpm-install\",\n\t\t\t\t\t`npm install --global npm@latest && npm add --global pnpm@${version}`,\n\t\t\t\t\torder,\n\t\t\t\t),\n\t\t\t)\n\t\t\t.addStep(\n\t\t\t\tDockerStep.run(\n\t\t\t\t\t\"pnpm-config\",\n\t\t\t\t\t`mkdir -p /home/${usernameExpr}/.config/pnpm /home/${usernameExpr}/.pnpm-store && chown -R ${usernameExpr}:${usernameExpr} /home/${usernameExpr}/.config /home/${usernameExpr}/.pnpm-store && printf \"store-dir=/home/${usernameExpr}/.pnpm-store\\\\n\" > /home/${usernameExpr}/.config/pnpm/rc`,\n\t\t\t\t\torder + 1,\n\t\t\t\t),\n\t\t\t);\n\t};\n}\n\nexport function withWorkspaceNodeModulesOwnership(options?: {\n\tworkspaceDir?: string;\n\tusernameExpr?: string;\n\torder?: number;\n}): LayerWriter {\n\tconst workspaceDir = options?.workspaceDir ?? \"/workspace\";\n\tconst usernameExpr = options?.usernameExpr ?? \"${USERNAME}\";\n\tconst order = options?.order ?? StepOrder.features + 200;\n\n\treturn (dockerfile) => {\n\t\tdockerfile.addStep(\n\t\t\tDockerStep.raw(\n\t\t\t\t\"workspace-node-modules\",\n\t\t\t\t`RUN mkdir -p ${workspaceDir}/node_modules && chown ${usernameExpr}:${usernameExpr} ${workspaceDir}/node_modules`,\n\t\t\t\torder,\n\t\t\t),\n\t\t);\n\t};\n}\n\nexport function withVsCodeJsDebugBootloaderFix(options?: {\n\tbashrcPath?: string;\n\torder?: number;\n}): LayerWriter {\n\tconst bashrcPath = options?.bashrcPath ?? \"/home/${USERNAME}/.bashrc\";\n\tconst order = options?.order ?? StepOrder.features + 300;\n\n\treturn (dockerfile) => {\n\t\tdockerfile.addStep(\n\t\t\tDockerStep.raw(\n\t\t\t\t\"vscode-bootloader-fix\",\n\t\t\t\t`RUN cat <<'EOF' >> \"${bashrcPath}\"\\n${VSCODE_BOOTLOADER_FIX_BASH_SNIPPET}\\nEOF`,\n\t\t\t\torder,\n\t\t\t),\n\t\t);\n\t};\n}\n\nexport class DockerfileModel implements KeyedModel {\n\tpublic readonly key = WELL_KNOWN_FILES.DOCKERFILE;\n\tprivate readonly _steps = new Map<string, DockerStep>();\n\tprivate readonly _layerWriters: LayerWriter[] = [];\n\tprivate _fromImage: string;\n\tprivate _layerCounter = 0;\n\n\tpublic constructor(baseImage: string) {\n\t\tthis._fromImage = baseImage;\n\t\tthis.registerBaseLayers();\n\t}\n\n\tpublic from(baseImage: string): this {\n\t\tthis._fromImage = baseImage;\n\t\treturn this;\n\t}\n\n\tpublic addLayer(layer: LayerWriter | string, order = StepOrder.features): this {\n\t\tif (typeof layer === \"string\") {\n\t\t\tconst idx = ++this._layerCounter;\n\t\t\tconst key = `layer-run-${idx}`;\n\t\t\tthis._layerWriters.push((dockerfile) => {\n\t\t\t\tdockerfile.addStep(DockerStep.run(key, layer, order + idx));\n\t\t\t});\n\t\t\treturn this;\n\t\t}\n\n\t\tthis._layerWriters.push(layer);\n\t\treturn this;\n\t}\n\n\tpublic addStep(step: DockerStep): this {\n\t\tthis._steps.set(step.key, step);\n\t\treturn this;\n\t}\n\n\tpublic removeStep(key: string): this {\n\t\tthis._steps.delete(key);\n\t\treturn this;\n\t}\n\n\tpublic entrypoint(value: string | readonly string[], order = StepOrder.entrypoint): this {\n\t\tthis.addStep(DockerStep.entrypoint(\"entrypoint\", value, order));\n\t\treturn this;\n\t}\n\n\tpublic addRunStep(cmd: string): this {\n\t\treturn this.addLayer(cmd);\n\t}\n\n\tpublic build(): string {\n\t\tfor (const layerWriter of this._layerWriters) {\n\t\t\tlayerWriter(this);\n\t\t}\n\n\t\tconst lines = [`FROM ${this._fromImage}`];\n\t\tconst sortedSteps = [...this._steps.values()].sort((left, right) => {\n\t\t\tif (left.order !== right.order) {\n\t\t\t\treturn left.order - right.order;\n\t\t\t}\n\t\t\treturn left.key.localeCompare(right.key, \"en\");\n\t\t});\n\n\t\tfor (const step of sortedSteps) {\n\t\t\tlines.push(\"\", step.content);\n\t\t}\n\n\t\treturn `${lines.join(\"\\n\")}\\n`;\n\t}\n\n\tprotected registerBaseLayers(): void {\n\t\t// Generic base model intentionally has no default layers.\n\t}\n\n\tpublic files(): SourceFile[] {\n\t\treturn [\n\t\t\t{\n\t\t\t\tfilePath: \"./Dockerfile\",\n\t\t\t\tcontent: this.build(),\n\t\t\t},\n\t\t];\n\t}\n}\n\nexport class DevContainerImageModel extends DockerfileModel {\n\tprotected override registerBaseLayers(): void {\n\t\tsuper.registerBaseLayers();\n\t\tthis.addLayer(withCommandHistory()).addLayer(withVsCodeJsDebugBootloaderFix());\n\t}\n\n\tpublic files(): SourceFile[] {\n\t\treturn [\n\t\t\t{\n\t\t\t\tfilePath: \".devcontainer/Dockerfile\",\n\t\t\t\tcontent: this.build(),\n\t\t\t},\n\t\t];\n\t}\n}\n"],"names":["WELL_KNOWN_FILES","DockerStep","key","content","order","run","command","raw","entrypoint","value","JSON","stringify","StepOrder","base","features","user","VSCODE_BOOTLOADER_FIX_BASH_SNIPPET","withCommandHistory","options","historyDir","historyFileName","historyFile","dockerfile","addStep","withNodeUser","username","includeUserInstruction","withPnpm","version","usernameExpr","withWorkspaceNodeModulesOwnership","workspaceDir","withVsCodeJsDebugBootloaderFix","bashrcPath","DockerfileModel","DOCKERFILE","_steps","Map","_layerWriters","_fromImage","_layerCounter","baseImage","registerBaseLayers","from","addLayer","layer","idx","push","step","set","removeStep","delete","addRunStep","cmd","build","layerWriter","lines","sortedSteps","values","sort","left","right","localeCompare","join","files","filePath","DevContainerImageModel"],"mappings":"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"}

package/es6/src/runner.js

@@ -30,8 +30,27 @@ const BUILDER_IMAGE = `ghcr.io/decohere/scaffold:${CREATE_VERSION}`;
     }
     const volumes = [
         "-v",
-        `${targetDir}:/workspace`
+        `${targetDir}:/workspace`,
+        "-v",
+        "/npm-cache"
     ];
+    const commandArgs = [
+        "webapi",
+        "-d",
+        "."
+    ];
+    if (opts.databaseProvider != null) {
+        commandArgs.push("--database", opts.databaseProvider);
+    }
+    if (opts.authProvider != null) {
+        commandArgs.push("--auth", opts.authProvider);
+    }
+    if (opts.postmanProvider != null) {
+        commandArgs.push("--postman", opts.postmanProvider);
+    }
+    if (opts.installDependencies != null) {
+        commandArgs.push("--install", opts.installDependencies);
+    }
     console.log("  Running scaffolding in a sandboxed container...\n");
     const result = spawnSync("docker", [
         "run",
@@ -40,16 +59,18 @@ const BUILDER_IMAGE = `ghcr.io/decohere/scaffold:${CREATE_VERSION}`;
         ...volumes,
         "-e",
         "DECOHERE_BUILDER=1",
+        "-e",
+        "NPM_CONFIG_CACHE=/npm-cache",
+        "-e",
+        "NPM_CONFIG_PREFER_OFFLINE=true",
         "-w",
         "/workspace",
         BUILDER_IMAGE,
-        "webapi",
-        "-d",
-        "."
+        ...commandArgs
     ], {
         stdio: "inherit"
     });
     process.exit(result.status ?? 0);
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/webapi/create-api.js

@@ -2,7 +2,6 @@ import { resolve } from "node:path";
 import { DockerCompose } from "../models/compose.model.js";
 import { ConfigYaml } from "../models/config-yaml.model.js";
 import { WELL_KNOWN_FILES } from "../models/const.js";
-import { DockerfileModel } from "../models/container-image.model.js";
 import { DevContainer } from "../models/dev-container.model.js";
 import { EnvFile } from "../models/env-file.model.js";
 import { Gitignore } from "../models/gitignore.model.js";
@@ -20,6 +19,7 @@ import { ApiPackageJson } from "./models/api-package-json.model.js";
 import { ControllerSourceFile } from "./models/controller-source-file.model.js";
 import { MainSourceFile } from "./models/main-source-file.model.js";
 import { SampleConfigModel, SampleServiceModel } from "./models/sample-files.model.js";
+import { WebapiDevContainer } from "./models/webapi-image.model.js";
 export const WEBAPI_PROJECT_DIR = "projects/api";
 const features = [
     DatabaseFeature,
@@ -51,7 +51,7 @@ function createWorkspace(targetDir) {
     // Workspace-level models (repo root)
     monoRepo.addModel(compose);
     monoRepo.addModel(devContainer);
-    monoRepo.addModel(new DockerfileModel());
+    monoRepo.addModel(new WebapiDevContainer());
     monoRepo.addModel(new VSCodeSettings(name));
     monoRepo.addModel(new LaunchJson());
     monoRepo.addModel(new TsConfig());
@@ -148,4 +148,4 @@ function createWorkspace(targetDir) {
     return monoRepo;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/create-api.ts"],"sourcesContent":["import { resolve } from \"node:path\";\nimport { DockerCompose } from \"../models/compose.model.js\";\nimport { ConfigYaml } from \"../models/config-yaml.model.js\";\nimport { WELL_KNOWN_FILES } from \"../models/const.js\";\nimport { DockerfileModel } from \"../models/container-image.model.js\";\nimport { DevContainer } from \"../models/dev-container.model.js\";\nimport { EnvFile } from \"../models/env-file.model.js\";\nimport { Gitignore } from \"../models/gitignore.model.js\";\nimport { LaunchJson } from \"../models/launch-json.model.js\";\nimport { PackageJson } from \"../models/package-json.model.js\";\nimport { MonoRepoScaffold, ProjectScaffold } from \"../models/project.model.js\";\nimport { TsConfig } from \"../models/tsconfig.model.js\";\nimport { VSCodeSettings } from \"../models/vscode-settings.model.js\";\nimport { ScaffoldService } from \"../services/scaffold.service.js\";\nimport { AuthFeature } from \"./features/auth.feature.js\";\nimport { DatabaseFeature } from \"./features/database.feature.js\";\nimport { FinalizeFeature } from \"./features/finalize.feature.js\";\nimport { PostmanFeature } from \"./features/postman.feature.js\";\nimport { ApiPackageJson } from \"./models/api-package-json.model.js\";\nimport { ControllerSourceFile } from \"./models/controller-source-file.model.js\";\nimport { MainSourceFile } from \"./models/main-source-file.model.js\";\nimport { SampleConfigModel, SampleServiceModel } from \"./models/sample-files.model.js\";\n\nexport const WEBAPI_PROJECT_DIR = \"projects/api\";\n\nexport type ApiOptions = {\n\td?: string;\n\tauthProvider?: string;\n\tdatabaseProvider?: \"none\" | \"postgres/typeorm\";\n};\n\nconst features = [DatabaseFeature, AuthFeature, PostmanFeature, FinalizeFeature];\n\nexport async function scaffoldApi(cliOptions: ApiOptions) {\n\tconst targetDir = resolve(cliOptions.d ?? \".\");\n\tconst workspace = createWorkspace(targetDir);\n\tawait ScaffoldService.scaffold(workspace, cliOptions, features);\n}\n\nfunction createWorkspace(targetDir: string): MonoRepoScaffold {\n\tconst monoRepo = new MonoRepoScaffold();\n\tmonoRepo.targetDir = targetDir;\n\tconst name = monoRepo.name;\n\n\tconst compose = new DockerCompose()\n\t\t.addService(\"devcontainer\", {\n\t\t\tbuild: \".\",\n\t\t\tvolumes: [\n\t\t\t\t`\\${HOME}/.npm/${name}:/home/node/.npm-config`,\n\t\t\t\t\"webapi-node-modules:/workspace/node_modules\",\n\t\t\t],\n\t\t\tenvironment: { NPM_CONFIG_USERCONFIG: \"/home/node/.npm-config/.npmrc\" },\n\t\t\tcommand: \"sleep infinity\",\n\t\t})\n\t\t.addVolume(\"webapi-node-modules\");\n\n\tconst devContainer = new DevContainer()\n\t\t.addExtension(\"biomejs.biome\", \"vitest.explorer\")\n\t\t.setPostStartCommand(\"npm whoami 2>/dev/null || npm login\")\n\t\t.useCompose();\n\n\t// Workspace-level models (repo root)\n\tmonoRepo.addModel(compose);\n\tmonoRepo.addModel(devContainer);\n\tmonoRepo.addModel(new DockerfileModel());\n\tmonoRepo.addModel(new VSCodeSettings(name));\n\tmonoRepo.addModel(new LaunchJson());\n\tmonoRepo.addModel(new TsConfig());\n\tmonoRepo.addModel(new PackageJson(`${name}.api`));\n\tmonoRepo.addModel(new ConfigYaml(WELL_KNOWN_FILES.CONFIG_YAML, \"config/config.yaml\", \"\"));\n\tmonoRepo.addModel(\n\t\tnew ConfigYaml(WELL_KNOWN_FILES.CONFIG_DEV_YAML, \"config/config.dev.yaml\", \"\"),\n\t);\n\tmonoRepo.addModel(new Gitignore());\n\tmonoRepo.addModel(new EnvFile());\n\n\t// Biome formatter/linter config\n\tmonoRepo.addFile({\n\t\tfiles: () => [\n\t\t\t{\n\t\t\t\tfilePath: \"biome.json\",\n\t\t\t\tcontent: JSON.stringify(\n\t\t\t\t\t{\n\t\t\t\t\t\t$schema: \"https://biomejs.dev/schemas/2.0.0/schema.json\",\n\t\t\t\t\t\tfiles: {\n\t\t\t\t\t\t\tincludes: [\"**/*.ts\", \"**/*.js\", \"**/*.json\", \"**/*.yml\", \"**/*.yaml\"],\n\t\t\t\t\t\t},\n\t\t\t\t\t\tassist: { actions: { source: { organizeImports: \"on\" } } },\n\t\t\t\t\t\tvcs: { enabled: true, clientKind: \"git\", useIgnoreFile: true },\n\t\t\t\t\t\tformatter: {\n\t\t\t\t\t\t\tenabled: true,\n\t\t\t\t\t\t\tformatWithErrors: true,\n\t\t\t\t\t\t\tindentStyle: \"tab\",\n\t\t\t\t\t\t\tlineWidth: 95,\n\t\t\t\t\t\t},\n\t\t\t\t\t\tjavascript: { parser: { unsafeParameterDecoratorsEnabled: true } },\n\t\t\t\t\t\tlinter: {\n\t\t\t\t\t\t\trules: {\n\t\t\t\t\t\t\t\tstyle: {\n\t\t\t\t\t\t\t\t\tuseConsistentMemberAccessibility: {\n\t\t\t\t\t\t\t\t\t\tlevel: \"error\",\n\t\t\t\t\t\t\t\t\t\toptions: { accessibility: \"explicit\" },\n\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t\toverrides: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tincludes: [\"**/*.json\"],\n\t\t\t\t\t\t\t\tformatter: { indentStyle: \"space\", indentWidth: 2 },\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t\tnull,\n\t\t\t\t\t2,\n\t\t\t\t),\n\t\t\t},\n\t\t],\n\t});\n\n\t// NPM token placeholder — gitignored, set manually after scaffold\n\tmonoRepo.addFile({\n\t\tfiles: () => [\n\t\t\t{\n\t\t\t\tfilePath: \".env.local\",\n\t\t\t\tcontent:\n\t\t\t\t\t\"# Set your npm access token here (created with: npm token create)\\nNPM_TOKEN=\\n\",\n\t\t\t},\n\t\t],\n\t});\n\n\t// Project-level models (paths relative to projects/api)\n\tconst apiProject = new ProjectScaffold(WEBAPI_PROJECT_DIR);\n\tapiProject.addModel(new ApiPackageJson(name));\n\tapiProject.addModel(new MainSourceFile(`${name}.api`));\n\tapiProject.addModel(new ControllerSourceFile());\n\n\t// SampleService + SampleConfig are part of the core scaffold — HelloController\n\t// injects SampleService to demonstrate config-driven behaviour out of the box.\n\tapiProject.addFile(new SampleConfigModel());\n\tapiProject.addFile(new SampleServiceModel());\n\n\tmonoRepo.addProject(apiProject);\n\n\treturn monoRepo;\n}\n"],"names":["resolve","DockerCompose","ConfigYaml","WELL_KNOWN_FILES","DockerfileModel","DevContainer","EnvFile","Gitignore","LaunchJson","PackageJson","MonoRepoScaffold","ProjectScaffold","TsConfig","VSCodeSettings","ScaffoldService","AuthFeature","DatabaseFeature","FinalizeFeature","PostmanFeature","ApiPackageJson","ControllerSourceFile","MainSourceFile","SampleConfigModel","SampleServiceModel","WEBAPI_PROJECT_DIR","features","scaffoldApi","cliOptions","targetDir","d","workspace","createWorkspace","scaffold","monoRepo","name","compose","addService","build","volumes","environment","NPM_CONFIG_USERCONFIG","command","addVolume","devContainer","addExtension","setPostStartCommand","useCompose","addModel","CONFIG_YAML","CONFIG_DEV_YAML","addFile","files","filePath","content","JSON","stringify","$schema","includes","assist","actions","source","organizeImports","vcs","enabled","clientKind","useIgnoreFile","formatter","formatWithErrors","indentStyle","lineWidth","javascript","parser","unsafeParameterDecoratorsEnabled","linter","rules","style","useConsistentMemberAccessibility","level","options","accessibility","overrides","indentWidth","apiProject","addProject"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/create-api.ts"],"sourcesContent":["import { resolve } from \"node:path\";\nimport { DockerCompose } from \"../models/compose.model.js\";\nimport { ConfigYaml } from \"../models/config-yaml.model.js\";\nimport { WELL_KNOWN_FILES } from \"../models/const.js\";\nimport { DevContainer } from \"../models/dev-container.model.js\";\nimport { EnvFile } from \"../models/env-file.model.js\";\nimport { Gitignore } from \"../models/gitignore.model.js\";\nimport { LaunchJson } from \"../models/launch-json.model.js\";\nimport { PackageJson } from \"../models/package-json.model.js\";\nimport { MonoRepoScaffold, ProjectScaffold } from \"../models/project.model.js\";\nimport { TsConfig } from \"../models/tsconfig.model.js\";\nimport { VSCodeSettings } from \"../models/vscode-settings.model.js\";\nimport { ScaffoldService } from \"../services/scaffold.service.js\";\nimport { AuthFeature } from \"./features/auth.feature.js\";\nimport { DatabaseFeature } from \"./features/database.feature.js\";\nimport { FinalizeFeature } from \"./features/finalize.feature.js\";\nimport { PostmanFeature } from \"./features/postman.feature.js\";\nimport { ApiPackageJson } from \"./models/api-package-json.model.js\";\nimport { ControllerSourceFile } from \"./models/controller-source-file.model.js\";\nimport { MainSourceFile } from \"./models/main-source-file.model.js\";\nimport { SampleConfigModel, SampleServiceModel } from \"./models/sample-files.model.js\";\nimport { WebapiDevContainer } from \"./models/webapi-image.model.js\";\n\nexport const WEBAPI_PROJECT_DIR = \"projects/api\";\n\nexport type ApiOptions = {\n\td?: string;\n\tauthProvider?: \"auth0\" | \"none\";\n\tdatabaseProvider?: \"none\" | \"postgres/typeorm\";\n\tpostmanProvider?: \"api\" | \"local\" | \"none\";\n\tinstallDependencies?: \"yes\" | \"no\";\n};\n\nconst features = [DatabaseFeature, AuthFeature, PostmanFeature, FinalizeFeature];\n\nexport async function scaffoldApi(cliOptions: ApiOptions) {\n\tconst targetDir = resolve(cliOptions.d ?? \".\");\n\tconst workspace = createWorkspace(targetDir);\n\tawait ScaffoldService.scaffold(workspace, cliOptions, features);\n}\n\nfunction createWorkspace(targetDir: string): MonoRepoScaffold {\n\tconst monoRepo = new MonoRepoScaffold();\n\tmonoRepo.targetDir = targetDir;\n\tconst name = monoRepo.name;\n\n\tconst compose = new DockerCompose()\n\t\t.addService(\"devcontainer\", {\n\t\t\tbuild: \".\",\n\t\t\tvolumes: [\n\t\t\t\t`\\${HOME}/.npm/${name}:/home/node/.npm-config`,\n\t\t\t\t\"webapi-node-modules:/workspace/node_modules\",\n\t\t\t],\n\t\t\tenvironment: { NPM_CONFIG_USERCONFIG: \"/home/node/.npm-config/.npmrc\" },\n\t\t\tcommand: \"sleep infinity\",\n\t\t})\n\t\t.addVolume(\"webapi-node-modules\");\n\n\tconst devContainer = new DevContainer()\n\t\t.addExtension(\"biomejs.biome\", \"vitest.explorer\")\n\t\t.setPostStartCommand(\"npm whoami 2>/dev/null || npm login\")\n\t\t.useCompose();\n\n\t// Workspace-level models (repo root)\n\tmonoRepo.addModel(compose);\n\tmonoRepo.addModel(devContainer);\n\tmonoRepo.addModel(new WebapiDevContainer());\n\tmonoRepo.addModel(new VSCodeSettings(name));\n\tmonoRepo.addModel(new LaunchJson());\n\tmonoRepo.addModel(new TsConfig());\n\tmonoRepo.addModel(new PackageJson(`${name}.api`));\n\tmonoRepo.addModel(new ConfigYaml(WELL_KNOWN_FILES.CONFIG_YAML, \"config/config.yaml\", \"\"));\n\tmonoRepo.addModel(\n\t\tnew ConfigYaml(WELL_KNOWN_FILES.CONFIG_DEV_YAML, \"config/config.dev.yaml\", \"\"),\n\t);\n\tmonoRepo.addModel(new Gitignore());\n\tmonoRepo.addModel(new EnvFile());\n\n\t// Biome formatter/linter config\n\tmonoRepo.addFile({\n\t\tfiles: () => [\n\t\t\t{\n\t\t\t\tfilePath: \"biome.json\",\n\t\t\t\tcontent: JSON.stringify(\n\t\t\t\t\t{\n\t\t\t\t\t\t$schema: \"https://biomejs.dev/schemas/2.0.0/schema.json\",\n\t\t\t\t\t\tfiles: {\n\t\t\t\t\t\t\tincludes: [\"**/*.ts\", \"**/*.js\", \"**/*.json\", \"**/*.yml\", \"**/*.yaml\"],\n\t\t\t\t\t\t},\n\t\t\t\t\t\tassist: { actions: { source: { organizeImports: \"on\" } } },\n\t\t\t\t\t\tvcs: { enabled: true, clientKind: \"git\", useIgnoreFile: true },\n\t\t\t\t\t\tformatter: {\n\t\t\t\t\t\t\tenabled: true,\n\t\t\t\t\t\t\tformatWithErrors: true,\n\t\t\t\t\t\t\tindentStyle: \"tab\",\n\t\t\t\t\t\t\tlineWidth: 95,\n\t\t\t\t\t\t},\n\t\t\t\t\t\tjavascript: { parser: { unsafeParameterDecoratorsEnabled: true } },\n\t\t\t\t\t\tlinter: {\n\t\t\t\t\t\t\trules: {\n\t\t\t\t\t\t\t\tstyle: {\n\t\t\t\t\t\t\t\t\tuseConsistentMemberAccessibility: {\n\t\t\t\t\t\t\t\t\t\tlevel: \"error\",\n\t\t\t\t\t\t\t\t\t\toptions: { accessibility: \"explicit\" },\n\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t\toverrides: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tincludes: [\"**/*.json\"],\n\t\t\t\t\t\t\t\tformatter: { indentStyle: \"space\", indentWidth: 2 },\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t\tnull,\n\t\t\t\t\t2,\n\t\t\t\t),\n\t\t\t},\n\t\t],\n\t});\n\n\t// NPM token placeholder — gitignored, set manually after scaffold\n\tmonoRepo.addFile({\n\t\tfiles: () => [\n\t\t\t{\n\t\t\t\tfilePath: \".env.local\",\n\t\t\t\tcontent:\n\t\t\t\t\t\"# Set your npm access token here (created with: npm token create)\\nNPM_TOKEN=\\n\",\n\t\t\t},\n\t\t],\n\t});\n\n\t// Project-level models (paths relative to projects/api)\n\tconst apiProject = new ProjectScaffold(WEBAPI_PROJECT_DIR);\n\tapiProject.addModel(new ApiPackageJson(name));\n\tapiProject.addModel(new MainSourceFile(`${name}.api`));\n\tapiProject.addModel(new ControllerSourceFile());\n\n\t// SampleService + SampleConfig are part of the core scaffold — HelloController\n\t// injects SampleService to demonstrate config-driven behaviour out of the box.\n\tapiProject.addFile(new SampleConfigModel());\n\tapiProject.addFile(new SampleServiceModel());\n\n\tmonoRepo.addProject(apiProject);\n\n\treturn monoRepo;\n}\n"],"names":["resolve","DockerCompose","ConfigYaml","WELL_KNOWN_FILES","DevContainer","EnvFile","Gitignore","LaunchJson","PackageJson","MonoRepoScaffold","ProjectScaffold","TsConfig","VSCodeSettings","ScaffoldService","AuthFeature","DatabaseFeature","FinalizeFeature","PostmanFeature","ApiPackageJson","ControllerSourceFile","MainSourceFile","SampleConfigModel","SampleServiceModel","WebapiDevContainer","WEBAPI_PROJECT_DIR","features","scaffoldApi","cliOptions","targetDir","d","workspace","createWorkspace","scaffold","monoRepo","name","compose","addService","build","volumes","environment","NPM_CONFIG_USERCONFIG","command","addVolume","devContainer","addExtension","setPostStartCommand","useCompose","addModel","CONFIG_YAML","CONFIG_DEV_YAML","addFile","files","filePath","content","JSON","stringify","$schema","includes","assist","actions","source","organizeImports","vcs","enabled","clientKind","useIgnoreFile","formatter","formatWithErrors","indentStyle","lineWidth","javascript","parser","unsafeParameterDecoratorsEnabled","linter","rules","style","useConsistentMemberAccessibility","level","options","accessibility","overrides","indentWidth","apiProject","addProject"],"mappings":"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"}

package/es6/src/webapi/features/finalize.feature.js

@@ -3,15 +3,22 @@ import { ask } from "../../domain/prompt.js";
 // State resolved during scaffold(), consumed by finalize().
 let _pm = null;
 let _shouldInstall = true;
-async function getOptions(_workspace, _cliOptions) {
+async function getOptions(_workspace, cliOptions) {
+    if (cliOptions.installDependencies != null) {
+        _shouldInstall = cliOptions.installDependencies === "yes";
+    }
     return {};
 }
-async function scaffold(workspace, _options) {
+async function scaffold(workspace, options) {
     if (process.env.DECOHERE_BUILDER === "1") {
         _shouldInstall = false;
         return;
     }
     _pm = detectPackageManager(workspace.targetDir) ?? await promptForPackageManager();
+    if (options.installDependencies != null) {
+        _shouldInstall = options.installDependencies === "yes";
+        return;
+    }
     const answer = await ask("\nInstall dependencies now? [yes/no] (yes): ", "yes");
     _shouldInstall = answer.toLowerCase() !== "no";
 }
@@ -38,4 +45,4 @@ export const FinalizeFeature = {
     finalize
 };
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,12 @@
+import { DevContainerImageModel, withNodeUser, withPnpm, withWorkspaceNodeModulesOwnership } from "../../models/docker-image.model.js";
+export class WebapiDevContainer extends DevContainerImageModel {
+    constructor(baseImage = "node:24"){
+        super(baseImage);
+    }
+    registerBaseLayers() {
+        super.registerBaseLayers();
+        this.addLayer(withNodeUser()).addLayer(withPnpm()).addLayer(withWorkspaceNodeModulesOwnership());
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvd2ViYXBpL21vZGVscy93ZWJhcGktaW1hZ2UubW9kZWwudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcblx0RGV2Q29udGFpbmVySW1hZ2VNb2RlbCxcblx0d2l0aE5vZGVVc2VyLFxuXHR3aXRoUG5wbSxcblx0d2l0aFdvcmtzcGFjZU5vZGVNb2R1bGVzT3duZXJzaGlwLFxufSBmcm9tIFwiLi4vLi4vbW9kZWxzL2RvY2tlci1pbWFnZS5tb2RlbC5qc1wiO1xuXG5leHBvcnQgY2xhc3MgV2ViYXBpRGV2Q29udGFpbmVyIGV4dGVuZHMgRGV2Q29udGFpbmVySW1hZ2VNb2RlbCB7XG5cdHB1YmxpYyBjb25zdHJ1Y3RvcihiYXNlSW1hZ2UgPSBcIm5vZGU6MjRcIikge1xuXHRcdHN1cGVyKGJhc2VJbWFnZSk7XG5cdH1cblxuXHRwcm90ZWN0ZWQgb3ZlcnJpZGUgcmVnaXN0ZXJCYXNlTGF5ZXJzKCk6IHZvaWQge1xuXHRcdHN1cGVyLnJlZ2lzdGVyQmFzZUxheWVycygpO1xuXHRcdHRoaXMuYWRkTGF5ZXIod2l0aE5vZGVVc2VyKCkpXG5cdFx0XHQuYWRkTGF5ZXIod2l0aFBucG0oKSlcblx0XHRcdC5hZGRMYXllcih3aXRoV29ya3NwYWNlTm9kZU1vZHVsZXNPd25lcnNoaXAoKSk7XG5cdH1cbn1cbiJdLCJuYW1lcyI6WyJEZXZDb250YWluZXJJbWFnZU1vZGVsIiwid2l0aE5vZGVVc2VyIiwid2l0aFBucG0iLCJ3aXRoV29ya3NwYWNlTm9kZU1vZHVsZXNPd25lcnNoaXAiLCJXZWJhcGlEZXZDb250YWluZXIiLCJiYXNlSW1hZ2UiLCJyZWdpc3RlckJhc2VMYXllcnMiLCJhZGRMYXllciJdLCJtYXBwaW5ncyI6IkFBQUEsU0FDQ0Esc0JBQXNCLEVBQ3RCQyxZQUFZLEVBQ1pDLFFBQVEsRUFDUkMsaUNBQWlDLFFBQzNCLHFDQUFxQztBQUU1QyxPQUFPLE1BQU1DLDJCQUEyQko7SUFDdkMsWUFBbUJLLFlBQVksU0FBUyxDQUFFO1FBQ3pDLEtBQUssQ0FBQ0E7SUFDUDtJQUVtQkMscUJBQTJCO1FBQzdDLEtBQUssQ0FBQ0E7UUFDTixJQUFJLENBQUNDLFFBQVEsQ0FBQ04sZ0JBQ1pNLFFBQVEsQ0FBQ0wsWUFDVEssUUFBUSxDQUFDSjtJQUNaO0FBQ0QifQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/create",
-  "version": "0.0.1-dev.21",
+  "version": "0.0.1-dev.22",
   "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.21",
+    "@decohere/nexus": "0.0.1-dev.22",
     "commander": "^13.1.0"
   },
   "devDependencies": {}

package/types/src/models/docker-image.model.d.ts

@@ -0,0 +1,56 @@
+import type { KeyedModel, SourceFile } from "./source-file.js";
+export type LayerWriter = (dockerfile: DockerfileModel) => void;
+export declare class DockerStep {
+    readonly key: string;
+    readonly content: string;
+    readonly order: number;
+    constructor(key: string, content: string, order?: number);
+    static run(key: string, command: string, order?: number): DockerStep;
+    static raw(key: string, content: string, order?: number): DockerStep;
+    static entrypoint(key: string, value: string | readonly string[], order?: number): DockerStep;
+}
+export declare function withCommandHistory(options?: {
+    historyDir?: string;
+    historyFileName?: string;
+    order?: number;
+}): LayerWriter;
+export declare function withNodeUser(options?: {
+    username?: string;
+    includeUserInstruction?: boolean;
+    order?: number;
+}): LayerWriter;
+export declare function withPnpm(options?: {
+    version?: string;
+    usernameExpr?: string;
+    order?: number;
+}): LayerWriter;
+export declare function withWorkspaceNodeModulesOwnership(options?: {
+    workspaceDir?: string;
+    usernameExpr?: string;
+    order?: number;
+}): LayerWriter;
+export declare function withVsCodeJsDebugBootloaderFix(options?: {
+    bashrcPath?: string;
+    order?: number;
+}): LayerWriter;
+export declare class DockerfileModel implements KeyedModel {
+    readonly key: string;
+    private readonly _steps;
+    private readonly _layerWriters;
+    private _fromImage;
+    private _layerCounter;
+    constructor(baseImage: string);
+    from(baseImage: string): this;
+    addLayer(layer: LayerWriter | string, order?: 5000): this;
+    addStep(step: DockerStep): this;
+    removeStep(key: string): this;
+    entrypoint(value: string | readonly string[], order?: 10000): this;
+    addRunStep(cmd: string): this;
+    build(): string;
+    protected registerBaseLayers(): void;
+    files(): SourceFile[];
+}
+export declare class DevContainerImageModel extends DockerfileModel {
+    protected registerBaseLayers(): void;
+    files(): SourceFile[];
+}

package/types/src/runner.d.ts

@@ -1,3 +1,4 @@
+import type { ApiOptions } from "./webapi/create-api.js";
 /**
  * Run the scaffold inside a pre-built Docker builder image.
  *
@@ -8,6 +9,4 @@
  * If `~/.config/auth0` exists on the host the directory is also mounted so
  * the auth0 CLI inside the container can reuse existing credentials silently.
  */
-export declare function runInBuilder(opts: {
-    d?: string;
-}): never;
+export declare function runInBuilder(opts: ApiOptions): never;

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

@@ -1,7 +1,9 @@
 export declare const WEBAPI_PROJECT_DIR = "projects/api";
 export type ApiOptions = {
     d?: string;
-    authProvider?: string;
+    authProvider?: "auth0" | "none";
     databaseProvider?: "none" | "postgres/typeorm";
+    postmanProvider?: "api" | "local" | "none";
+    installDependencies?: "yes" | "no";
 };
 export declare function scaffoldApi(cliOptions: ApiOptions): Promise<void>;

package/types/src/webapi/models/webapi-image.model.d.ts

@@ -0,0 +1,5 @@
+import { DevContainerImageModel } from "../../models/docker-image.model.js";
+export declare class WebapiDevContainer extends DevContainerImageModel {
+    constructor(baseImage?: string);
+    protected registerBaseLayers(): void;
+}