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

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

@@ -1,66 +0,0 @@
-import { WELL_KNOWN_FILES } from "../../models/const.js";
-import { DEFAULT_WEBAPI_NAME, webapiPackagedEntry, webapiProjectDir } from "../const.js";
-/**
- * Production Dockerfile for each API, in the API's own folder: `projects/<name>/Dockerfile`.
- * That is where `forge docker` and `forge package` look for a deployable, and the folder is
- * the Docker build context.
- *
- * The image copies `.package/`, which `forge package` writes before Docker runs: the API's
- * compiled code, the workspace libraries it imports, and a real (symlink-free) `node_modules`
- * of the third-party packages it reaches. So the image build installs nothing, runs no
- * workspace tooling, and needs no npm token.
- */ export class WebapiProductionDockerfile {
-    apiNames;
-    key = WELL_KNOWN_FILES.PRODUCTION_DOCKERFILE;
-    constructor(apiNames = [
-        DEFAULT_WEBAPI_NAME
-    ]){
-        this.apiNames = apiNames;
-    }
-    files() {
-        const names = this.apiNames.length > 0 ? this.apiNames : [
-            DEFAULT_WEBAPI_NAME
-        ];
-        return names.flatMap((name)=>[
-                {
-                    filePath: `${webapiProjectDir(name)}/Dockerfile`,
-                    content: renderProductionDockerfile(name)
-                },
-                {
-                    filePath: `${webapiProjectDir(name)}/.dockerignore`,
-                    content: dockerignoreContent()
-                }
-            ]);
-    }
-}
-export function renderProductionDockerfile(apiName) {
-    const projectDir = webapiProjectDir(apiName);
-    const entry = webapiPackagedEntry();
-    return `# syntax=docker/dockerfile:1
-# Production image for ${apiName}. Docker only copies the packaged app; it installs nothing.
-#
-# Build the package first (release build, then .package/ in each API), then the image:
-#   pnpm run package:${apiName}
-#   docker build -t ${apiName} ${projectDir}
-# or, with the image name and tags from the workspace:
-#   pnpm run package:${apiName} && pnpm exec forge docker --configuration release
-#
-# Hosts that build from a git clone (Railway, Fly) do not have .package/. Build and push the
-# image from CI instead, or run the package step before \`docker build\`.
-FROM node:24-bookworm-slim
-WORKDIR /app
-ENV NODE_ENV=production
-
-COPY .package/ ./
-
-EXPOSE 3000
-CMD ["node", "${entry}"]
-`;
-}
-/** The build context is the project folder; only the package belongs in the image. */ function dockerignoreContent() {
-    return [
-        "*",
-        "!.package",
-        ""
-    ].join("\n");
-}

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

@@ -1,40 +0,0 @@
-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/core/configuration";`,
-    `import type { IConfigurationService } from "@decohere/core/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
-            }
-        ];
-    }
-}

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

@@ -1,18 +0,0 @@
-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()
-            }
-        ];
-    }
-}

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

@@ -1,166 +0,0 @@
-/** Minimal OpenAPI 3 document shape used for Postman conversion. */ /**
- * Canonical Hello WebAPI OpenAPI document used to generate Postman requests.
- * Keep paths aligned with scaffolded HelloController (`/hello`, `/hello/{id}`).
- */ export 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"
-                        }
-                    }
-                }
-            }
-        }
-    };
-}

package/es6/src/webapi/postman/local-view.js

@@ -1,167 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { openApiPathParamsToColon } from "./openapi-to-postman.js";
-function yamlQuote(value) {
-    if (/[:#{}[\],&*?|<>=!%@`]/.test(value) || value.includes("\n") || value === "") {
-        return JSON.stringify(value);
-    }
-    return value;
-}
-/** Local View / Native Git environment (YAML). */ export function buildEnvironmentYaml(name, auth, options) {
-    const values = [
-        {
-            key: "baseUrl",
-            value: "http://localhost:3000"
-        }
-    ];
-    if (auth?.auth0Domain) {
-        values.push({
-            key: "auth0Domain",
-            value: auth.auth0Domain
-        }, {
-            key: "auth0Audience",
-            value: auth.auth0Audience ?? ""
-        }, {
-            key: "auth0ClientId",
-            value: auth.auth0ClientId ?? ""
-        }, {
-            key: "authUrl",
-            value: `https://${auth.auth0Domain}/authorize?audience=${auth.auth0Audience ?? ""}`
-        }, {
-            key: "accessTokenUrl",
-            value: `https://${auth.auth0Domain}/oauth/token`
-        }, {
-            key: "callbackUrl",
-            value: options.callbacks[0]
-        }, {
-            key: "scope",
-            value: options.scopes
-        });
-    }
-    const lines = [
-        `name: ${yamlQuote(name)}`,
-        "values:"
-    ];
-    for (const v of values){
-        lines.push(`  - key: ${v.key}`);
-        lines.push(`    value: ${yamlQuote(v.value)}`);
-        lines.push("    enabled: true");
-    }
-    return `${lines.join("\n")}\n`;
-}
-/**
- * Build Postman Local View multi-file YAML from a v2.1 collection (routes)
- * plus hand-authored Auth0 overlay.
- */ export function buildLocalViewFilesFromCollection(collection, projectName, auth, options) {
-    const collectionDir = `postman/collections/${projectName} WebAPI`;
-    const files = [];
-    const authBlock = auth?.auth0Domain ? [
-        "auth:",
-        `  - id: ${randomUUID()}`,
-        "    type: oauth2",
-        "    name: OAuth 2.0",
-        "    credentials:",
-        "      addTokenTo: header",
-        "      grant_type: authorization_code_with_pkce",
-        `      authUrl: https://${auth.auth0Domain}/authorize?audience=${auth.auth0Audience ?? ""}`,
-        `      accessTokenUrl: https://${auth.auth0Domain}/oauth/token`,
-        `      clientId: ${yamlQuote(auth.auth0ClientId ?? "")}`,
-        `      scope: ${yamlQuote(options.scopes)}`,
-        `      redirect_uri: ${options.callbacks[0]}`,
-        "      useBrowser: true",
-        "      challengeAlgorithm: S256",
-        "      client_authentication: body",
-        '      clientSecret: ""',
-        `      tokenName: ${yamlQuote(`${projectName} Access Token`)}`,
-        ""
-    ].join("\n") : "";
-    files.push({
-        filePath: `${collectionDir}/.resources/definition.yaml`,
-        content: [
-            "$kind: collection",
-            `name: ${yamlQuote(`${projectName} WebAPI`)}`,
-            "schemaVersion: '3.0'",
-            "description: >-",
-            "  Open this project root in Postman Local View (Files → Open folder).",
-            "  Select the Local environment, then Authorization → Get New Access Token (PKCE).",
-            "  Route requests are generated from OpenAPI; Auth0 overlay is hand-authored.",
-            authBlock
-        ].filter((l)=>l !== undefined).join("\n").replace(/\n+$/, "\n")
-    });
-    let folderOrder = 1000;
-    for (const folder of collection.item ?? []){
-        if (folder.item == null) {
-            continue;
-        }
-        const folderName = folder.name ?? "Requests";
-        files.push({
-            filePath: `${collectionDir}/${folderName}/.resources/definition.yaml`,
-            content: [
-                "$kind: folder",
-                `name: ${yamlQuote(folderName)}`,
-                `order: ${folderOrder}`,
-                ""
-            ].join("\n")
-        });
-        folderOrder += 1000;
-        let requestOrder = 1000;
-        for (const child of folder.item){
-            const yaml = requestToLocalViewYaml(child, requestOrder);
-            if (yaml == null) {
-                continue;
-            }
-            const fileName = `${sanitizeFileName(child.name ?? "Request")}.request.yaml`;
-            files.push({
-                filePath: `${collectionDir}/${folderName}/${fileName}`,
-                content: yaml
-            });
-            requestOrder += 1000;
-        }
-    }
-    return files;
-}
-function requestToLocalViewYaml(item, order) {
-    const request = item.request;
-    if (request == null) {
-        return null;
-    }
-    const method = (request.method ?? "GET").toUpperCase();
-    const url = requestUrlForLocalView(request);
-    const lines = [
-        "$kind: http-request",
-        `name: ${yamlQuote(item.name ?? method)}`,
-        `method: ${method}`,
-        `url: ${yamlQuote(url)}`
-    ];
-    if (request.auth?.type === "noauth") {
-        lines.push("auth:", "  type: noauth");
-    }
-    const contentType = request.header?.find((h)=>h.key.toLowerCase() === "content-type")?.value;
-    const rawBody = request.body?.raw?.trim();
-    if (rawBody) {
-        lines.push("headers:");
-        lines.push(`  Content-Type: ${contentType ?? "application/json"}`);
-        lines.push("body:");
-        lines.push("  type: json");
-        lines.push("  content: |-");
-        for (const bodyLine of rawBody.split("\n")){
-            lines.push(`    ${bodyLine}`);
-        }
-    }
-    lines.push(`order: ${order}`, "");
-    return lines.join("\n");
-}
-function requestUrlForLocalView(request) {
-    const url = request.url;
-    if (typeof url === "string") {
-        return openApiPathParamsToColon(url);
-    }
-    if (url?.raw) {
-        return openApiPathParamsToColon(url.raw);
-    }
-    const host = url?.host?.[0] ?? "{{baseUrl}}";
-    const path = (url?.path ?? []).map((segment)=>openApiPathParamsToColon(String(segment))).join("/");
-    return path ? `${host}/${path}` : host;
-}
-function sanitizeFileName(name) {
-    return name.replace(/[^\w\s()-]+/g, "").trim() || "Request";
-}

package/es6/src/webapi/postman/openapi-to-postman.js

@@ -1,179 +0,0 @@
-async function convertAsync(data, options) {
-    // Loaded here, not at the top: the converter pulls in about 700 modules (lodash, faker, ajv,
-    // …), which every scaffolder run paid for even with `--postman none`.
-    const { default: converter } = await import("openapi-to-postmanv2");
-    return new Promise((resolve, reject)=>{
-        converter.convert({
-            type: "json",
-            data
-        }, options, (err, result)=>{
-            if (err) {
-                reject(err);
-                return;
-            }
-            resolve(result);
-        });
-    });
-}
-/** Convert an OpenAPI document to a Postman Collection v2.1 via openapi-to-postmanv2. */ export async function openApiToPostmanCollection(document) {
-    const result = await convertAsync(document, {
-        folderStrategy: "Tags",
-        requestNameSource: "Fallback",
-        includeAuthInfoInExample: false
-    });
-    if (!result.result || result.output?.[0]?.data == null) {
-        throw new Error(result.reason ?? "openapi-to-postmanv2 conversion failed");
-    }
-    return result.output[0].data;
-}
-/**
- * Overlay Auth0 OAuth2 (PKCE) collection auth and fix Local View-friendly URLs.
- * Route items come from OpenAPI; auth/env remain hand-authored.
- */ export function applyPostmanAuthOverlay(collection, projectName, auth, options) {
-    const next = {
-        ...collection,
-        info: {
-            ...collection.info,
-            name: `${projectName} WebAPI`,
-            description: options.description,
-            schema: collection.info.schema ?? "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
-        }
-    };
-    if (auth?.auth0Domain) {
-        next.auth = {
-            type: "oauth2",
-            oauth2: [
-                {
-                    key: "grant_type",
-                    value: "authorization_code_with_pkce",
-                    type: "string"
-                },
-                {
-                    key: "authUrl",
-                    value: "https://{{auth0Domain}}/authorize?audience={{auth0Audience}}",
-                    type: "string"
-                },
-                {
-                    key: "accessTokenUrl",
-                    value: "https://{{auth0Domain}}/oauth/token",
-                    type: "string"
-                },
-                {
-                    key: "clientId",
-                    value: "{{auth0ClientId}}",
-                    type: "string"
-                },
-                {
-                    key: "scope",
-                    value: options.scopes,
-                    type: "string"
-                },
-                {
-                    key: "redirect_uri",
-                    value: options.callbacks[0],
-                    type: "string"
-                },
-                {
-                    key: "useBrowser",
-                    value: "true",
-                    type: "boolean"
-                },
-                {
-                    key: "addTokenTo",
-                    value: "header",
-                    type: "string"
-                },
-                {
-                    key: "challengeAlgorithm",
-                    value: "S256",
-                    type: "string"
-                },
-                {
-                    key: "client_authentication",
-                    value: "body",
-                    type: "string"
-                },
-                {
-                    key: "clientSecret",
-                    value: "",
-                    type: "string"
-                },
-                {
-                    key: "tokenName",
-                    value: `${projectName} Access Token`,
-                    type: "string"
-                }
-            ]
-        };
-    }
-    next.item = rewriteCollectionItems(collection.item ?? [], {
-        markListAnonymous: true
-    });
-    return next;
-}
-function rewriteCollectionItems(items, opts) {
-    return items.map((item)=>{
-        if (item.item != null) {
-            return {
-                ...item,
-                item: rewriteCollectionItems(item.item, opts)
-            };
-        }
-        const request = item.request;
-        if (request == null) {
-            return item;
-        }
-        const method = (request.method ?? "GET").toUpperCase();
-        const rawUrl = requestUrlRaw(request);
-        const nextRequest = {
-            ...request,
-            url: toPostmanUrl(rawUrl)
-        };
-        // List Hello stays anonymous (matches scaffold AllowAnonymous on GET /hello).
-        if (opts.markListAnonymous && method === "GET" && normalizePath(rawUrl) === "/hello" && !rawUrl.includes("/:")) {
-            nextRequest.auth = {
-                type: "noauth"
-            };
-        }
-        return {
-            ...item,
-            request: nextRequest
-        };
-    });
-}
-function requestUrlRaw(request) {
-    const url = request.url;
-    if (typeof url === "string") {
-        return url;
-    }
-    if (url?.raw) {
-        return url.raw;
-    }
-    const host = url?.host?.[0] ?? "{{baseUrl}}";
-    const path = (url?.path ?? []).join("/");
-    return path ? `${host}/${path}` : host;
-}
-/** OpenAPI `{id}` → Postman `:id`, without touching `{{variables}}`. */ export function openApiPathParamsToColon(url) {
-    return url.replace(/(?<!\{)\{([A-Za-z_][\w]*)\}(?!\})/g, ":$1");
-}
-function normalizePath(rawUrl) {
-    const withoutBase = rawUrl.replace(/\{\{baseUrl\}\}/g, "").split("?")[0] ?? "";
-    const withSlash = withoutBase.startsWith("/") ? withoutBase : `/${withoutBase}`;
-    return openApiPathParamsToColon(withSlash);
-}
-/** Prefer Postman template URL shape used by existing Local View / API uploads. */ function toPostmanUrl(rawUrl) {
-    let pathPart = rawUrl.replace(/\{\{baseUrl\}\}/g, "");
-    if (!pathPart.startsWith("/")) {
-        pathPart = `/${pathPart}`;
-    }
-    // openapi-to-postman uses {id}; Local View / prior collections use :id
-    pathPart = openApiPathParamsToColon(pathPart);
-    const segments = pathPart.split("/").filter(Boolean);
-    return {
-        raw: `{{baseUrl}}${pathPart}`,
-        host: [
-            "{{baseUrl}}"
-        ],
-        path: segments
-    };
-}