@decohere/create 0.0.1-dev.23 → 0.0.1-dev.25

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

@@ -1,6 +1,20 @@
+import { randomUUID } from "node:crypto";
 import { pick } from "../../domain/prompt.js";
 import { WELL_KNOWN_FILES } from "../../models/const.js";
 import * as auth0Cli from "./auth0-cli.js";
+/** Postman OAuth callback URLs (popup + "Authorize using browser"). */ const POSTMAN_CALLBACKS = [
+    "https://oauth.pstmn.io/v1/callback",
+    "https://oauth.pstmn.io/v1/browser-callback"
+];
+/** Scopes requested for Auth0 access tokens (OIDC + Hello CASL permissions). */ const POSTMAN_SCOPES = [
+    "openid",
+    "profile",
+    "email",
+    "read:Hello",
+    "create:Hello",
+    "update:Hello",
+    "delete:Hello"
+].join(" ");
 async function getOptions(_workspace, cliOptions) {
     if (cliOptions.postmanProvider != null) return {};
     const choices = [
@@ -10,11 +24,11 @@ async function getOptions(_workspace, cliOptions) {
         },
         {
             label: "local",
-            description: "write collection + environment files"
+            description: "Local View / Native Git files (no API key)"
         },
         {
             label: "api",
-            description: "write files and upload to Postman.com"
+            description: "also upload to Postman.com (needs API key)"
         }
     ];
     const selected = await pick("\n  Postman: ", choices, (c)=>`${c.label} — ${c.description}`);
@@ -25,7 +39,6 @@ async function getOptions(_workspace, cliOptions) {
     if (provider === "local") return {
         postmanProvider: "local"
     };
-    // api: collect API key + workspace selection
     const apiKey = process.env.POSTMAN_API_KEY ?? await import("../../domain/prompt.js").then((m)=>m.ask("\n  Postman API key (app.getpostman.com/settings/me/api-keys): "));
     const headers = {
         "X-Api-Key": apiKey,
@@ -78,7 +91,7 @@ async function getOptions(_workspace, cliOptions) {
         workspaceId
     };
 }
-function buildCollection(projectName, auth) {
+/** v2.1 JSON — used for Postman.com API upload only. */ function buildCollectionJson(projectName, auth) {
     const authObj = auth?.auth0Domain ? {
         type: "oauth2",
         oauth2: [
@@ -104,9 +117,19 @@ function buildCollection(projectName, auth) {
             },
             {
                 key: "scope",
-                value: "openid profile email",
+                value: POSTMAN_SCOPES,
                 type: "string"
             },
+            {
+                key: "redirect_uri",
+                value: POSTMAN_CALLBACKS[0],
+                type: "string"
+            },
+            {
+                key: "useBrowser",
+                value: "true",
+                type: "boolean"
+            },
             {
                 key: "addTokenTo",
                 value: "header",
@@ -116,13 +139,37 @@ function buildCollection(projectName, auth) {
                 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"
             }
         ]
     } : undefined;
+    const helloUrl = (path, raw)=>({
+            raw: `{{baseUrl}}${raw}`,
+            host: [
+                "{{baseUrl}}"
+            ],
+            path: path.split("/").filter(Boolean)
+        });
     return {
         info: {
+            _postman_id: randomUUID(),
             name: `${projectName} WebAPI`,
-            schema: "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+            schema: "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
+            description: "Open the project root in Postman Local View (not the postman/ folder). " + "Select the Local environment, then Authorization → Get New Access Token (PKCE)."
         },
         ...authObj ? {
             auth: authObj
@@ -130,46 +177,268 @@ function buildCollection(projectName, auth) {
         item: [
             {
                 name: "Hello",
-                request: {
-                    method: "GET",
-                    url: {
-                        raw: "{{baseUrl}}/hello",
-                        host: [
-                            "{{baseUrl}}"
-                        ],
-                        path: [
-                            "hello"
-                        ]
+                item: [
+                    {
+                        name: "List (anonymous)",
+                        request: {
+                            auth: {
+                                type: "noauth"
+                            },
+                            method: "GET",
+                            url: helloUrl("hello", "/hello")
+                        }
+                    },
+                    {
+                        name: "Get by id",
+                        request: {
+                            method: "GET",
+                            url: helloUrl("hello/:id", "/hello/:id")
+                        }
+                    },
+                    {
+                        name: "Create",
+                        request: {
+                            method: "POST",
+                            header: [
+                                {
+                                    key: "Content-Type",
+                                    value: "application/json"
+                                }
+                            ],
+                            body: {
+                                mode: "raw",
+                                raw: '{\n  "message": "hello"\n}\n'
+                            },
+                            url: helloUrl("hello", "/hello")
+                        }
+                    },
+                    {
+                        name: "Update",
+                        request: {
+                            method: "PUT",
+                            header: [
+                                {
+                                    key: "Content-Type",
+                                    value: "application/json"
+                                }
+                            ],
+                            body: {
+                                mode: "raw",
+                                raw: '{\n  "message": "updated"\n}\n'
+                            },
+                            url: helloUrl("hello/:id", "/hello/:id")
+                        }
+                    },
+                    {
+                        name: "Delete",
+                        request: {
+                            method: "DELETE",
+                            url: helloUrl("hello/:id", "/hello/:id")
+                        }
                     }
-                }
+                ]
             }
         ]
     };
 }
-function buildEnvironmentYaml(name, auth) {
-    const auth0Section = auth?.auth0Domain ? [
-        "  - key: auth0Domain",
-        `    value: ${auth.auth0Domain}`,
-        "  - key: auth0Audience",
-        `    value: '${auth.auth0Audience ?? ""}'`,
-        "  - key: auth0ClientId",
-        `    value: '${auth.auth0ClientId ?? ""}'`,
-        "    description: Client ID of the Auth0 SPA application used by Postman for PKCE authentication"
-    ].join("\n") + "\n" : "";
-    return `name: ${name}\nvalues:\n  - key: baseUrl\n    value: 'http://localhost:3000'\n${auth0Section}`;
+function yamlQuote(value) {
+    if (/[:#{}[\],&*?|<>=!%@`]/.test(value) || value.includes("\n") || value === "") {
+        return JSON.stringify(value);
+    }
+    return value;
+}
+/** Local View / Native Git environment (YAML). */ function buildEnvironmentYaml(name, auth) {
+    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: POSTMAN_CALLBACKS[0]
+        }, {
+            key: "scope",
+            value: POSTMAN_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`;
+}
+/** Local View / Native Git collection (v3 multi-file YAML). */ function buildLocalViewFiles(projectName, auth) {
+    const collectionDir = `postman/collections/${projectName} WebAPI`;
+    const files = [];
+    // Postman Local View stores OAuth under auth[].credentials (not the v2.1 oauth2 array).
+    // Use concrete https URLs — empty Auth URL yields "Invalid protocol for auth URL".
+    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(POSTMAN_SCOPES)}`,
+        `      redirect_uri: ${POSTMAN_CALLBACKS[0]}`,
+        "      useBrowser: true",
+        "      challengeAlgorithm: S256",
+        // SPA public client: Auth0 token endpoint rejects Basic auth (feacft Unauthorized).
+        "      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).",
+            authBlock
+        ].filter((l)=>l !== undefined).join("\n").replace(/\n+$/, "\n")
+    });
+    files.push({
+        filePath: `${collectionDir}/Hello/.resources/definition.yaml`,
+        content: [
+            "$kind: folder",
+            "name: Hello",
+            "order: 1000",
+            ""
+        ].join("\n")
+    });
+    const requests = [
+        {
+            file: "List (anonymous).request.yaml",
+            yaml: [
+                "$kind: http-request",
+                "name: List (anonymous)",
+                "method: GET",
+                'url: "{{baseUrl}}/hello"',
+                "auth:",
+                "  type: noauth",
+                "order: 1000",
+                ""
+            ].join("\n")
+        },
+        {
+            file: "Get by id.request.yaml",
+            yaml: [
+                "$kind: http-request",
+                "name: Get by id",
+                "method: GET",
+                'url: "{{baseUrl}}/hello/:id"',
+                "order: 2000",
+                ""
+            ].join("\n")
+        },
+        {
+            file: "Create.request.yaml",
+            yaml: [
+                "$kind: http-request",
+                "name: Create",
+                "method: POST",
+                'url: "{{baseUrl}}/hello"',
+                "headers:",
+                "  Content-Type: application/json",
+                "body:",
+                "  type: json",
+                "  content: |-",
+                "    {",
+                '      "message": "hello"',
+                "    }",
+                "order: 3000",
+                ""
+            ].join("\n")
+        },
+        {
+            file: "Update.request.yaml",
+            yaml: [
+                "$kind: http-request",
+                "name: Update",
+                "method: PUT",
+                'url: "{{baseUrl}}/hello/:id"',
+                "headers:",
+                "  Content-Type: application/json",
+                "body:",
+                "  type: json",
+                "  content: |-",
+                "    {",
+                '      "message": "updated"',
+                "    }",
+                "order: 4000",
+                ""
+            ].join("\n")
+        },
+        {
+            file: "Delete.request.yaml",
+            yaml: [
+                "$kind: http-request",
+                "name: Delete",
+                "method: DELETE",
+                'url: "{{baseUrl}}/hello/:id"',
+                "order: 5000",
+                ""
+            ].join("\n")
+        }
+    ];
+    for (const r of requests){
+        files.push({
+            filePath: `${collectionDir}/Hello/${r.file}`,
+            content: r.yaml
+        });
+    }
+    return files;
 }
 async function scaffold(workspace, options) {
-    if (options.postmanProvider === "none") return;
+    if (options.postmanProvider === "none" || options.postmanProvider == null) return;
     const authConfigModel = workspace.getModel(WELL_KNOWN_FILES.AUTH_CONFIG);
     const authCfg = authConfigModel?.config;
     let spaClientId;
-    if (options.postmanProvider === "api" && options.apiKey && authCfg?.issuerBaseUrl) {
+    if (authCfg?.issuerBaseUrl) {
         try {
-            const app = auth0Cli.createSpaApp(`${workspace.name} Postman`, "https://oauth.pstmn.io/v1/callback");
+            const app = auth0Cli.ensureSpaApp(`${workspace.name} Postman`, [
+                ...POSTMAN_CALLBACKS
+            ]);
             spaClientId = app.client_id;
-            console.log("  ✓ Auth0 SPA app created for Postman PKCE");
-        } catch  {
-            console.error("  ✗ Failed to create Auth0 SPA app — continuing without it.");
+            console.log(app.reused ? `  ✓ Reusing Auth0 SPA app for Postman PKCE (${spaClientId})` : `  ✓ Auth0 SPA app created for Postman PKCE (${spaClientId})`);
+            try {
+                auth0Cli.enableConnectionForClient(auth0Cli.DB_CONNECTION_NAME, spaClientId);
+                console.log(`  ✓ Enabled ${auth0Cli.DB_CONNECTION_NAME} on Postman SPA`);
+            } catch (err) {
+                console.error(`  ✗ Failed to enable DB connection on SPA: ${err instanceof Error ? err.message : err}`);
+            }
+        } catch (err) {
+            console.error(`  ✗ Failed to ensure Auth0 SPA app — set auth0ClientId in the environment: ${err instanceof Error ? err.message : err}`);
         }
     }
     const auth0Env = authCfg?.issuerBaseUrl ? {
@@ -178,21 +447,30 @@ async function scaffold(workspace, options) {
         auth0ClientId: spaClientId
     } : undefined;
     const projectName = workspace.name;
-    const collection = buildCollection(projectName, auth0Env);
-    const envYaml = buildEnvironmentYaml(`${projectName} — Local`, auth0Env);
+    const envName = `${projectName} Local`;
+    const localFiles = buildLocalViewFiles(projectName, auth0Env);
+    const envYaml = buildEnvironmentYaml(envName, auth0Env);
     workspace.addFile({
         files: ()=>[
                 {
-                    filePath: `postman/environments/${projectName} \u2014 Local.environment.yaml`,
-                    content: envYaml
+                    filePath: ".postman/resources.yaml",
+                    content: [
+                        "# Open this project root in Postman (Files → Open folder), not the postman/ subfolder.",
+                        "# Postman fills workspace.id when you connect Local View.",
+                        "#",
+                        "# All resources under postman/ are registered automatically.",
+                        ""
+                    ].join("\n")
                 },
                 {
-                    filePath: `postman/collections/${projectName}.postman_collection.json`,
-                    content: `${JSON.stringify(collection, null, 2)}\n`
-                }
+                    filePath: `postman/environments/${projectName}-Local.environment.yaml`,
+                    content: envYaml
+                },
+                ...localFiles
             ]
     });
     if (options.postmanProvider === "api" && options.apiKey) {
+        const collection = buildCollectionJson(projectName, auth0Env);
         const headers = {
             "X-Api-Key": options.apiKey,
             "Content-Type": "application/json"
@@ -209,7 +487,7 @@ async function scaffold(workspace, options) {
         } else {
             console.error("  ✗ Failed to upload Postman collection");
         }
-        const envVars = [
+        const envValues = [
             {
                 key: "baseUrl",
                 value: "http://localhost:3000",
@@ -238,8 +516,8 @@ async function scaffold(workspace, options) {
             headers,
             body: JSON.stringify({
                 environment: {
-                    name: `${projectName} — Local`,
-                    values: envVars
+                    name: envName,
+                    values: envValues
                 }
             })
         });
@@ -254,5 +532,6 @@ export const PostmanFeature = {
     getOptions,
     scaffold
 };
+export { POSTMAN_CALLBACKS, POSTMAN_SCOPES };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/features/postman.feature.ts"],"sourcesContent":["import { pick } from \"../../domain/prompt.js\";\nimport { WELL_KNOWN_FILES } from \"../../models/const.js\";\nimport type { WorkspaceScaffold } from \"../../models/project.model.js\";\nimport type { Feature } from \"../../services/scaffold.service.js\";\nimport type { AuthConfigModel } from \"../models/auth-config.model.js\";\nimport * as auth0Cli from \"./auth0-cli.js\";\n\nexport type PostmanOptions = {\n\tpostmanProvider?: \"api\" | \"local\" | \"none\";\n\tapiKey?: string;\n\tworkspaceId?: string;\n};\n\nasync function getOptions(\n\t_workspace: WorkspaceScaffold,\n\tcliOptions: Partial<PostmanOptions>,\n): Promise<Partial<PostmanOptions>> {\n\tif (cliOptions.postmanProvider != null) return {};\n\n\tconst choices = [\n\t\t{ label: \"none\" as const, description: \"skip\" },\n\t\t{ label: \"local\" as const, description: \"write collection + environment files\" },\n\t\t{ label: \"api\" as const, description: \"write files and upload to Postman.com\" },\n\t];\n\tconst selected = await pick(\n\t\t\"\\n  Postman: \",\n\t\tchoices,\n\t\t(c) => `${c.label} — ${c.description}`,\n\t);\n\tconst provider = selected?.label ?? \"none\";\n\n\tif (provider === \"none\") return { postmanProvider: \"none\" };\n\tif (provider === \"local\") return { postmanProvider: \"local\" };\n\n\t// api: collect API key + workspace selection\n\tconst apiKey =\n\t\tprocess.env.POSTMAN_API_KEY ??\n\t\t(await import(\"../../domain/prompt.js\").then((m) =>\n\t\t\tm.ask(\"\\n  Postman API key (app.getpostman.com/settings/me/api-keys): \"),\n\t\t));\n\n\tconst headers = { \"X-Api-Key\": apiKey, \"Content-Type\": \"application/json\" };\n\tconst wsRes = await fetch(\"https://api.getpostman.com/workspaces\", { headers });\n\n\tif (!wsRes.ok) {\n\t\tconsole.error(\"\\n  Postman API key invalid — falling back to local files.\");\n\t\treturn { postmanProvider: \"local\" };\n\t}\n\n\tconst { workspaces } = (await wsRes.json()) as {\n\t\tworkspaces: Array<{ id: string; name: string; type: string }>;\n\t};\n\n\ttype WsChoice = { label: string; id: string | null };\n\tconst wsChoices: WsChoice[] = [\n\t\t{ label: \"<new workspace>\", id: null },\n\t\t...workspaces.map((w) => ({ label: `${w.name} (${w.type})`, id: w.id })),\n\t];\n\n\tconst wsPicked = await pick(\"\\n  Postman workspace: \", wsChoices, (c) => c.label);\n\n\tlet workspaceId: string;\n\tif (!wsPicked || wsPicked.id === null) {\n\t\tconst { ask } = await import(\"../../domain/prompt.js\");\n\t\tconst wsName = await ask(`  Workspace name: `);\n\t\tconst createRes = await fetch(\"https://api.getpostman.com/workspaces\", {\n\t\t\tmethod: \"POST\",\n\t\t\theaders,\n\t\t\tbody: JSON.stringify({ workspace: { name: wsName, type: \"personal\" } }),\n\t\t});\n\t\tconst { workspace: ws } = (await createRes.json()) as { workspace: { id: string } };\n\t\tworkspaceId = ws.id;\n\t\tconsole.log(`  ✓ Workspace created: ${wsName}`);\n\t} else {\n\t\tworkspaceId = wsPicked.id;\n\t}\n\n\treturn { postmanProvider: \"api\", apiKey, workspaceId };\n}\n\ntype Auth0Env = {\n\tauth0Domain?: string;\n\tauth0Audience?: string;\n\tauth0ClientId?: string;\n};\n\nfunction buildCollection(projectName: string, auth?: Auth0Env): unknown {\n\tconst authObj = auth?.auth0Domain\n\t\t? {\n\t\t\t\ttype: \"oauth2\",\n\t\t\t\toauth2: [\n\t\t\t\t\t{ key: \"grant_type\", value: \"authorization_code_with_pkce\", type: \"string\" },\n\t\t\t\t\t{\n\t\t\t\t\t\tkey: \"authUrl\",\n\t\t\t\t\t\tvalue: \"https://{{auth0Domain}}/authorize?audience={{auth0Audience}}\",\n\t\t\t\t\t\ttype: \"string\",\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tkey: \"accessTokenUrl\",\n\t\t\t\t\t\tvalue: \"https://{{auth0Domain}}/oauth/token\",\n\t\t\t\t\t\ttype: \"string\",\n\t\t\t\t\t},\n\t\t\t\t\t{ key: \"clientId\", value: \"{{auth0ClientId}}\", type: \"string\" },\n\t\t\t\t\t{ key: \"scope\", value: \"openid profile email\", type: \"string\" },\n\t\t\t\t\t{ key: \"addTokenTo\", value: \"header\", type: \"string\" },\n\t\t\t\t\t{ key: \"challengeAlgorithm\", value: \"S256\", type: \"string\" },\n\t\t\t\t],\n\t\t\t}\n\t\t: undefined;\n\n\treturn {\n\t\tinfo: {\n\t\t\tname: `${projectName} WebAPI`,\n\t\t\tschema: \"https://schema.getpostman.com/json/collection/v2.1.0/collection.json\",\n\t\t},\n\t\t...(authObj ? { auth: authObj } : {}),\n\t\titem: [\n\t\t\t{\n\t\t\t\tname: \"Hello\",\n\t\t\t\trequest: {\n\t\t\t\t\tmethod: \"GET\",\n\t\t\t\t\turl: { raw: \"{{baseUrl}}/hello\", host: [\"{{baseUrl}}\"], path: [\"hello\"] },\n\t\t\t\t},\n\t\t\t},\n\t\t],\n\t};\n}\n\nfunction buildEnvironmentYaml(name: string, auth?: Auth0Env): string {\n\tconst auth0Section = auth?.auth0Domain\n\t\t? [\n\t\t\t\t\"  - key: auth0Domain\",\n\t\t\t\t`    value: ${auth.auth0Domain}`,\n\t\t\t\t\"  - key: auth0Audience\",\n\t\t\t\t`    value: '${auth.auth0Audience ?? \"\"}'`,\n\t\t\t\t\"  - key: auth0ClientId\",\n\t\t\t\t`    value: '${auth.auth0ClientId ?? \"\"}'`,\n\t\t\t\t\"    description: Client ID of the Auth0 SPA application used by Postman for PKCE authentication\",\n\t\t\t].join(\"\\n\") + \"\\n\"\n\t\t: \"\";\n\n\treturn `name: ${name}\\nvalues:\\n  - key: baseUrl\\n    value: 'http://localhost:3000'\\n${auth0Section}`;\n}\n\nasync function scaffold(workspace: WorkspaceScaffold, options: PostmanOptions): Promise<void> {\n\tif (options.postmanProvider === \"none\") return;\n\n\tconst authConfigModel = workspace.getModel<AuthConfigModel>(WELL_KNOWN_FILES.AUTH_CONFIG);\n\tconst authCfg = authConfigModel?.config;\n\n\tlet spaClientId: string | undefined;\n\n\tif (options.postmanProvider === \"api\" && options.apiKey && authCfg?.issuerBaseUrl) {\n\t\ttry {\n\t\t\tconst app = auth0Cli.createSpaApp(\n\t\t\t\t`${workspace.name} Postman`,\n\t\t\t\t\"https://oauth.pstmn.io/v1/callback\",\n\t\t\t);\n\t\t\tspaClientId = app.client_id;\n\t\t\tconsole.log(\"  ✓ Auth0 SPA app created for Postman PKCE\");\n\t\t} catch {\n\t\t\tconsole.error(\"  ✗ Failed to create Auth0 SPA app — continuing without it.\");\n\t\t}\n\t}\n\n\tconst auth0Env: Auth0Env | undefined = authCfg?.issuerBaseUrl\n\t\t? {\n\t\t\t\tauth0Domain: authCfg.issuerBaseUrl.replace(/^https?:\\/\\//, \"\"),\n\t\t\t\tauth0Audience: authCfg.audience,\n\t\t\t\tauth0ClientId: spaClientId,\n\t\t\t}\n\t\t: undefined;\n\n\tconst projectName = workspace.name;\n\tconst collection = buildCollection(projectName, auth0Env);\n\tconst envYaml = buildEnvironmentYaml(`${projectName} — Local`, auth0Env);\n\n\tworkspace.addFile({\n\t\tfiles: () => [\n\t\t\t{\n\t\t\t\tfilePath: `postman/environments/${projectName} \\u2014 Local.environment.yaml`,\n\t\t\t\tcontent: envYaml,\n\t\t\t},\n\t\t\t{\n\t\t\t\tfilePath: `postman/collections/${projectName}.postman_collection.json`,\n\t\t\t\tcontent: `${JSON.stringify(collection, null, 2)}\\n`,\n\t\t\t},\n\t\t],\n\t});\n\n\tif (options.postmanProvider === \"api\" && options.apiKey) {\n\t\tconst headers = { \"X-Api-Key\": options.apiKey, \"Content-Type\": \"application/json\" };\n\n\t\tconst colRes = await fetch(\n\t\t\t`https://api.getpostman.com/collections?workspace=${options.workspaceId}`,\n\t\t\t{\n\t\t\t\tmethod: \"POST\",\n\t\t\t\theaders,\n\t\t\t\tbody: JSON.stringify({ collection }),\n\t\t\t},\n\t\t);\n\t\tif (colRes.ok) {\n\t\t\tconsole.log(\"  ✓ Postman collection uploaded\");\n\t\t} else {\n\t\t\tconsole.error(\"  ✗ Failed to upload Postman collection\");\n\t\t}\n\n\t\tconst envVars = [\n\t\t\t{ key: \"baseUrl\", value: \"http://localhost:3000\", enabled: true },\n\t\t\t...(auth0Env?.auth0Domain\n\t\t\t\t? [\n\t\t\t\t\t\t{ key: \"auth0Domain\", value: auth0Env.auth0Domain, enabled: true },\n\t\t\t\t\t\t{ key: \"auth0Audience\", value: auth0Env.auth0Audience ?? \"\", enabled: true },\n\t\t\t\t\t\t{ key: \"auth0ClientId\", value: auth0Env.auth0ClientId ?? \"\", enabled: true },\n\t\t\t\t\t]\n\t\t\t\t: []),\n\t\t];\n\t\tconst envRes = await fetch(\n\t\t\t`https://api.getpostman.com/environments?workspace=${options.workspaceId}`,\n\t\t\t{\n\t\t\t\tmethod: \"POST\",\n\t\t\t\theaders,\n\t\t\t\tbody: JSON.stringify({\n\t\t\t\t\tenvironment: { name: `${projectName} — Local`, values: envVars },\n\t\t\t\t}),\n\t\t\t},\n\t\t);\n\t\tif (envRes.ok) {\n\t\t\tconsole.log(\"  ✓ Postman environment uploaded\");\n\t\t} else {\n\t\t\tconsole.error(\"  ✗ Failed to upload Postman environment\");\n\t\t}\n\t}\n}\n\nexport const PostmanFeature: Feature<PostmanOptions> = { getOptions, scaffold };\n"],"names":["pick","WELL_KNOWN_FILES","auth0Cli","getOptions","_workspace","cliOptions","postmanProvider","choices","label","description","selected","c","provider","apiKey","process","env","POSTMAN_API_KEY","then","m","ask","headers","wsRes","fetch","ok","console","error","workspaces","json","wsChoices","id","map","w","name","type","wsPicked","workspaceId","wsName","createRes","method","body","JSON","stringify","workspace","ws","log","buildCollection","projectName","auth","authObj","auth0Domain","oauth2","key","value","undefined","info","schema","item","request","url","raw","host","path","buildEnvironmentYaml","auth0Section","auth0Audience","auth0ClientId","join","scaffold","options","authConfigModel","getModel","AUTH_CONFIG","authCfg","config","spaClientId","issuerBaseUrl","app","createSpaApp","client_id","auth0Env","replace","audience","collection","envYaml","addFile","files","filePath","content","colRes","envVars","enabled","envRes","environment","values","PostmanFeature"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/features/postman.feature.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport { pick } from \"../../domain/prompt.js\";\nimport { WELL_KNOWN_FILES } from \"../../models/const.js\";\nimport type { WorkspaceScaffold } from \"../../models/project.model.js\";\nimport type { Feature } from \"../../services/scaffold.service.js\";\nimport type { AuthConfigModel } from \"../models/auth-config.model.js\";\nimport * as auth0Cli from \"./auth0-cli.js\";\n\n/** Postman OAuth callback URLs (popup + \"Authorize using browser\"). */\nconst POSTMAN_CALLBACKS = [\n\t\"https://oauth.pstmn.io/v1/callback\",\n\t\"https://oauth.pstmn.io/v1/browser-callback\",\n] as const;\n\n/** Scopes requested for Auth0 access tokens (OIDC + Hello CASL permissions). */\nconst POSTMAN_SCOPES = [\n\t\"openid\",\n\t\"profile\",\n\t\"email\",\n\t\"read:Hello\",\n\t\"create:Hello\",\n\t\"update:Hello\",\n\t\"delete:Hello\",\n].join(\" \");\n\nexport type PostmanOptions = {\n\tpostmanProvider?: \"api\" | \"local\" | \"none\";\n\tapiKey?: string;\n\tworkspaceId?: string;\n};\n\nasync function getOptions(\n\t_workspace: WorkspaceScaffold,\n\tcliOptions: Partial<PostmanOptions>,\n): Promise<Partial<PostmanOptions>> {\n\tif (cliOptions.postmanProvider != null) return {};\n\n\tconst choices = [\n\t\t{ label: \"none\" as const, description: \"skip\" },\n\t\t{\n\t\t\tlabel: \"local\" as const,\n\t\t\tdescription: \"Local View / Native Git files (no API key)\",\n\t\t},\n\t\t{\n\t\t\tlabel: \"api\" as const,\n\t\t\tdescription: \"also upload to Postman.com (needs API key)\",\n\t\t},\n\t];\n\tconst selected = await pick(\n\t\t\"\\n  Postman: \",\n\t\tchoices,\n\t\t(c) => `${c.label} — ${c.description}`,\n\t);\n\tconst provider = selected?.label ?? \"none\";\n\n\tif (provider === \"none\") return { postmanProvider: \"none\" };\n\tif (provider === \"local\") return { postmanProvider: \"local\" };\n\n\tconst apiKey =\n\t\tprocess.env.POSTMAN_API_KEY ??\n\t\t(await import(\"../../domain/prompt.js\").then((m) =>\n\t\t\tm.ask(\"\\n  Postman API key (app.getpostman.com/settings/me/api-keys): \"),\n\t\t));\n\n\tconst headers = { \"X-Api-Key\": apiKey, \"Content-Type\": \"application/json\" };\n\tconst wsRes = await fetch(\"https://api.getpostman.com/workspaces\", { headers });\n\n\tif (!wsRes.ok) {\n\t\tconsole.error(\"\\n  Postman API key invalid — falling back to local files.\");\n\t\treturn { postmanProvider: \"local\" };\n\t}\n\n\tconst { workspaces } = (await wsRes.json()) as {\n\t\tworkspaces: Array<{ id: string; name: string; type: string }>;\n\t};\n\n\ttype WsChoice = { label: string; id: string | null };\n\tconst wsChoices: WsChoice[] = [\n\t\t{ label: \"<new workspace>\", id: null },\n\t\t...workspaces.map((w) => ({ label: `${w.name} (${w.type})`, id: w.id })),\n\t];\n\n\tconst wsPicked = await pick(\"\\n  Postman workspace: \", wsChoices, (c) => c.label);\n\n\tlet workspaceId: string;\n\tif (!wsPicked || wsPicked.id === null) {\n\t\tconst { ask } = await import(\"../../domain/prompt.js\");\n\t\tconst wsName = await ask(`  Workspace name: `);\n\t\tconst createRes = await fetch(\"https://api.getpostman.com/workspaces\", {\n\t\t\tmethod: \"POST\",\n\t\t\theaders,\n\t\t\tbody: JSON.stringify({ workspace: { name: wsName, type: \"personal\" } }),\n\t\t});\n\t\tconst { workspace: ws } = (await createRes.json()) as { workspace: { id: string } };\n\t\tworkspaceId = ws.id;\n\t\tconsole.log(`  ✓ Workspace created: ${wsName}`);\n\t} else {\n\t\tworkspaceId = wsPicked.id;\n\t}\n\n\treturn { postmanProvider: \"api\", apiKey, workspaceId };\n}\n\ntype Auth0Env = {\n\tauth0Domain?: string;\n\tauth0Audience?: string;\n\tauth0ClientId?: string;\n};\n\n/** v2.1 JSON — used for Postman.com API upload only. */\nfunction buildCollectionJson(projectName: string, auth?: Auth0Env): unknown {\n\tconst authObj = auth?.auth0Domain\n\t\t? {\n\t\t\t\ttype: \"oauth2\",\n\t\t\t\toauth2: [\n\t\t\t\t\t{ key: \"grant_type\", value: \"authorization_code_with_pkce\", type: \"string\" },\n\t\t\t\t\t{\n\t\t\t\t\t\tkey: \"authUrl\",\n\t\t\t\t\t\tvalue: \"https://{{auth0Domain}}/authorize?audience={{auth0Audience}}\",\n\t\t\t\t\t\ttype: \"string\",\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tkey: \"accessTokenUrl\",\n\t\t\t\t\t\tvalue: \"https://{{auth0Domain}}/oauth/token\",\n\t\t\t\t\t\ttype: \"string\",\n\t\t\t\t\t},\n\t\t\t\t\t{ key: \"clientId\", value: \"{{auth0ClientId}}\", type: \"string\" },\n\t\t\t\t\t{ key: \"scope\", value: POSTMAN_SCOPES, type: \"string\" },\n\t\t\t\t\t{ key: \"redirect_uri\", value: POSTMAN_CALLBACKS[0], type: \"string\" },\n\t\t\t\t\t{ key: \"useBrowser\", value: \"true\", type: \"boolean\" },\n\t\t\t\t\t{ key: \"addTokenTo\", value: \"header\", type: \"string\" },\n\t\t\t\t\t{ key: \"challengeAlgorithm\", value: \"S256\", type: \"string\" },\n\t\t\t\t\t{ key: \"client_authentication\", value: \"body\", type: \"string\" },\n\t\t\t\t\t{ key: \"clientSecret\", value: \"\", type: \"string\" },\n\t\t\t\t\t{ key: \"tokenName\", value: `${projectName} Access Token`, type: \"string\" },\n\t\t\t\t],\n\t\t\t}\n\t\t: undefined;\n\n\tconst helloUrl = (path: string, raw: string) => ({\n\t\traw: `{{baseUrl}}${raw}`,\n\t\thost: [\"{{baseUrl}}\"],\n\t\tpath: path.split(\"/\").filter(Boolean),\n\t});\n\n\treturn {\n\t\tinfo: {\n\t\t\t_postman_id: randomUUID(),\n\t\t\tname: `${projectName} WebAPI`,\n\t\t\tschema: \"https://schema.getpostman.com/json/collection/v2.1.0/collection.json\",\n\t\t\tdescription:\n\t\t\t\t\"Open the project root in Postman Local View (not the postman/ folder). \" +\n\t\t\t\t\"Select the Local environment, then Authorization → Get New Access Token (PKCE).\",\n\t\t},\n\t\t...(authObj ? { auth: authObj } : {}),\n\t\titem: [\n\t\t\t{\n\t\t\t\tname: \"Hello\",\n\t\t\t\titem: [\n\t\t\t\t\t{\n\t\t\t\t\t\tname: \"List (anonymous)\",\n\t\t\t\t\t\trequest: {\n\t\t\t\t\t\t\tauth: { type: \"noauth\" },\n\t\t\t\t\t\t\tmethod: \"GET\",\n\t\t\t\t\t\t\turl: helloUrl(\"hello\", \"/hello\"),\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tname: \"Get by id\",\n\t\t\t\t\t\trequest: {\n\t\t\t\t\t\t\tmethod: \"GET\",\n\t\t\t\t\t\t\turl: helloUrl(\"hello/:id\", \"/hello/:id\"),\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tname: \"Create\",\n\t\t\t\t\t\trequest: {\n\t\t\t\t\t\t\tmethod: \"POST\",\n\t\t\t\t\t\t\theader: [{ key: \"Content-Type\", value: \"application/json\" }],\n\t\t\t\t\t\t\tbody: {\n\t\t\t\t\t\t\t\tmode: \"raw\",\n\t\t\t\t\t\t\t\traw: '{\\n  \"message\": \"hello\"\\n}\\n',\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\turl: helloUrl(\"hello\", \"/hello\"),\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tname: \"Update\",\n\t\t\t\t\t\trequest: {\n\t\t\t\t\t\t\tmethod: \"PUT\",\n\t\t\t\t\t\t\theader: [{ key: \"Content-Type\", value: \"application/json\" }],\n\t\t\t\t\t\t\tbody: {\n\t\t\t\t\t\t\t\tmode: \"raw\",\n\t\t\t\t\t\t\t\traw: '{\\n  \"message\": \"updated\"\\n}\\n',\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\turl: helloUrl(\"hello/:id\", \"/hello/:id\"),\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tname: \"Delete\",\n\t\t\t\t\t\trequest: {\n\t\t\t\t\t\t\tmethod: \"DELETE\",\n\t\t\t\t\t\t\turl: helloUrl(\"hello/:id\", \"/hello/:id\"),\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t},\n\t\t],\n\t};\n}\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). */\nfunction buildEnvironmentYaml(name: string, auth?: Auth0Env): 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: POSTMAN_CALLBACKS[0] },\n\t\t\t{ key: \"scope\", value: POSTMAN_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/** Local View / Native Git collection (v3 multi-file YAML). */\nfunction buildLocalViewFiles(\n\tprojectName: string,\n\tauth?: Auth0Env,\n): Array<{ filePath: string; content: string }> {\n\tconst collectionDir = `postman/collections/${projectName} WebAPI`;\n\tconst files: Array<{ filePath: string; content: string }> = [];\n\n\t// Postman Local View stores OAuth under auth[].credentials (not the v2.1 oauth2 array).\n\t// Use concrete https URLs — empty Auth URL yields \"Invalid protocol for auth URL\".\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(POSTMAN_SCOPES)}`,\n\t\t\t\t`      redirect_uri: ${POSTMAN_CALLBACKS[0]}`,\n\t\t\t\t\"      useBrowser: true\",\n\t\t\t\t\"      challengeAlgorithm: S256\",\n\t\t\t\t// SPA public client: Auth0 token endpoint rejects Basic auth (feacft Unauthorized).\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\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\tfiles.push({\n\t\tfilePath: `${collectionDir}/Hello/.resources/definition.yaml`,\n\t\tcontent: [\"$kind: folder\", \"name: Hello\", \"order: 1000\", \"\"].join(\"\\n\"),\n\t});\n\n\tconst requests: Array<{\n\t\tfile: string;\n\t\tyaml: string;\n\t}> = [\n\t\t{\n\t\t\tfile: \"List (anonymous).request.yaml\",\n\t\t\tyaml: [\n\t\t\t\t\"$kind: http-request\",\n\t\t\t\t\"name: List (anonymous)\",\n\t\t\t\t\"method: GET\",\n\t\t\t\t'url: \"{{baseUrl}}/hello\"',\n\t\t\t\t\"auth:\",\n\t\t\t\t\"  type: noauth\",\n\t\t\t\t\"order: 1000\",\n\t\t\t\t\"\",\n\t\t\t].join(\"\\n\"),\n\t\t},\n\t\t{\n\t\t\tfile: \"Get by id.request.yaml\",\n\t\t\tyaml: [\n\t\t\t\t\"$kind: http-request\",\n\t\t\t\t\"name: Get by id\",\n\t\t\t\t\"method: GET\",\n\t\t\t\t'url: \"{{baseUrl}}/hello/:id\"',\n\t\t\t\t\"order: 2000\",\n\t\t\t\t\"\",\n\t\t\t].join(\"\\n\"),\n\t\t},\n\t\t{\n\t\t\tfile: \"Create.request.yaml\",\n\t\t\tyaml: [\n\t\t\t\t\"$kind: http-request\",\n\t\t\t\t\"name: Create\",\n\t\t\t\t\"method: POST\",\n\t\t\t\t'url: \"{{baseUrl}}/hello\"',\n\t\t\t\t\"headers:\",\n\t\t\t\t\"  Content-Type: application/json\",\n\t\t\t\t\"body:\",\n\t\t\t\t\"  type: json\",\n\t\t\t\t\"  content: |-\",\n\t\t\t\t\"    {\",\n\t\t\t\t'      \"message\": \"hello\"',\n\t\t\t\t\"    }\",\n\t\t\t\t\"order: 3000\",\n\t\t\t\t\"\",\n\t\t\t].join(\"\\n\"),\n\t\t},\n\t\t{\n\t\t\tfile: \"Update.request.yaml\",\n\t\t\tyaml: [\n\t\t\t\t\"$kind: http-request\",\n\t\t\t\t\"name: Update\",\n\t\t\t\t\"method: PUT\",\n\t\t\t\t'url: \"{{baseUrl}}/hello/:id\"',\n\t\t\t\t\"headers:\",\n\t\t\t\t\"  Content-Type: application/json\",\n\t\t\t\t\"body:\",\n\t\t\t\t\"  type: json\",\n\t\t\t\t\"  content: |-\",\n\t\t\t\t\"    {\",\n\t\t\t\t'      \"message\": \"updated\"',\n\t\t\t\t\"    }\",\n\t\t\t\t\"order: 4000\",\n\t\t\t\t\"\",\n\t\t\t].join(\"\\n\"),\n\t\t},\n\t\t{\n\t\t\tfile: \"Delete.request.yaml\",\n\t\t\tyaml: [\n\t\t\t\t\"$kind: http-request\",\n\t\t\t\t\"name: Delete\",\n\t\t\t\t\"method: DELETE\",\n\t\t\t\t'url: \"{{baseUrl}}/hello/:id\"',\n\t\t\t\t\"order: 5000\",\n\t\t\t\t\"\",\n\t\t\t].join(\"\\n\"),\n\t\t},\n\t];\n\n\tfor (const r of requests) {\n\t\tfiles.push({\n\t\t\tfilePath: `${collectionDir}/Hello/${r.file}`,\n\t\t\tcontent: r.yaml,\n\t\t});\n\t}\n\n\treturn files;\n}\n\nasync function scaffold(workspace: WorkspaceScaffold, options: PostmanOptions): Promise<void> {\n\tif (options.postmanProvider === \"none\" || options.postmanProvider == null) return;\n\n\tconst authConfigModel = workspace.getModel<AuthConfigModel>(WELL_KNOWN_FILES.AUTH_CONFIG);\n\tconst authCfg = authConfigModel?.config;\n\n\tlet spaClientId: string | undefined;\n\n\tif (authCfg?.issuerBaseUrl) {\n\t\ttry {\n\t\t\tconst app = auth0Cli.ensureSpaApp(`${workspace.name} Postman`, [...POSTMAN_CALLBACKS]);\n\t\t\tspaClientId = app.client_id;\n\t\t\tconsole.log(\n\t\t\t\tapp.reused\n\t\t\t\t\t? `  ✓ Reusing Auth0 SPA app for Postman PKCE (${spaClientId})`\n\t\t\t\t\t: `  ✓ Auth0 SPA app created for Postman PKCE (${spaClientId})`,\n\t\t\t);\n\t\t\ttry {\n\t\t\t\tauth0Cli.enableConnectionForClient(auth0Cli.DB_CONNECTION_NAME, spaClientId);\n\t\t\t\tconsole.log(`  ✓ Enabled ${auth0Cli.DB_CONNECTION_NAME} on Postman SPA`);\n\t\t\t} catch (err) {\n\t\t\t\tconsole.error(\n\t\t\t\t\t`  ✗ Failed to enable DB connection on SPA: ${err instanceof Error ? err.message : err}`,\n\t\t\t\t);\n\t\t\t}\n\t\t} catch (err) {\n\t\t\tconsole.error(\n\t\t\t\t`  ✗ Failed to ensure Auth0 SPA app — set auth0ClientId in the environment: ${err instanceof Error ? err.message : err}`,\n\t\t\t);\n\t\t}\n\t}\n\n\tconst auth0Env: Auth0Env | undefined = authCfg?.issuerBaseUrl\n\t\t? {\n\t\t\t\tauth0Domain: authCfg.issuerBaseUrl.replace(/^https?:\\/\\//, \"\"),\n\t\t\t\tauth0Audience: authCfg.audience,\n\t\t\t\tauth0ClientId: spaClientId,\n\t\t\t}\n\t\t: undefined;\n\n\tconst projectName = workspace.name;\n\tconst envName = `${projectName} Local`;\n\tconst localFiles = buildLocalViewFiles(projectName, auth0Env);\n\tconst envYaml = buildEnvironmentYaml(envName, auth0Env);\n\n\tworkspace.addFile({\n\t\tfiles: () => [\n\t\t\t{\n\t\t\t\tfilePath: \".postman/resources.yaml\",\n\t\t\t\tcontent: [\n\t\t\t\t\t\"# Open this project root in Postman (Files → Open folder), not the postman/ subfolder.\",\n\t\t\t\t\t\"# Postman fills workspace.id when you connect Local View.\",\n\t\t\t\t\t\"#\",\n\t\t\t\t\t\"# All resources under postman/ are registered automatically.\",\n\t\t\t\t\t\"\",\n\t\t\t\t].join(\"\\n\"),\n\t\t\t},\n\t\t\t{\n\t\t\t\tfilePath: `postman/environments/${projectName}-Local.environment.yaml`,\n\t\t\t\tcontent: envYaml,\n\t\t\t},\n\t\t\t...localFiles,\n\t\t],\n\t});\n\n\tif (options.postmanProvider === \"api\" && options.apiKey) {\n\t\tconst collection = buildCollectionJson(projectName, auth0Env);\n\t\tconst headers = { \"X-Api-Key\": options.apiKey, \"Content-Type\": \"application/json\" };\n\n\t\tconst colRes = await fetch(\n\t\t\t`https://api.getpostman.com/collections?workspace=${options.workspaceId}`,\n\t\t\t{\n\t\t\t\tmethod: \"POST\",\n\t\t\t\theaders,\n\t\t\t\tbody: JSON.stringify({ collection }),\n\t\t\t},\n\t\t);\n\t\tif (colRes.ok) {\n\t\t\tconsole.log(\"  ✓ Postman collection uploaded\");\n\t\t} else {\n\t\t\tconsole.error(\"  ✗ Failed to upload Postman collection\");\n\t\t}\n\n\t\tconst envValues = [\n\t\t\t{ key: \"baseUrl\", value: \"http://localhost:3000\", enabled: true },\n\t\t\t...(auth0Env?.auth0Domain\n\t\t\t\t? [\n\t\t\t\t\t\t{ key: \"auth0Domain\", value: auth0Env.auth0Domain, enabled: true },\n\t\t\t\t\t\t{ key: \"auth0Audience\", value: auth0Env.auth0Audience ?? \"\", enabled: true },\n\t\t\t\t\t\t{ key: \"auth0ClientId\", value: auth0Env.auth0ClientId ?? \"\", enabled: true },\n\t\t\t\t\t]\n\t\t\t\t: []),\n\t\t];\n\t\tconst envRes = await fetch(\n\t\t\t`https://api.getpostman.com/environments?workspace=${options.workspaceId}`,\n\t\t\t{\n\t\t\t\tmethod: \"POST\",\n\t\t\t\theaders,\n\t\t\t\tbody: JSON.stringify({\n\t\t\t\t\tenvironment: { name: envName, values: envValues },\n\t\t\t\t}),\n\t\t\t},\n\t\t);\n\t\tif (envRes.ok) {\n\t\t\tconsole.log(\"  ✓ Postman environment uploaded\");\n\t\t} else {\n\t\t\tconsole.error(\"  ✗ Failed to upload Postman environment\");\n\t\t}\n\t}\n}\n\nexport const PostmanFeature: Feature<PostmanOptions> = { getOptions, scaffold };\nexport { POSTMAN_CALLBACKS, POSTMAN_SCOPES };\n"],"names":["randomUUID","pick","WELL_KNOWN_FILES","auth0Cli","POSTMAN_CALLBACKS","POSTMAN_SCOPES","join","getOptions","_workspace","cliOptions","postmanProvider","choices","label","description","selected","c","provider","apiKey","process","env","POSTMAN_API_KEY","then","m","ask","headers","wsRes","fetch","ok","console","error","workspaces","json","wsChoices","id","map","w","name","type","wsPicked","workspaceId","wsName","createRes","method","body","JSON","stringify","workspace","ws","log","buildCollectionJson","projectName","auth","authObj","auth0Domain","oauth2","key","value","undefined","helloUrl","path","raw","host","split","filter","Boolean","info","_postman_id","schema","item","request","url","header","mode","yamlQuote","test","includes","buildEnvironmentYaml","values","push","auth0Audience","auth0ClientId","lines","v","buildLocalViewFiles","collectionDir","files","authBlock","filePath","content","l","replace","requests","file","yaml","r","scaffold","options","authConfigModel","getModel","AUTH_CONFIG","authCfg","config","spaClientId","issuerBaseUrl","app","ensureSpaApp","client_id","reused","enableConnectionForClient","DB_CONNECTION_NAME","err","Error","message","auth0Env","audience","envName","localFiles","envYaml","addFile","collection","colRes","envValues","enabled","envRes","environment","PostmanFeature"],"mappings":"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"}

package/es6/src/webapi/models/api-package-json.model.js

@@ -31,6 +31,9 @@ import { CREATE_VERSION } from "../../version.js";
             version: "0.0.1",
             type: "module",
             main: "src/main.ts",
+            scripts: {
+                lint: "biome check --write ."
+            },
             dependencies: {
                 ...this._dependencies
             }
@@ -49,4 +52,4 @@ import { CREATE_VERSION } from "../../version.js";
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/webapi/models/auth-config.model.js

@@ -11,9 +11,12 @@ import { WELL_KNOWN_FILES } from "../../models/const.js";
     constructor(config){
         this.config = config;
     }
+    setAdminUser(adminUser) {
+        this.config.adminUser = adminUser;
+    }
     files() {
         return [];
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvd2ViYXBpL21vZGVscy9hdXRoLWNvbmZpZy5tb2RlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBXRUxMX0tOT1dOX0ZJTEVTIH0gZnJvbSBcIi4uLy4uL21vZGVscy9jb25zdC5qc1wiO1xuaW1wb3J0IHR5cGUgeyBLZXllZE1vZGVsLCBTb3VyY2VGaWxlIH0gZnJvbSBcIi4uLy4uL21vZGVscy9zb3VyY2UtZmlsZS5qc1wiO1xuXG5leHBvcnQgdHlwZSBBdXRoQ29uZmlnID0ge1xuXHRpc3N1ZXJCYXNlVXJsOiBzdHJpbmc7XG5cdGF1ZGllbmNlOiBzdHJpbmc7XG59O1xuXG4vKipcbiAqIERhdGEtY2FycmllciBtb2RlbCBmb3IgYXV0aCBjb25maWd1cmF0aW9uLlxuICpcbiAqIFJlZ2lzdGVyZWQgYnkgQXV0aEZlYXR1cmUgd2hlbiBhdXRoMCBpcyBjb25maWd1cmVkLiBPdGhlciBmZWF0dXJlcyAoZS5nLlxuICogUG9zdG1hbkZlYXR1cmUpIHJldHJpZXZlIGl0IHZpYSB3b3Jrc3BhY2UuZ2V0TW9kZWwoV0VMTF9LTk9XTl9GSUxFUy5BVVRIX0NPTkZJRykuXG4gKiBQcm9kdWNlcyBubyBmaWxlcyDigJQgZXhpc3RzIHNvbGVseSBzbyBmZWF0dXJlcyBjYW4gY29tbXVuaWNhdGUgYXV0aCBkZXRhaWxzLlxuICovXG5leHBvcnQgY2xhc3MgQXV0aENvbmZpZ01vZGVsIGltcGxlbWVudHMgS2V5ZWRNb2RlbCB7XG5cdHB1YmxpYyByZWFkb25seSBrZXkgPSBXRUxMX0tOT1dOX0ZJTEVTLkFVVEhfQ09ORklHO1xuXG5cdHB1YmxpYyBjb25zdHJ1Y3RvcihwdWJsaWMgcmVhZG9ubHkgY29uZmlnOiBBdXRoQ29uZmlnKSB7fVxuXG5cdHB1YmxpYyBmaWxlcygpOiBTb3VyY2VGaWxlW10ge1xuXHRcdHJldHVybiBbXTtcblx0fVxufVxuIl0sIm5hbWVzIjpbIldFTExfS05PV05fRklMRVMiLCJBdXRoQ29uZmlnTW9kZWwiLCJrZXkiLCJBVVRIX0NPTkZJRyIsImNvbmZpZyIsImZpbGVzIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxnQkFBZ0IsUUFBUSx3QkFBd0I7QUFRekQ7Ozs7OztDQU1DLEdBQ0QsT0FBTyxNQUFNQzs7SUFDSUMsTUFBTUYsaUJBQWlCRyxXQUFXLENBQUM7SUFFbkQsWUFBbUIsQUFBZ0JDLE1BQWtCLENBQUU7YUFBcEJBLFNBQUFBO0lBQXFCO0lBRWpEQyxRQUFzQjtRQUM1QixPQUFPLEVBQUU7SUFDVjtBQUNEIn0=
+//# sourceMappingURL=data:application/json;base64,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