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

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

@@ -0,0 +1,184 @@
+"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 buildEnvironmentYaml () {
+        return buildEnvironmentYaml;
+    },
+    get buildLocalViewFilesFromCollection () {
+        return buildLocalViewFilesFromCollection;
+    }
+});
+const _nodecrypto = require("node:crypto");
+const _openapitopostman = require("./openapi-to-postman.js");
+function yamlQuote(value) {
+    if (/[:#{}[\],&*?|<>=!%@`]/.test(value) || value.includes("\n") || value === "") {
+        return JSON.stringify(value);
+    }
+    return value;
+}
+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`;
+}
+function buildLocalViewFilesFromCollection(collection, projectName, auth, options) {
+    const collectionDir = `postman/collections/${projectName} WebAPI`;
+    const files = [];
+    const authBlock = auth?.auth0Domain ? [
+        "auth:",
+        `  - id: ${(0, _nodecrypto.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 (0, _openapitopostman.openApiPathParamsToColon)(url);
+    }
+    if (url?.raw) {
+        return (0, _openapitopostman.openApiPathParamsToColon)(url.raw);
+    }
+    const host = url?.host?.[0] ?? "{{baseUrl}}";
+    const path = (url?.path ?? []).map((segment)=>(0, _openapitopostman.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/scaffold/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":["buildEnvironmentYaml","buildLocalViewFilesFromCollection","yamlQuote","value","test","includes","JSON","stringify","name","auth","options","values","key","auth0Domain","push","auth0Audience","auth0ClientId","callbacks","scopes","lines","v","join","collection","projectName","collectionDir","files","authBlock","randomUUID","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","openApiPathParamsToColon","host","path","map","segment","String"],"mappings":"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"}

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

@@ -0,0 +1,202 @@
+"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 applyPostmanAuthOverlay () {
+        return applyPostmanAuthOverlay;
+    },
+    get openApiPathParamsToColon () {
+        return openApiPathParamsToColon;
+    },
+    get openApiToPostmanCollection () {
+        return openApiToPostmanCollection;
+    }
+});
+const _openapitopostmanv2 = /*#__PURE__*/ _interop_require_default(require("openapi-to-postmanv2"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function convertAsync(data, options) {
+    return new Promise((resolve, reject)=>{
+        _openapitopostmanv2.default.convert({
+            type: "json",
+            data
+        }, options, (err, result)=>{
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(result);
+        });
+    });
+}
+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;
+}
+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;
+}
+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/scaffold/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":["applyPostmanAuthOverlay","openApiPathParamsToColon","openApiToPostmanCollection","convertAsync","data","options","Promise","resolve","reject","converter","convert","type","err","result","document","folderStrategy","requestNameSource","includeAuthInfoInExample","output","Error","reason","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","replace","withoutBase","split","withSlash","startsWith","pathPart","segments","filter","Boolean"],"mappings":"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"}

package/commonjs/src/webapi/workspace-readme.js

@@ -0,0 +1,110 @@
+"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 renderWorkspaceReadme () {
+        return renderWorkspaceReadme;
+    },
+    get resolveWorkspaceReadmeInput () {
+        return resolveWorkspaceReadmeInput;
+    },
+    get writeWorkspaceReadme () {
+        return writeWorkspaceReadme;
+    }
+});
+const _nodefs = require("node:fs");
+const _nodepath = require("node:path");
+const _const = require("../models/const.js");
+const _apiname = require("./api-name.js");
+function renderWorkspaceReadme(input) {
+    const { projectName, apiNames, hasPostgres, hasAuth0, hasPostman } = input;
+    const apis = apiNames.length > 0 ? apiNames : [
+        "api"
+    ];
+    const lines = [
+        `# ${projectName}`,
+        "",
+        "Decohere web API workspace. Scaffolded with [`@decohere/create`](https://www.npmjs.com/package/@decohere/create).",
+        "",
+        "## Get started",
+        "",
+        "1. Open this folder in VS Code / Cursor.",
+        "2. **Reopen in Container** (or rebuild the Dev Container).",
+        "   Host `initialize.sh` and container `post-start.sh` ask y/N (TTY only) before npm auth or codebase RAG MCP.",
+        "   Skip or decline; missing TTY skips. RAG credentials land in `.cursor/` (gitignored).",
+        "3. Install dependencies if needed:",
+        "",
+        "```bash",
+        "pnpm install",
+        "```",
+        "",
+        "## Develop",
+        "",
+        "```bash",
+        "pnpm dev              # Flux HMR (first API)",
+        "pnpm start            # run the compiled first API",
+        "pnpm run build        # forge release build"
+    ];
+    for (const name of apis){
+        lines.push(`pnpm run dev:${name}     # HMR for ${name}`);
+        lines.push(`pnpm run start:${name}   # production entry for ${name}`);
+    }
+    lines.push("```", "");
+    lines.push("## Logging", "", "In development, Scribe uses pino-pretty and rolling files under `logs/` (gitignored).", "When `NODE_ENV=production`, the process writes structured JSON to stdout and does not rotate files.", "Ship and retain those streams outside the app (platform logs, a sidecar, or a log agent) so shipping can change without rebuilding.", "", "Override roll path and rotation without changing app code:", "`SCRIBE_LOG_FILE`, `SCRIBE_LOG_SIZE`, `SCRIBE_LOG_FREQUENCY`, `SCRIBE_LOG_KEEP`.", "", 'Opt into in-process pretty or roll in production only with `{ when: "always" }` on `scribe.withPinoPretty` / `scribe.withPinoRoll`.', "");
+    if (hasPostgres) {
+        lines.push("## Database", "", "Postgres runs via Dev Container Compose:", "", "```bash", "pnpm db:up", "pnpm db:down", "pnpm db:reset", "```", "");
+    }
+    lines.push("## Deploy", "", "PaaS hosts (`docker build` from the repo root) use the scaffolded `Dockerfile`.", "The runtime image installs production dependencies only (`pnpm install --prod`);", "Forge, TypeScript, Biome, and Vitest stay in the build stage.", "", "```bash", `docker build -t ${projectName} .`, "```", "", "Extra APIs: `docker build -f Dockerfile.<name> .`", "");
+    lines.push("## Add another API", "", "```bash", "decohere add api <name>", "```", "", "Example: `decohere add api billing`", "");
+    if (hasAuth0) {
+        lines.push("## Auth0", "", "JWT auth is wired from `.env` (`AUTH0_ISSUER_BASE_URL`, `AUTH0_AUDIENCE`).", "Set those values (or re-run scaffold with `--auth auth0`) before calling protected routes.", "");
+    }
+    if (hasPostman) {
+        lines.push("## Postman", "", "Open this **project root** in Postman Local View (Files → Open folder), not the `postman/` subfolder.", "Select the Local environment, then Authorization → Get New Access Token when Auth0 is enabled.", "");
+    }
+    lines.push("## More", "", "- Package docs: https://www.npmjs.com/package/@decohere/create", "- After `decohere add api`, this README is refreshed so scripts and APIs stay accurate.", "");
+    return `${lines.join("\n")}`;
+}
+function resolveWorkspaceReadmeInput(workspace, options) {
+    const newNames = workspace.getProjects().map((project)=>(0, _apiname.apiNameFromProjectDir)(project.dir));
+    const apiNames = options.add ? mergeApiNames((0, _apiname.listExistingApiNames)(workspace.targetDir), newNames) : newNames;
+    const pkg = workspace.getModel(_const.WELL_KNOWN_FILES.PACKAGE_JSON);
+    const env = workspace.getModel(_const.WELL_KNOWN_FILES.ENV_FILE);
+    const hasPostgres = options.databaseProvider === "postgres/typeorm" || Boolean(pkg?.hasScript("db:up"));
+    const hasAuth0 = options.authProvider === "auth0" || Boolean(env?.hasEntry("AUTH0_ISSUER_BASE_URL"));
+    const hasPostman = options.postmanProvider === "local" || options.postmanProvider === "api" || (0, _nodefs.existsSync)((0, _nodepath.join)(workspace.targetDir, "postman")) || (0, _nodefs.existsSync)((0, _nodepath.join)(workspace.targetDir, ".postman"));
+    return {
+        projectName: workspace.name,
+        apiNames,
+        hasPostgres,
+        hasAuth0,
+        hasPostman
+    };
+}
+function writeWorkspaceReadme(workspace, options) {
+    const content = renderWorkspaceReadme(resolveWorkspaceReadmeInput(workspace, options));
+    workspace.addFile({
+        files: ()=>[
+                {
+                    filePath: "README.md",
+                    content
+                }
+            ]
+    });
+}
+function mergeApiNames(existing, added) {
+    const seen = new Set(existing);
+    return [
+        ...existing,
+        ...added.filter((name)=>!seen.has(name))
+    ];
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/webapi/workspace-readme.ts"],"sourcesContent":["import { existsSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { WELL_KNOWN_FILES } from \"../models/const.js\";\nimport type { EnvFile } from \"../models/env-file.model.js\";\nimport type { PackageJson } from \"../models/package-json.model.js\";\nimport type { WorkspaceScaffold } from \"../models/project.model.js\";\nimport { apiNameFromProjectDir, listExistingApiNames } from \"./api-name.js\";\n\nexport type WorkspaceReadmeOptions = {\n\tadd?: boolean;\n\tdatabaseProvider?: \"none\" | \"postgres/typeorm\";\n\tauthProvider?: \"auth0\" | \"none\";\n\tpostmanProvider?: \"api\" | \"local\" | \"none\";\n};\n\nexport type WorkspaceReadmeInput = {\n\tprojectName: string;\n\tapiNames: readonly string[];\n\thasPostgres: boolean;\n\thasAuth0: boolean;\n\thasPostman: boolean;\n};\n\n/** Pure renderer — keep feature sections short and copy-paste ready. */\nexport function renderWorkspaceReadme(input: WorkspaceReadmeInput): string {\n\tconst { projectName, apiNames, hasPostgres, hasAuth0, hasPostman } = input;\n\tconst apis = apiNames.length > 0 ? apiNames : [\"api\"];\n\tconst lines: string[] = [\n\t\t`# ${projectName}`,\n\t\t\"\",\n\t\t\"Decohere web API workspace. Scaffolded with [`@decohere/create`](https://www.npmjs.com/package/@decohere/create).\",\n\t\t\"\",\n\t\t\"## Get started\",\n\t\t\"\",\n\t\t\"1. Open this folder in VS Code / Cursor.\",\n\t\t\"2. **Reopen in Container** (or rebuild the Dev Container).\",\n\t\t\"   Host `initialize.sh` and container `post-start.sh` ask y/N (TTY only) before npm auth or codebase RAG MCP.\",\n\t\t\"   Skip or decline; missing TTY skips. RAG credentials land in `.cursor/` (gitignored).\",\n\t\t\"3. Install dependencies if needed:\",\n\t\t\"\",\n\t\t\"```bash\",\n\t\t\"pnpm install\",\n\t\t\"```\",\n\t\t\"\",\n\t\t\"## Develop\",\n\t\t\"\",\n\t\t\"```bash\",\n\t\t\"pnpm dev              # Flux HMR (first API)\",\n\t\t\"pnpm start            # run the compiled first API\",\n\t\t\"pnpm run build        # forge release build\",\n\t];\n\n\tfor (const name of apis) {\n\t\tlines.push(`pnpm run dev:${name}     # HMR for ${name}`);\n\t\tlines.push(`pnpm run start:${name}   # production entry for ${name}`);\n\t}\n\n\tlines.push(\"```\", \"\");\n\n\tlines.push(\n\t\t\"## Logging\",\n\t\t\"\",\n\t\t\"In development, Scribe uses pino-pretty and rolling files under `logs/` (gitignored).\",\n\t\t\"When `NODE_ENV=production`, the process writes structured JSON to stdout and does not rotate files.\",\n\t\t\"Ship and retain those streams outside the app (platform logs, a sidecar, or a log agent) so shipping can change without rebuilding.\",\n\t\t\"\",\n\t\t\"Override roll path and rotation without changing app code:\",\n\t\t\"`SCRIBE_LOG_FILE`, `SCRIBE_LOG_SIZE`, `SCRIBE_LOG_FREQUENCY`, `SCRIBE_LOG_KEEP`.\",\n\t\t\"\",\n\t\t'Opt into in-process pretty or roll in production only with `{ when: \"always\" }` on `scribe.withPinoPretty` / `scribe.withPinoRoll`.',\n\t\t\"\",\n\t);\n\n\tif (hasPostgres) {\n\t\tlines.push(\n\t\t\t\"## Database\",\n\t\t\t\"\",\n\t\t\t\"Postgres runs via Dev Container Compose:\",\n\t\t\t\"\",\n\t\t\t\"```bash\",\n\t\t\t\"pnpm db:up\",\n\t\t\t\"pnpm db:down\",\n\t\t\t\"pnpm db:reset\",\n\t\t\t\"```\",\n\t\t\t\"\",\n\t\t);\n\t}\n\n\tlines.push(\n\t\t\"## Deploy\",\n\t\t\"\",\n\t\t\"PaaS hosts (`docker build` from the repo root) use the scaffolded `Dockerfile`.\",\n\t\t\"The runtime image installs production dependencies only (`pnpm install --prod`);\",\n\t\t\"Forge, TypeScript, Biome, and Vitest stay in the build stage.\",\n\t\t\"\",\n\t\t\"```bash\",\n\t\t`docker build -t ${projectName} .`,\n\t\t\"```\",\n\t\t\"\",\n\t\t\"Extra APIs: `docker build -f Dockerfile.<name> .`\",\n\t\t\"\",\n\t);\n\n\tlines.push(\n\t\t\"## Add another API\",\n\t\t\"\",\n\t\t\"```bash\",\n\t\t\"decohere add api <name>\",\n\t\t\"```\",\n\t\t\"\",\n\t\t\"Example: `decohere add api billing`\",\n\t\t\"\",\n\t);\n\n\tif (hasAuth0) {\n\t\tlines.push(\n\t\t\t\"## Auth0\",\n\t\t\t\"\",\n\t\t\t\"JWT auth is wired from `.env` (`AUTH0_ISSUER_BASE_URL`, `AUTH0_AUDIENCE`).\",\n\t\t\t\"Set those values (or re-run scaffold with `--auth auth0`) before calling protected routes.\",\n\t\t\t\"\",\n\t\t);\n\t}\n\n\tif (hasPostman) {\n\t\tlines.push(\n\t\t\t\"## Postman\",\n\t\t\t\"\",\n\t\t\t\"Open this **project root** in Postman Local View (Files → Open folder), not the `postman/` subfolder.\",\n\t\t\t\"Select the Local environment, then Authorization → Get New Access Token when Auth0 is enabled.\",\n\t\t\t\"\",\n\t\t);\n\t}\n\n\tlines.push(\n\t\t\"## More\",\n\t\t\"\",\n\t\t\"- Package docs: https://www.npmjs.com/package/@decohere/create\",\n\t\t\"- After `decohere add api`, this README is refreshed so scripts and APIs stay accurate.\",\n\t\t\"\",\n\t);\n\n\treturn `${lines.join(\"\\n\")}`;\n}\n\nexport function resolveWorkspaceReadmeInput(\n\tworkspace: WorkspaceScaffold,\n\toptions: WorkspaceReadmeOptions,\n): WorkspaceReadmeInput {\n\tconst newNames = workspace\n\t\t.getProjects()\n\t\t.map((project) => apiNameFromProjectDir(project.dir));\n\tconst apiNames = options.add\n\t\t? mergeApiNames(listExistingApiNames(workspace.targetDir), newNames)\n\t\t: newNames;\n\n\tconst pkg = workspace.getModel<PackageJson>(WELL_KNOWN_FILES.PACKAGE_JSON);\n\tconst env = workspace.getModel<EnvFile>(WELL_KNOWN_FILES.ENV_FILE);\n\n\tconst hasPostgres =\n\t\toptions.databaseProvider === \"postgres/typeorm\" || Boolean(pkg?.hasScript(\"db:up\"));\n\tconst hasAuth0 =\n\t\toptions.authProvider === \"auth0\" || Boolean(env?.hasEntry(\"AUTH0_ISSUER_BASE_URL\"));\n\tconst hasPostman =\n\t\toptions.postmanProvider === \"local\" ||\n\t\toptions.postmanProvider === \"api\" ||\n\t\texistsSync(join(workspace.targetDir, \"postman\")) ||\n\t\texistsSync(join(workspace.targetDir, \".postman\"));\n\n\treturn {\n\t\tprojectName: workspace.name,\n\t\tapiNames,\n\t\thasPostgres,\n\t\thasAuth0,\n\t\thasPostman,\n\t};\n}\n\nexport function writeWorkspaceReadme(\n\tworkspace: WorkspaceScaffold,\n\toptions: WorkspaceReadmeOptions,\n): void {\n\tconst content = renderWorkspaceReadme(resolveWorkspaceReadmeInput(workspace, options));\n\tworkspace.addFile({\n\t\tfiles: () => [{ filePath: \"README.md\", content }],\n\t});\n}\n\nfunction mergeApiNames(existing: readonly string[], added: readonly string[]): string[] {\n\tconst seen = new Set(existing);\n\treturn [...existing, ...added.filter((name) => !seen.has(name))];\n}\n"],"names":["renderWorkspaceReadme","resolveWorkspaceReadmeInput","writeWorkspaceReadme","input","projectName","apiNames","hasPostgres","hasAuth0","hasPostman","apis","length","lines","name","push","join","workspace","options","newNames","getProjects","map","project","apiNameFromProjectDir","dir","add","mergeApiNames","listExistingApiNames","targetDir","pkg","getModel","WELL_KNOWN_FILES","PACKAGE_JSON","env","ENV_FILE","databaseProvider","Boolean","hasScript","authProvider","hasEntry","postmanProvider","existsSync","content","addFile","files","filePath","existing","added","seen","Set","filter","has"],"mappings":"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"}

package/commonjs/src/webapi.action.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WebapiAction", {
+    enumerable: true,
+    get: function() {
+        return WebapiAction;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _cli = require("@decohere/nexus/cli");
+const _clioptions = require("./webapi/cli-options.js");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+class WebapiAction {
+    async run(options) {
+        await (0, _clioptions.runScaffoldApi)((0, _clioptions.toApiOptions)(options.directory, options));
+        return _cli.ActionResponse.Success("webapi");
+    }
+}
+WebapiAction = _ts_decorate([
+    (0, _decorators.injectable)()
+], WebapiAction);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy93ZWJhcGkuYWN0aW9uLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGluamVjdGFibGUgfSBmcm9tIFwiQGRlY29oZXJlL2NydWNpYmxlL2RlY29yYXRvcnNcIjtcbmltcG9ydCB7IHR5cGUgQWN0aW9uLCBBY3Rpb25SZXNwb25zZSB9IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvY2xpXCI7XG5pbXBvcnQgeyBydW5TY2FmZm9sZEFwaSwgdG9BcGlPcHRpb25zIH0gZnJvbSBcIi4vd2ViYXBpL2NsaS1vcHRpb25zLmpzXCI7XG5cbmV4cG9ydCB0eXBlIFdlYmFwaU9wdGlvbnMgPSB7XG5cdGRpcmVjdG9yeT86IHN0cmluZztcblx0ZD86IHN0cmluZztcblx0bmFtZT86IHN0cmluZyB8IHN0cmluZ1tdO1xuXHRkYXRhYmFzZT86IHN0cmluZztcblx0YXV0aD86IHN0cmluZztcblx0cG9zdG1hbj86IHN0cmluZztcblx0eWVzPzogYm9vbGVhbjtcblx0aW5zdGFsbD86IHN0cmluZztcbn07XG5cbkBpbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBXZWJhcGlBY3Rpb24gaW1wbGVtZW50cyBBY3Rpb248V2ViYXBpT3B0aW9ucz4ge1xuXHRwdWJsaWMgYXN5bmMgcnVuKG9wdGlvbnM6IFdlYmFwaU9wdGlvbnMpOiBQcm9taXNlPEFjdGlvblJlc3BvbnNlPiB7XG5cdFx0YXdhaXQgcnVuU2NhZmZvbGRBcGkodG9BcGlPcHRpb25zKG9wdGlvbnMuZGlyZWN0b3J5LCBvcHRpb25zKSk7XG5cdFx0cmV0dXJuIEFjdGlvblJlc3BvbnNlLlN1Y2Nlc3MoXCJ3ZWJhcGlcIik7XG5cdH1cbn1cbiJdLCJuYW1lcyI6WyJXZWJhcGlBY3Rpb24iLCJydW4iLCJvcHRpb25zIiwicnVuU2NhZmZvbGRBcGkiLCJ0b0FwaU9wdGlvbnMiLCJkaXJlY3RvcnkiLCJBY3Rpb25SZXNwb25zZSIsIlN1Y2Nlc3MiXSwibWFwcGluZ3MiOiI7Ozs7K0JBZ0JhQTs7O2VBQUFBOzs7NEJBaEJjO3FCQUNpQjs0QkFDQzs7Ozs7OztBQWN0QyxNQUFNQTtJQUNaLE1BQWFDLElBQUlDLE9BQXNCLEVBQTJCO1FBQ2pFLE1BQU1DLElBQUFBLDBCQUFjLEVBQUNDLElBQUFBLHdCQUFZLEVBQUNGLFFBQVFHLFNBQVMsRUFBRUg7UUFDckQsT0FBT0ksbUJBQWMsQ0FBQ0MsT0FBTyxDQUFDO0lBQy9CO0FBQ0QifQ==