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

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

@@ -0,0 +1,324 @@
+"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 POSTMAN_CALLBACKS () {
+        return POSTMAN_CALLBACKS;
+    },
+    get POSTMAN_SCOPES () {
+        return POSTMAN_SCOPES;
+    },
+    get PostmanFeature () {
+        return PostmanFeature;
+    },
+    get buildHelloOpenApiDocument () {
+        return _helloopenapi.buildHelloOpenApiDocument;
+    },
+    get buildHybridPostmanCollection () {
+        return buildHybridPostmanCollection;
+    }
+});
+const _nodecrypto = require("node:crypto");
+const _nodefs = require("node:fs");
+const _nodepath = require("node:path");
+const _prompt = require("../../domain/prompt.js");
+const _const = require("../../models/const.js");
+const _helloopenapi = require("../postman/hello-openapi.js");
+const _localview = require("../postman/local-view.js");
+const _openapitopostman = require("../postman/openapi-to-postman.js");
+const _auth0cli = /*#__PURE__*/ _interop_require_wildcard(require("./auth0-cli.js"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+/** 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(" ");
+const COLLECTION_DESCRIPTION = "Open the project root in Postman Local View (not the postman/ folder). " + "Select the Local environment, then Authorization → Get New Access Token (PKCE). " + "Routes are generated from OpenAPI; Auth0 overlay is hand-authored.";
+async function getOptions(_workspace, cliOptions) {
+    if (cliOptions.postmanProvider != null) return {};
+    const choices = [
+        {
+            label: "none",
+            description: "skip"
+        },
+        {
+            label: "local",
+            description: "Local View / Native Git files (no API key)"
+        },
+        {
+            label: "api",
+            description: "also upload to Postman.com (needs API key)"
+        }
+    ];
+    const selected = await (0, _prompt.pick)("\n  Postman: ", choices, (c)=>`${c.label} — ${c.description}`);
+    const provider = selected?.label ?? "none";
+    if (provider === "none") return {
+        postmanProvider: "none"
+    };
+    if (provider === "local") return {
+        postmanProvider: "local"
+    };
+    const apiKey = process.env.POSTMAN_API_KEY ?? await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../../domain/prompt.js"))).then((m)=>m.ask("\n  Postman API key (app.getpostman.com/settings/me/api-keys): "));
+    const headers = {
+        "X-Api-Key": apiKey,
+        "Content-Type": "application/json"
+    };
+    const wsRes = await fetch("https://api.getpostman.com/workspaces", {
+        headers
+    });
+    if (!wsRes.ok) {
+        console.error("\n  Postman API key invalid — falling back to local files.");
+        return {
+            postmanProvider: "local"
+        };
+    }
+    const { workspaces } = await wsRes.json();
+    const wsChoices = [
+        {
+            label: "<new workspace>",
+            id: null
+        },
+        ...workspaces.map((w)=>({
+                label: `${w.name} (${w.type})`,
+                id: w.id
+            }))
+    ];
+    const wsPicked = await (0, _prompt.pick)("\n  Postman workspace: ", wsChoices, (c)=>c.label);
+    let workspaceId;
+    if (!wsPicked || wsPicked.id === null) {
+        const { ask } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../../domain/prompt.js")));
+        const wsName = await ask(`  Workspace name: `);
+        const createRes = await fetch("https://api.getpostman.com/workspaces", {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                workspace: {
+                    name: wsName,
+                    type: "personal"
+                }
+            })
+        });
+        const { workspace: ws } = await createRes.json();
+        workspaceId = ws.id;
+        console.log(`  ✓ Workspace created: ${wsName}`);
+    } else {
+        workspaceId = wsPicked.id;
+    }
+    return {
+        postmanProvider: "api",
+        apiKey,
+        workspaceId
+    };
+}
+async function buildHybridPostmanCollection(projectName, auth) {
+    const openapi = (0, _helloopenapi.buildHelloOpenApiDocument)(projectName);
+    const base = await (0, _openapitopostman.openApiToPostmanCollection)(openapi);
+    if (base.info._postman_id == null) {
+        base.info._postman_id = (0, _nodecrypto.randomUUID)();
+    }
+    return (0, _openapitopostman.applyPostmanAuthOverlay)(base, projectName, auth, {
+        callbacks: POSTMAN_CALLBACKS,
+        scopes: POSTMAN_SCOPES,
+        description: COLLECTION_DESCRIPTION
+    });
+}
+/** Read a previously scaffolded auth0ClientId so re-scaffold never blanks it. */ function readExistingSpaClientId(targetDir, projectName) {
+    const envPath = (0, _nodepath.join)(targetDir, "postman/environments", `${projectName}-Local.environment.yaml`);
+    if (!(0, _nodefs.existsSync)(envPath)) return undefined;
+    const text = (0, _nodefs.readFileSync)(envPath, "utf8");
+    const match = text.match(/key:\s*auth0ClientId\s*\n\s*value:\s*["']?([^"'\n]+)/);
+    const value = match?.[1]?.trim();
+    return value && value.length > 0 ? value : undefined;
+}
+/**
+ * Resolve the Postman SPA client id. Never returns empty — preserves an existing
+ * env value on Auth0 failure, otherwise throws so we do not write a blank env.
+ */ function resolveSpaClientId(workspace) {
+    const appName = `${workspace.name} Postman`;
+    try {
+        const app = _auth0cli.ensureSpaApp(appName, [
+            ...POSTMAN_CALLBACKS
+        ]);
+        console.log(app.reused ? `  ✓ Reusing Auth0 SPA app for Postman PKCE (${app.client_id})` : `  ✓ Auth0 SPA app created for Postman PKCE (${app.client_id})`);
+        try {
+            _auth0cli.enableConnectionForClient(_auth0cli.DB_CONNECTION_NAME, app.client_id);
+            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}`);
+        }
+        return app.client_id;
+    } catch (err) {
+        const existing = readExistingSpaClientId(workspace.targetDir, workspace.name);
+        if (existing) {
+            console.error(`  ✗ Failed to ensure Auth0 SPA app (${err instanceof Error ? err.message : err})`);
+            console.log(`  ✓ Keeping existing auth0ClientId from Postman environment (${existing})`);
+            return existing;
+        }
+        const detail = err instanceof Error ? err.message : String(err);
+        // Entity-limit messages are already actionable; avoid burying them.
+        if (_auth0cli.isAuth0EntityLimitError(err)) {
+            throw new Error(detail);
+        }
+        throw new Error(`Failed to ensure Auth0 SPA app for Postman — auth0ClientId would be empty: ${detail}`);
+    }
+}
+async function scaffold(workspace, options) {
+    if (options.postmanProvider === "none" || options.postmanProvider == null) return;
+    const authConfigModel = workspace.getModel(_const.WELL_KNOWN_FILES.AUTH_CONFIG);
+    const authCfg = authConfigModel?.config;
+    const spaClientId = authCfg?.issuerBaseUrl ? resolveSpaClientId(workspace) : undefined;
+    const auth0Env = authCfg?.issuerBaseUrl ? {
+        auth0Domain: authCfg.issuerBaseUrl.replace(/^https?:\/\//, ""),
+        auth0Audience: authCfg.audience,
+        auth0ClientId: spaClientId
+    } : undefined;
+    const projectName = workspace.name;
+    const envName = `${projectName} Local`;
+    const collection = await buildHybridPostmanCollection(projectName, auth0Env);
+    const localFiles = (0, _localview.buildLocalViewFilesFromCollection)(collection, projectName, auth0Env, {
+        callbacks: POSTMAN_CALLBACKS,
+        scopes: POSTMAN_SCOPES
+    });
+    const envYaml = (0, _localview.buildEnvironmentYaml)(envName, auth0Env, {
+        callbacks: POSTMAN_CALLBACKS,
+        scopes: POSTMAN_SCOPES
+    });
+    workspace.addFile({
+        files: ()=>[
+                {
+                    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.",
+                        "# Route requests are generated from OpenAPI; Auth0 overlay is hand-authored.",
+                        ""
+                    ].join("\n")
+                },
+                {
+                    filePath: `postman/environments/${projectName}-Local.environment.yaml`,
+                    content: envYaml
+                },
+                ...localFiles
+            ]
+    });
+    if (options.postmanProvider === "api" && options.apiKey) {
+        const headers = {
+            "X-Api-Key": options.apiKey,
+            "Content-Type": "application/json"
+        };
+        const colRes = await fetch(`https://api.getpostman.com/collections?workspace=${options.workspaceId}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                collection
+            })
+        });
+        if (colRes.ok) {
+            console.log("  ✓ Postman collection uploaded");
+        } else {
+            console.error("  ✗ Failed to upload Postman collection");
+        }
+        const envValues = [
+            {
+                key: "baseUrl",
+                value: "http://localhost:3000",
+                enabled: true
+            },
+            ...auth0Env?.auth0Domain ? [
+                {
+                    key: "auth0Domain",
+                    value: auth0Env.auth0Domain,
+                    enabled: true
+                },
+                {
+                    key: "auth0Audience",
+                    value: auth0Env.auth0Audience ?? "",
+                    enabled: true
+                },
+                {
+                    key: "auth0ClientId",
+                    value: auth0Env.auth0ClientId ?? "",
+                    enabled: true
+                }
+            ] : []
+        ];
+        const envRes = await fetch(`https://api.getpostman.com/environments?workspace=${options.workspaceId}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                environment: {
+                    name: envName,
+                    values: envValues
+                }
+            })
+        });
+        if (envRes.ok) {
+            console.log("  ✓ Postman environment uploaded");
+        } else {
+            console.error("  ✗ Failed to upload Postman environment");
+        }
+    }
+}
+const PostmanFeature = {
+    getOptions,
+    scaffold
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/webapi/features/postman.feature.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport { existsSync, readFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\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 { buildHelloOpenApiDocument } from \"../postman/hello-openapi.js\";\nimport {\n\tbuildEnvironmentYaml,\n\tbuildLocalViewFilesFromCollection,\n} from \"../postman/local-view.js\";\nimport {\n\ttype Auth0Env,\n\tapplyPostmanAuthOverlay,\n\topenApiToPostmanCollection,\n} from \"../postman/openapi-to-postman.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\nconst COLLECTION_DESCRIPTION =\n\t\"Open the project root in Postman Local View (not the postman/ folder). \" +\n\t\"Select the Local environment, then Authorization → Get New Access Token (PKCE). \" +\n\t\"Routes are generated from OpenAPI; Auth0 overlay is hand-authored.\";\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\n/** Build Postman collection: OpenAPI routes + Auth0 auth overlay. */\nexport async function buildHybridPostmanCollection(projectName: string, auth?: Auth0Env) {\n\tconst openapi = buildHelloOpenApiDocument(projectName);\n\tconst base = await openApiToPostmanCollection(openapi);\n\tif (base.info._postman_id == null) {\n\t\tbase.info._postman_id = randomUUID();\n\t}\n\treturn applyPostmanAuthOverlay(base, projectName, auth, {\n\t\tcallbacks: POSTMAN_CALLBACKS,\n\t\tscopes: POSTMAN_SCOPES,\n\t\tdescription: COLLECTION_DESCRIPTION,\n\t});\n}\n\n/** Read a previously scaffolded auth0ClientId so re-scaffold never blanks it. */\nfunction readExistingSpaClientId(targetDir: string, projectName: string): string | undefined {\n\tconst envPath = join(\n\t\ttargetDir,\n\t\t\"postman/environments\",\n\t\t`${projectName}-Local.environment.yaml`,\n\t);\n\tif (!existsSync(envPath)) return undefined;\n\tconst text = readFileSync(envPath, \"utf8\");\n\tconst match = text.match(/key:\\s*auth0ClientId\\s*\\n\\s*value:\\s*[\"']?([^\"'\\n]+)/);\n\tconst value = match?.[1]?.trim();\n\treturn value && value.length > 0 ? value : undefined;\n}\n\n/**\n * Resolve the Postman SPA client id. Never returns empty — preserves an existing\n * env value on Auth0 failure, otherwise throws so we do not write a blank env.\n */\nfunction resolveSpaClientId(workspace: WorkspaceScaffold): string {\n\tconst appName = `${workspace.name} Postman`;\n\ttry {\n\t\tconst app = auth0Cli.ensureSpaApp(appName, [...POSTMAN_CALLBACKS]);\n\t\tconsole.log(\n\t\t\tapp.reused\n\t\t\t\t? `  ✓ Reusing Auth0 SPA app for Postman PKCE (${app.client_id})`\n\t\t\t\t: `  ✓ Auth0 SPA app created for Postman PKCE (${app.client_id})`,\n\t\t);\n\t\ttry {\n\t\t\tauth0Cli.enableConnectionForClient(auth0Cli.DB_CONNECTION_NAME, app.client_id);\n\t\t\tconsole.log(`  ✓ Enabled ${auth0Cli.DB_CONNECTION_NAME} on Postman SPA`);\n\t\t} catch (err) {\n\t\t\tconsole.error(\n\t\t\t\t`  ✗ Failed to enable DB connection on SPA: ${err instanceof Error ? err.message : err}`,\n\t\t\t);\n\t\t}\n\t\treturn app.client_id;\n\t} catch (err) {\n\t\tconst existing = readExistingSpaClientId(workspace.targetDir, workspace.name);\n\t\tif (existing) {\n\t\t\tconsole.error(\n\t\t\t\t`  ✗ Failed to ensure Auth0 SPA app (${err instanceof Error ? err.message : err})`,\n\t\t\t);\n\t\t\tconsole.log(`  ✓ Keeping existing auth0ClientId from Postman environment (${existing})`);\n\t\t\treturn existing;\n\t\t}\n\t\tconst detail = err instanceof Error ? err.message : String(err);\n\t\t// Entity-limit messages are already actionable; avoid burying them.\n\t\tif (auth0Cli.isAuth0EntityLimitError(err)) {\n\t\t\tthrow new Error(detail);\n\t\t}\n\t\tthrow new Error(\n\t\t\t`Failed to ensure Auth0 SPA app for Postman — auth0ClientId would be empty: ${detail}`,\n\t\t);\n\t}\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\tconst spaClientId = authCfg?.issuerBaseUrl ? resolveSpaClientId(workspace) : undefined;\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 collection = await buildHybridPostmanCollection(projectName, auth0Env);\n\tconst localFiles = buildLocalViewFilesFromCollection(collection, projectName, auth0Env, {\n\t\tcallbacks: POSTMAN_CALLBACKS,\n\t\tscopes: POSTMAN_SCOPES,\n\t});\n\tconst envYaml = buildEnvironmentYaml(envName, auth0Env, {\n\t\tcallbacks: POSTMAN_CALLBACKS,\n\t\tscopes: POSTMAN_SCOPES,\n\t});\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\"# Route requests are generated from OpenAPI; Auth0 overlay is hand-authored.\",\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 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 { buildHelloOpenApiDocument } from \"../postman/hello-openapi.js\";\nexport { POSTMAN_CALLBACKS, POSTMAN_SCOPES };\n"],"names":["POSTMAN_CALLBACKS","POSTMAN_SCOPES","PostmanFeature","buildHelloOpenApiDocument","buildHybridPostmanCollection","join","COLLECTION_DESCRIPTION","getOptions","_workspace","cliOptions","postmanProvider","choices","label","description","selected","pick","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","projectName","auth","openapi","base","openApiToPostmanCollection","info","_postman_id","randomUUID","applyPostmanAuthOverlay","callbacks","scopes","readExistingSpaClientId","targetDir","envPath","existsSync","undefined","text","readFileSync","match","value","trim","length","resolveSpaClientId","appName","app","auth0Cli","ensureSpaApp","reused","client_id","enableConnectionForClient","DB_CONNECTION_NAME","err","Error","message","existing","detail","String","isAuth0EntityLimitError","scaffold","options","authConfigModel","getModel","WELL_KNOWN_FILES","AUTH_CONFIG","authCfg","config","spaClientId","issuerBaseUrl","auth0Env","auth0Domain","replace","auth0Audience","audience","auth0ClientId","envName","collection","localFiles","buildLocalViewFilesFromCollection","envYaml","buildEnvironmentYaml","addFile","files","filePath","content","colRes","envValues","key","enabled","envRes","environment","values"],"mappings":"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"}

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ApiPackageJson", {
+    enumerable: true,
+    get: function() {
+        return ApiPackageJson;
+    }
+});
+const _const = require("../../models/const.js");
+const _packagejsonmodel = require("../../models/package-json.model.js");
+const _version = require("../../version.js");
+class ApiPackageJson {
+    workspaceName;
+    apiName;
+    key = _const.WELL_KNOWN_FILES.API_PACKAGE_JSON;
+    _dependencies;
+    _devDependencies = {};
+    constructor(workspaceName, apiName = "api"){
+        this.workspaceName = workspaceName;
+        this.apiName = apiName;
+        this._dependencies = {
+            "@decohere/cortex": _version.CREATE_VERSION,
+            "@decohere/crucible": _version.CREATE_VERSION
+        };
+    }
+    addDependency(name, version) {
+        this._dependencies[name] = version;
+        return this;
+    }
+    addDevDependency(name, version) {
+        this._devDependencies[name] = version;
+        return this;
+    }
+    files() {
+        const pkg = {
+            name: `@${this.workspaceName}/${this.apiName}`,
+            version: "0.0.1",
+            private: true,
+            type: "module",
+            main: "src/main.ts",
+            scripts: {
+                lint: "biome check --write ."
+            },
+            dependencies: (0, _packagejsonmodel.sortStringMap)(this._dependencies)
+        };
+        if (Object.keys(this._devDependencies).length > 0) {
+            pkg.devDependencies = (0, _packagejsonmodel.sortStringMap)(this._devDependencies);
+        }
+        return [
+            {
+                filePath: "package.json",
+                content: JSON.stringify(pkg, null, 2)
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AuthConfigModel", {
+    enumerable: true,
+    get: function() {
+        return AuthConfigModel;
+    }
+});
+const _const = require("../../models/const.js");
+class AuthConfigModel {
+    config;
+    key = _const.WELL_KNOWN_FILES.AUTH_CONFIG;
+    constructor(config){
+        this.config = config;
+    }
+    setAdminUser(adminUser) {
+        this.config.adminUser = adminUser;
+    }
+    files() {
+        return [];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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