@decohere/create 0.0.1-dev.36 → 0.0.1-dev.38

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

@@ -0,0 +1,168 @@
+/** 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"
+                        }
+                    }
+                }
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,169 @@
+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";
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/postman/local-view.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport {\n\ttype Auth0Env,\n\topenApiPathParamsToColon,\n\ttype PostmanCollection,\n\ttype PostmanItem,\n\ttype PostmanRequest,\n} from \"./openapi-to-postman.js\";\n\nfunction yamlQuote(value: string): string {\n\tif (/[:#{}[\\],&*?|<>=!%@`]/.test(value) || value.includes(\"\\n\") || value === \"\") {\n\t\treturn JSON.stringify(value);\n\t}\n\treturn value;\n}\n\n/** Local View / Native Git environment (YAML). */\nexport function buildEnvironmentYaml(\n\tname: string,\n\tauth: Auth0Env | undefined,\n\toptions: { callbacks: readonly string[]; scopes: string },\n): string {\n\tconst values: Array<{ key: string; value: string }> = [\n\t\t{ key: \"baseUrl\", value: \"http://localhost:3000\" },\n\t];\n\tif (auth?.auth0Domain) {\n\t\tvalues.push(\n\t\t\t{ key: \"auth0Domain\", value: auth.auth0Domain },\n\t\t\t{ key: \"auth0Audience\", value: auth.auth0Audience ?? \"\" },\n\t\t\t{ key: \"auth0ClientId\", value: auth.auth0ClientId ?? \"\" },\n\t\t\t{\n\t\t\t\tkey: \"authUrl\",\n\t\t\t\tvalue: `https://${auth.auth0Domain}/authorize?audience=${auth.auth0Audience ?? \"\"}`,\n\t\t\t},\n\t\t\t{\n\t\t\t\tkey: \"accessTokenUrl\",\n\t\t\t\tvalue: `https://${auth.auth0Domain}/oauth/token`,\n\t\t\t},\n\t\t\t{ key: \"callbackUrl\", value: options.callbacks[0] },\n\t\t\t{ key: \"scope\", value: options.scopes },\n\t\t);\n\t}\n\n\tconst lines = [`name: ${yamlQuote(name)}`, \"values:\"];\n\tfor (const v of values) {\n\t\tlines.push(`  - key: ${v.key}`);\n\t\tlines.push(`    value: ${yamlQuote(v.value)}`);\n\t\tlines.push(\"    enabled: true\");\n\t}\n\treturn `${lines.join(\"\\n\")}\\n`;\n}\n\n/**\n * Build Postman Local View multi-file YAML from a v2.1 collection (routes)\n * plus hand-authored Auth0 overlay.\n */\nexport function buildLocalViewFilesFromCollection(\n\tcollection: PostmanCollection,\n\tprojectName: string,\n\tauth: Auth0Env | undefined,\n\toptions: { callbacks: readonly string[]; scopes: string },\n): Array<{ filePath: string; content: string }> {\n\tconst collectionDir = `postman/collections/${projectName} WebAPI`;\n\tconst files: Array<{ filePath: string; content: string }> = [];\n\n\tconst authBlock = auth?.auth0Domain\n\t\t? [\n\t\t\t\t\"auth:\",\n\t\t\t\t`  - id: ${randomUUID()}`,\n\t\t\t\t\"    type: oauth2\",\n\t\t\t\t\"    name: OAuth 2.0\",\n\t\t\t\t\"    credentials:\",\n\t\t\t\t\"      addTokenTo: header\",\n\t\t\t\t\"      grant_type: authorization_code_with_pkce\",\n\t\t\t\t`      authUrl: https://${auth.auth0Domain}/authorize?audience=${auth.auth0Audience ?? \"\"}`,\n\t\t\t\t`      accessTokenUrl: https://${auth.auth0Domain}/oauth/token`,\n\t\t\t\t`      clientId: ${yamlQuote(auth.auth0ClientId ?? \"\")}`,\n\t\t\t\t`      scope: ${yamlQuote(options.scopes)}`,\n\t\t\t\t`      redirect_uri: ${options.callbacks[0]}`,\n\t\t\t\t\"      useBrowser: true\",\n\t\t\t\t\"      challengeAlgorithm: S256\",\n\t\t\t\t\"      client_authentication: body\",\n\t\t\t\t'      clientSecret: \"\"',\n\t\t\t\t`      tokenName: ${yamlQuote(`${projectName} Access Token`)}`,\n\t\t\t\t\"\",\n\t\t\t].join(\"\\n\")\n\t\t: \"\";\n\n\tfiles.push({\n\t\tfilePath: `${collectionDir}/.resources/definition.yaml`,\n\t\tcontent: [\n\t\t\t\"$kind: collection\",\n\t\t\t`name: ${yamlQuote(`${projectName} WebAPI`)}`,\n\t\t\t\"schemaVersion: '3.0'\",\n\t\t\t\"description: >-\",\n\t\t\t\"  Open this project root in Postman Local View (Files → Open folder).\",\n\t\t\t\"  Select the Local environment, then Authorization → Get New Access Token (PKCE).\",\n\t\t\t\"  Route requests are generated from OpenAPI; Auth0 overlay is hand-authored.\",\n\t\t\tauthBlock,\n\t\t]\n\t\t\t.filter((l) => l !== undefined)\n\t\t\t.join(\"\\n\")\n\t\t\t.replace(/\\n+$/, \"\\n\"),\n\t});\n\n\tlet folderOrder = 1000;\n\tfor (const folder of collection.item ?? []) {\n\t\tif (folder.item == null) {\n\t\t\tcontinue;\n\t\t}\n\t\tconst folderName = folder.name ?? \"Requests\";\n\t\tfiles.push({\n\t\t\tfilePath: `${collectionDir}/${folderName}/.resources/definition.yaml`,\n\t\t\tcontent: [\n\t\t\t\t\"$kind: folder\",\n\t\t\t\t`name: ${yamlQuote(folderName)}`,\n\t\t\t\t`order: ${folderOrder}`,\n\t\t\t\t\"\",\n\t\t\t].join(\"\\n\"),\n\t\t});\n\t\tfolderOrder += 1000;\n\n\t\tlet requestOrder = 1000;\n\t\tfor (const child of folder.item) {\n\t\t\tconst yaml = requestToLocalViewYaml(child, requestOrder);\n\t\t\tif (yaml == null) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst fileName = `${sanitizeFileName(child.name ?? \"Request\")}.request.yaml`;\n\t\t\tfiles.push({\n\t\t\t\tfilePath: `${collectionDir}/${folderName}/${fileName}`,\n\t\t\t\tcontent: yaml,\n\t\t\t});\n\t\t\trequestOrder += 1000;\n\t\t}\n\t}\n\n\treturn files;\n}\n\nfunction requestToLocalViewYaml(item: PostmanItem, order: number): string | null {\n\tconst request = item.request;\n\tif (request == null) {\n\t\treturn null;\n\t}\n\tconst method = (request.method ?? \"GET\").toUpperCase();\n\tconst url = requestUrlForLocalView(request);\n\tconst lines = [\n\t\t\"$kind: http-request\",\n\t\t`name: ${yamlQuote(item.name ?? method)}`,\n\t\t`method: ${method}`,\n\t\t`url: ${yamlQuote(url)}`,\n\t];\n\n\tif (request.auth?.type === \"noauth\") {\n\t\tlines.push(\"auth:\", \"  type: noauth\");\n\t}\n\n\tconst contentType = request.header?.find(\n\t\t(h) => h.key.toLowerCase() === \"content-type\",\n\t)?.value;\n\tconst rawBody = request.body?.raw?.trim();\n\tif (rawBody) {\n\t\tlines.push(\"headers:\");\n\t\tlines.push(`  Content-Type: ${contentType ?? \"application/json\"}`);\n\t\tlines.push(\"body:\");\n\t\tlines.push(\"  type: json\");\n\t\tlines.push(\"  content: |-\");\n\t\tfor (const bodyLine of rawBody.split(\"\\n\")) {\n\t\t\tlines.push(`    ${bodyLine}`);\n\t\t}\n\t}\n\n\tlines.push(`order: ${order}`, \"\");\n\treturn lines.join(\"\\n\");\n}\n\nfunction requestUrlForLocalView(request: PostmanRequest): string {\n\tconst url = request.url;\n\tif (typeof url === \"string\") {\n\t\treturn openApiPathParamsToColon(url);\n\t}\n\tif (url?.raw) {\n\t\treturn openApiPathParamsToColon(url.raw);\n\t}\n\tconst host = url?.host?.[0] ?? \"{{baseUrl}}\";\n\tconst path = (url?.path ?? [])\n\t\t.map((segment) => openApiPathParamsToColon(String(segment)))\n\t\t.join(\"/\");\n\treturn path ? `${host}/${path}` : host;\n}\n\nfunction sanitizeFileName(name: string): string {\n\treturn name.replace(/[^\\w\\s()-]+/g, \"\").trim() || \"Request\";\n}\n"],"names":["randomUUID","openApiPathParamsToColon","yamlQuote","value","test","includes","JSON","stringify","buildEnvironmentYaml","name","auth","options","values","key","auth0Domain","push","auth0Audience","auth0ClientId","callbacks","scopes","lines","v","join","buildLocalViewFilesFromCollection","collection","projectName","collectionDir","files","authBlock","filePath","content","filter","l","undefined","replace","folderOrder","folder","item","folderName","requestOrder","child","yaml","requestToLocalViewYaml","fileName","sanitizeFileName","order","request","method","toUpperCase","url","requestUrlForLocalView","type","contentType","header","find","h","toLowerCase","rawBody","body","raw","trim","bodyLine","split","host","path","map","segment","String"],"mappings":"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"}

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

@@ -0,0 +1,179 @@
+import converter from "openapi-to-postmanv2";
+function convertAsync(data, options) {
+    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
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/postman/openapi-to-postman.ts"],"sourcesContent":["import converter from \"openapi-to-postmanv2\";\nimport type { ScaffoldOpenApiDocument } from \"./hello-openapi.js\";\n\nexport type PostmanCollection = {\n\tinfo: {\n\t\t_postman_id?: string;\n\t\tname: string;\n\t\tschema: string;\n\t\tdescription?: string;\n\t};\n\tauth?: unknown;\n\titem?: PostmanItem[];\n\tvariable?: Array<{ key: string; value: string }>;\n\t[key: string]: unknown;\n};\n\nexport type PostmanItem = {\n\tname?: string;\n\titem?: PostmanItem[];\n\trequest?: PostmanRequest;\n\t[key: string]: unknown;\n};\n\nexport type PostmanRequest = {\n\tmethod?: string;\n\theader?: Array<{ key: string; value: string }>;\n\tbody?: { mode?: string; raw?: string };\n\turl?: string | { raw?: string; host?: string[]; path?: string[]; variable?: unknown[] };\n\tauth?: { type: string; [key: string]: unknown };\n\t[key: string]: unknown;\n};\n\nexport type Auth0Env = {\n\tauth0Domain?: string;\n\tauth0Audience?: string;\n\tauth0ClientId?: string;\n};\n\ntype ConvertResult = {\n\tresult: boolean;\n\treason?: string;\n\toutput?: Array<{ type: string; data: PostmanCollection }>;\n};\n\nfunction convertAsync(\n\tdata: ScaffoldOpenApiDocument,\n\toptions: Record<string, unknown>,\n): Promise<ConvertResult> {\n\treturn new Promise((resolve, reject) => {\n\t\tconverter.convert(\n\t\t\t{ type: \"json\", data },\n\t\t\toptions,\n\t\t\t(err: Error | null, result: ConvertResult) => {\n\t\t\t\tif (err) {\n\t\t\t\t\treject(err);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tresolve(result);\n\t\t\t},\n\t\t);\n\t});\n}\n\n/** Convert an OpenAPI document to a Postman Collection v2.1 via openapi-to-postmanv2. */\nexport async function openApiToPostmanCollection(\n\tdocument: ScaffoldOpenApiDocument,\n): Promise<PostmanCollection> {\n\tconst result = await convertAsync(document, {\n\t\tfolderStrategy: \"Tags\",\n\t\trequestNameSource: \"Fallback\",\n\t\tincludeAuthInfoInExample: false,\n\t});\n\tif (!result.result || result.output?.[0]?.data == null) {\n\t\tthrow new Error(result.reason ?? \"openapi-to-postmanv2 conversion failed\");\n\t}\n\treturn result.output[0].data;\n}\n\n/**\n * Overlay Auth0 OAuth2 (PKCE) collection auth and fix Local View-friendly URLs.\n * Route items come from OpenAPI; auth/env remain hand-authored.\n */\nexport function applyPostmanAuthOverlay(\n\tcollection: PostmanCollection,\n\tprojectName: string,\n\tauth: Auth0Env | undefined,\n\toptions: {\n\t\tcallbacks: readonly string[];\n\t\tscopes: string;\n\t\tdescription: string;\n\t},\n): PostmanCollection {\n\tconst next: PostmanCollection = {\n\t\t...collection,\n\t\tinfo: {\n\t\t\t...collection.info,\n\t\t\tname: `${projectName} WebAPI`,\n\t\t\tdescription: options.description,\n\t\t\tschema:\n\t\t\t\tcollection.info.schema ??\n\t\t\t\t\"https://schema.getpostman.com/json/collection/v2.1.0/collection.json\",\n\t\t},\n\t};\n\n\tif (auth?.auth0Domain) {\n\t\tnext.auth = {\n\t\t\ttype: \"oauth2\",\n\t\t\toauth2: [\n\t\t\t\t{ key: \"grant_type\", value: \"authorization_code_with_pkce\", type: \"string\" },\n\t\t\t\t{\n\t\t\t\t\tkey: \"authUrl\",\n\t\t\t\t\tvalue: \"https://{{auth0Domain}}/authorize?audience={{auth0Audience}}\",\n\t\t\t\t\ttype: \"string\",\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\tkey: \"accessTokenUrl\",\n\t\t\t\t\tvalue: \"https://{{auth0Domain}}/oauth/token\",\n\t\t\t\t\ttype: \"string\",\n\t\t\t\t},\n\t\t\t\t{ key: \"clientId\", value: \"{{auth0ClientId}}\", type: \"string\" },\n\t\t\t\t{ key: \"scope\", value: options.scopes, type: \"string\" },\n\t\t\t\t{ key: \"redirect_uri\", value: options.callbacks[0], type: \"string\" },\n\t\t\t\t{ key: \"useBrowser\", value: \"true\", type: \"boolean\" },\n\t\t\t\t{ key: \"addTokenTo\", value: \"header\", type: \"string\" },\n\t\t\t\t{ key: \"challengeAlgorithm\", value: \"S256\", type: \"string\" },\n\t\t\t\t{ key: \"client_authentication\", value: \"body\", type: \"string\" },\n\t\t\t\t{ key: \"clientSecret\", value: \"\", type: \"string\" },\n\t\t\t\t{ key: \"tokenName\", value: `${projectName} Access Token`, type: \"string\" },\n\t\t\t],\n\t\t};\n\t}\n\n\tnext.item = rewriteCollectionItems(collection.item ?? [], {\n\t\tmarkListAnonymous: true,\n\t});\n\treturn next;\n}\n\nfunction rewriteCollectionItems(\n\titems: PostmanItem[],\n\topts: { markListAnonymous: boolean },\n): PostmanItem[] {\n\treturn items.map((item) => {\n\t\tif (item.item != null) {\n\t\t\treturn { ...item, item: rewriteCollectionItems(item.item, opts) };\n\t\t}\n\t\tconst request = item.request;\n\t\tif (request == null) {\n\t\t\treturn item;\n\t\t}\n\t\tconst method = (request.method ?? \"GET\").toUpperCase();\n\t\tconst rawUrl = requestUrlRaw(request);\n\t\tconst nextRequest: PostmanRequest = {\n\t\t\t...request,\n\t\t\turl: toPostmanUrl(rawUrl),\n\t\t};\n\t\t// List Hello stays anonymous (matches scaffold AllowAnonymous on GET /hello).\n\t\tif (\n\t\t\topts.markListAnonymous &&\n\t\t\tmethod === \"GET\" &&\n\t\t\tnormalizePath(rawUrl) === \"/hello\" &&\n\t\t\t!rawUrl.includes(\"/:\")\n\t\t) {\n\t\t\tnextRequest.auth = { type: \"noauth\" };\n\t\t}\n\t\treturn { ...item, request: nextRequest };\n\t});\n}\n\nfunction requestUrlRaw(request: PostmanRequest): string {\n\tconst url = request.url;\n\tif (typeof url === \"string\") {\n\t\treturn url;\n\t}\n\tif (url?.raw) {\n\t\treturn url.raw;\n\t}\n\tconst host = url?.host?.[0] ?? \"{{baseUrl}}\";\n\tconst path = (url?.path ?? []).join(\"/\");\n\treturn path ? `${host}/${path}` : host;\n}\n\n/** OpenAPI `{id}` → Postman `:id`, without touching `{{variables}}`. */\nexport function openApiPathParamsToColon(url: string): string {\n\treturn url.replace(/(?<!\\{)\\{([A-Za-z_][\\w]*)\\}(?!\\})/g, \":$1\");\n}\n\nfunction normalizePath(rawUrl: string): string {\n\tconst withoutBase = rawUrl.replace(/\\{\\{baseUrl\\}\\}/g, \"\").split(\"?\")[0] ?? \"\";\n\tconst withSlash = withoutBase.startsWith(\"/\") ? withoutBase : `/${withoutBase}`;\n\treturn openApiPathParamsToColon(withSlash);\n}\n\n/** Prefer Postman template URL shape used by existing Local View / API uploads. */\nfunction toPostmanUrl(rawUrl: string): PostmanRequest[\"url\"] {\n\tlet pathPart = rawUrl.replace(/\\{\\{baseUrl\\}\\}/g, \"\");\n\tif (!pathPart.startsWith(\"/\")) {\n\t\tpathPart = `/${pathPart}`;\n\t}\n\t// openapi-to-postman uses {id}; Local View / prior collections use :id\n\tpathPart = openApiPathParamsToColon(pathPart);\n\tconst segments = pathPart.split(\"/\").filter(Boolean);\n\treturn {\n\t\traw: `{{baseUrl}}${pathPart}`,\n\t\thost: [\"{{baseUrl}}\"],\n\t\tpath: segments,\n\t};\n}\n"],"names":["converter","convertAsync","data","options","Promise","resolve","reject","convert","type","err","result","openApiToPostmanCollection","document","folderStrategy","requestNameSource","includeAuthInfoInExample","output","Error","reason","applyPostmanAuthOverlay","collection","projectName","auth","next","info","name","description","schema","auth0Domain","oauth2","key","value","scopes","callbacks","item","rewriteCollectionItems","markListAnonymous","items","opts","map","request","method","toUpperCase","rawUrl","requestUrlRaw","nextRequest","url","toPostmanUrl","normalizePath","includes","raw","host","path","join","openApiPathParamsToColon","replace","withoutBase","split","withSlash","startsWith","pathPart","segments","filter","Boolean"],"mappings":"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"}

package/package.json

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

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

@@ -22,6 +22,8 @@ export interface ComposeService {
     command?: string;
     restart?: string;
     depends_on?: string[];
+    /** Compose profiles (service only starts when profile is enabled). */
+    profiles?: string[];
     /** Attach to compose networks (string name or map with aliases). */
     networks?: ComposeNetworkRef[];
     healthcheck?: ComposeHealthcheck;

package/types/src/webapi/features/postman.feature.d.ts

@@ -1,4 +1,5 @@
 import type { Feature } from "../../services/scaffold.service.js";
+import { type Auth0Env } from "../postman/openapi-to-postman.js";
 /** Postman OAuth callback URLs (popup + "Authorize using browser"). */
 declare const POSTMAN_CALLBACKS: readonly ["https://oauth.pstmn.io/v1/callback", "https://oauth.pstmn.io/v1/browser-callback"];
 /** Scopes requested for Auth0 access tokens (OIDC + Hello CASL permissions). */
@@ -8,5 +9,8 @@ export type PostmanOptions = {
     apiKey?: string;
     workspaceId?: string;
 };
+/** Build Postman collection: OpenAPI routes + Auth0 auth overlay. */
+export declare function buildHybridPostmanCollection(projectName: string, auth?: Auth0Env): Promise<import("../postman/openapi-to-postman.js").PostmanCollection>;
 export declare const PostmanFeature: Feature<PostmanOptions>;
+export { buildHelloOpenApiDocument } from "../postman/hello-openapi.js";
 export { POSTMAN_CALLBACKS, POSTMAN_SCOPES };

package/types/src/webapi/postman/hello-openapi.d.ts

@@ -0,0 +1,19 @@
+/** Minimal OpenAPI 3 document shape used for Postman conversion. */
+export type ScaffoldOpenApiDocument = {
+    openapi: "3.0.3";
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+    };
+    servers?: Array<{
+        url: string;
+        description?: string;
+    }>;
+    paths: Record<string, Record<string, unknown>>;
+};
+/**
+ * Canonical Hello WebAPI OpenAPI document used to generate Postman requests.
+ * Keep paths aligned with scaffolded HelloController (`/hello`, `/hello/{id}`).
+ */
+export declare function buildHelloOpenApiDocument(projectName: string): ScaffoldOpenApiDocument;