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

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

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get WebapiProductionDockerfile () {
+        return WebapiProductionDockerfile;
+    },
+    get renderProductionDockerfile () {
+        return renderProductionDockerfile;
+    }
+});
+const _const = require("../../models/const.js");
+const _const1 = require("../const.js");
+class WebapiProductionDockerfile {
+    apiNames;
+    options;
+    key = _const.WELL_KNOWN_FILES.PRODUCTION_DOCKERFILE;
+    constructor(apiNames = [
+        _const1.DEFAULT_WEBAPI_NAME
+    ], options = {}){
+        this.apiNames = apiNames;
+        this.options = options;
+    }
+    files() {
+        const names = this.apiNames.length > 0 ? this.apiNames : [
+            _const1.DEFAULT_WEBAPI_NAME
+        ];
+        const first = names[0] ?? _const1.DEFAULT_WEBAPI_NAME;
+        const files = [];
+        if (!this.options.namedOnly) {
+            files.push({
+                filePath: ".dockerignore",
+                content: dockerignoreContent()
+            });
+            files.push({
+                filePath: "Dockerfile",
+                content: renderProductionDockerfile(first, "start")
+            });
+        }
+        const emitNamed = this.options.namedOnly || names.length > 1 || first !== _const1.DEFAULT_WEBAPI_NAME;
+        if (emitNamed) {
+            for (const name of names){
+                files.push({
+                    filePath: `Dockerfile.${name}`,
+                    content: renderProductionDockerfile(name, `start:${name}`)
+                });
+            }
+        }
+        return files;
+    }
+}
+function renderProductionDockerfile(apiName, startScript) {
+    const projectDir = (0, _const1.webapiProjectDir)(apiName);
+    const startCmd = startScript === "start" ? 'CMD ["pnpm", "start"]' : `CMD ["pnpm", "run", "${startScript}"]`;
+    const startEntry = (0, _const1.webapiReleaseEntry)(apiName);
+    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":["WebapiProductionDockerfile","renderProductionDockerfile","key","WELL_KNOWN_FILES","PRODUCTION_DOCKERFILE","apiNames","DEFAULT_WEBAPI_NAME","options","files","names","length","first","namedOnly","push","filePath","content","dockerignoreContent","emitNamed","name","apiName","startScript","projectDir","webapiProjectDir","startCmd","startEntry","webapiReleaseEntry","dockerfileFlag","renderPnpmInstall","mode","flags","join"],"mappings":";;;;;;;;;;;QAmBaA;eAAAA;;QAuCGC;eAAAA;;;uBA1DiB;wBAEyC;AAiBnE,MAAMD;;;IACIE,MAAMC,uBAAgB,CAACC,qBAAqB,CAAC;IAE7D,YACC,AAAiBC,WAA8B;QAACC,2BAAmB;KAAC,EACpE,AAAiBC,UAAuC,CAAC,CAAC,CACzD;aAFgBF,WAAAA;aACAE,UAAAA;IACf;IAEIC,QAAsB;QAC5B,MAAMC,QAAQ,IAAI,CAACJ,QAAQ,CAACK,MAAM,GAAG,IAAI,IAAI,CAACL,QAAQ,GAAG;YAACC,2BAAmB;SAAC;QAC9E,MAAMK,QAAQF,KAAK,CAAC,EAAE,IAAIH,2BAAmB;QAC7C,MAAME,QAAsB,EAAE;QAE9B,IAAI,CAAC,IAAI,CAACD,OAAO,CAACK,SAAS,EAAE;YAC5BJ,MAAMK,IAAI,CAAC;gBACVC,UAAU;gBACVC,SAASC;YACV;YACAR,MAAMK,IAAI,CAAC;gBACVC,UAAU;gBACVC,SAASd,2BAA2BU,OAAO;YAC5C;QACD;QAEA,MAAMM,YACL,IAAI,CAACV,OAAO,CAACK,SAAS,IAAIH,MAAMC,MAAM,GAAG,KAAKC,UAAUL,2BAAmB;QAC5E,IAAIW,WAAW;YACd,KAAK,MAAMC,QAAQT,MAAO;gBACzBD,MAAMK,IAAI,CAAC;oBACVC,UAAU,CAAC,WAAW,EAAEI,MAAM;oBAC9BH,SAASd,2BAA2BiB,MAAM,CAAC,MAAM,EAAEA,MAAM;gBAC1D;YACD;QACD;QAEA,OAAOV;IACR;AACD;AAEO,SAASP,2BAA2BkB,OAAe,EAAEC,WAAmB;IAC9E,MAAMC,aAAaC,IAAAA,wBAAgB,EAACH;IACpC,MAAMI,WACLH,gBAAgB,UACb,0BACA,CAAC,qBAAqB,EAAEA,YAAY,EAAE,CAAC;IAC3C,MAAMI,aAAaC,IAAAA,0BAAkB,EAACN;IACtC,MAAMO,iBAAiBN,gBAAgB,UAAU,KAAK,CAAC,CAAC,EAAED,SAAS;IAEnE,OAAO,CAAC;;;sDAG6C,EAAEO,eAAe;;;;;;;;;;;;;;;;;KAiBlE,EAAEL,WAAW,GAAG,EAAEA,WAAW;;AAElC,EAAEM,kBAAkB,OAAO;;;;;;;;;;;KAWtB,EAAEN,WAAW,gBAAgB,EAAEA,WAAW;;AAE/C,EAAEM,kBAAkB,QAAQ;;;;;;;;;;;;2BAYD,EAAEN,WAAW,gBAAgB,EAAEA,WAAW;;;AAGrE,EAAEE,SAAS;kCACuB,EAAEH,YAAY,SAAS,EAAEI,WAAW;AACtE,CAAC;AACD;AAEA,8FAA8F,GAC9F,SAASG,kBAAkBC,IAAoB;IAC9C,MAAMC,QAAQD,SAAS,SAAS,YAAY;IAC5C,OAAO,CAAC;;;;;;;;;;;gCAWuB,EAAEC,MAAM;;cAE1B,EAAEA,MAAM;;aAET,CAAC;AACd;AAEA,SAASb;IACR,OAAO;QACN;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;KACA,CAACc,IAAI,CAAC;AACR"}

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get SampleConfigModel () {
+        return SampleConfigModel;
+    },
+    get SampleServiceModel () {
+        return SampleServiceModel;
+    }
+});
+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");
+class SampleConfigModel {
+    files() {
+        return [
+            {
+                filePath: "src/sample.config.ts",
+                content: SAMPLE_CONFIG_CONTENT
+            }
+        ];
+    }
+}
+class SampleServiceModel {
+    files() {
+        return [
+            {
+                filePath: "src/services/sample.service.ts",
+                content: SAMPLE_SERVICE_CONTENT
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WebapiDevContainer", {
+    enumerable: true,
+    get: function() {
+        return WebapiDevContainer;
+    }
+});
+const _dockerimagemodel = require("../../models/docker-image.model.js");
+const _version = require("../../version.js");
+class WebapiDevContainer extends _dockerimagemodel.DockerfileModel {
+    constructor(baseImage = `${_version.DEVCONTAINER_IMAGE_REPOSITORY}:${_version.CREATE_VERSION}`){
+        super(baseImage);
+    }
+    files() {
+        return [
+            {
+                filePath: ".devcontainer/Dockerfile",
+                content: this.build()
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy93ZWJhcGkvbW9kZWxzL3dlYmFwaS1pbWFnZS5tb2RlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEb2NrZXJmaWxlTW9kZWwgfSBmcm9tIFwiLi4vLi4vbW9kZWxzL2RvY2tlci1pbWFnZS5tb2RlbC5qc1wiO1xuaW1wb3J0IHsgQ1JFQVRFX1ZFUlNJT04sIERFVkNPTlRBSU5FUl9JTUFHRV9SRVBPU0lUT1JZIH0gZnJvbSBcIi4uLy4uL3ZlcnNpb24uanNcIjtcblxuLyoqXG4gKiBTY2FmZm9sZGVkIGFwcCBgLmRldmNvbnRhaW5lci9Eb2NrZXJmaWxlYCDigJQgdGhpbiBgRlJPTWAgdGhlIHB1Ymxpc2hlZCBiYXNlIGltYWdlLlxuICogT3B0aW9uYWwgZmVhdHVyZSBsYXllcnMgKGUuZy4gcG9zdGdyZXNxbC1jbGllbnQpIGFwcGVuZCB2aWEgYGFkZExheWVyYC5cbiAqL1xuZXhwb3J0IGNsYXNzIFdlYmFwaURldkNvbnRhaW5lciBleHRlbmRzIERvY2tlcmZpbGVNb2RlbCB7XG5cdHB1YmxpYyBjb25zdHJ1Y3RvcihiYXNlSW1hZ2UgPSBgJHtERVZDT05UQUlORVJfSU1BR0VfUkVQT1NJVE9SWX06JHtDUkVBVEVfVkVSU0lPTn1gKSB7XG5cdFx0c3VwZXIoYmFzZUltYWdlKTtcblx0fVxuXG5cdHB1YmxpYyBmaWxlcygpIHtcblx0XHRyZXR1cm4gW1xuXHRcdFx0e1xuXHRcdFx0XHRmaWxlUGF0aDogXCIuZGV2Y29udGFpbmVyL0RvY2tlcmZpbGVcIixcblx0XHRcdFx0Y29udGVudDogdGhpcy5idWlsZCgpLFxuXHRcdFx0fSxcblx0XHRdO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiV2ViYXBpRGV2Q29udGFpbmVyIiwiRG9ja2VyZmlsZU1vZGVsIiwiYmFzZUltYWdlIiwiREVWQ09OVEFJTkVSX0lNQUdFX1JFUE9TSVRPUlkiLCJDUkVBVEVfVkVSU0lPTiIsImZpbGVzIiwiZmlsZVBhdGgiLCJjb250ZW50IiwiYnVpbGQiXSwibWFwcGluZ3MiOiI7Ozs7K0JBT2FBOzs7ZUFBQUE7OztrQ0FQbUI7eUJBQzhCO0FBTXZELE1BQU1BLDJCQUEyQkMsaUNBQWU7SUFDdEQsWUFBbUJDLFlBQVksR0FBR0Msc0NBQTZCLENBQUMsQ0FBQyxFQUFFQyx1QkFBYyxFQUFFLENBQUU7UUFDcEYsS0FBSyxDQUFDRjtJQUNQO0lBRU9HLFFBQVE7UUFDZCxPQUFPO1lBQ047Z0JBQ0NDLFVBQVU7Z0JBQ1ZDLFNBQVMsSUFBSSxDQUFDQyxLQUFLO1lBQ3BCO1NBQ0E7SUFDRjtBQUNEIn0=

package/commonjs/src/webapi/postman/hello-openapi.js

@@ -0,0 +1,175 @@
+/** Minimal OpenAPI 3 document shape used for Postman conversion. */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "buildHelloOpenApiDocument", {
+    enumerable: true,
+    get: function() {
+        return buildHelloOpenApiDocument;
+    }
+});
+function buildHelloOpenApiDocument(projectName) {
+    return {
+        openapi: "3.0.3",
+        info: {
+            title: `${projectName} WebAPI`,
+            version: "1.0.0",
+            description: "Generated from OpenAPI for Postman. Auth/env overlays are applied separately."
+        },
+        servers: [
+            {
+                url: "{{baseUrl}}"
+            }
+        ],
+        paths: {
+            "/hello": {
+                get: {
+                    operationId: "HelloController.getAll",
+                    summary: "List (anonymous)",
+                    tags: [
+                        "Hello"
+                    ],
+                    parameters: [
+                        {
+                            name: "filter",
+                            in: "query",
+                            required: false,
+                            schema: {
+                                type: "string"
+                            }
+                        }
+                    ],
+                    responses: {
+                        "200": {
+                            description: "Successful response"
+                        }
+                    }
+                },
+                post: {
+                    operationId: "HelloController.create",
+                    summary: "Create",
+                    tags: [
+                        "Hello"
+                    ],
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        message: {
+                                            type: "string"
+                                        }
+                                    },
+                                    required: [
+                                        "message"
+                                    ],
+                                    example: {
+                                        message: "hello"
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    responses: {
+                        "200": {
+                            description: "Successful response"
+                        }
+                    }
+                }
+            },
+            "/hello/{id}": {
+                get: {
+                    operationId: "HelloController.getOne",
+                    summary: "Get by id",
+                    tags: [
+                        "Hello"
+                    ],
+                    parameters: [
+                        {
+                            name: "id",
+                            in: "path",
+                            required: true,
+                            schema: {
+                                type: "string"
+                            }
+                        }
+                    ],
+                    responses: {
+                        "200": {
+                            description: "Successful response"
+                        }
+                    }
+                },
+                put: {
+                    operationId: "HelloController.update",
+                    summary: "Update",
+                    tags: [
+                        "Hello"
+                    ],
+                    parameters: [
+                        {
+                            name: "id",
+                            in: "path",
+                            required: true,
+                            schema: {
+                                type: "string"
+                            }
+                        }
+                    ],
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        message: {
+                                            type: "string"
+                                        }
+                                    },
+                                    required: [
+                                        "message"
+                                    ],
+                                    example: {
+                                        message: "updated"
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    responses: {
+                        "200": {
+                            description: "Successful response"
+                        }
+                    }
+                },
+                delete: {
+                    operationId: "HelloController.remove",
+                    summary: "Delete",
+                    tags: [
+                        "Hello"
+                    ],
+                    parameters: [
+                        {
+                            name: "id",
+                            in: "path",
+                            required: true,
+                            schema: {
+                                type: "string"
+                            }
+                        }
+                    ],
+                    responses: {
+                        "200": {
+                            description: "Successful response"
+                        }
+                    }
+                }
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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