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

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

@@ -0,0 +1,258 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { pick } from "../../domain/prompt.js";
+import { WELL_KNOWN_FILES } from "../../models/const.js";
+import { buildHelloOpenApiDocument } from "../postman/hello-openapi.js";
+import { buildEnvironmentYaml, buildLocalViewFilesFromCollection } from "../postman/local-view.js";
+import { applyPostmanAuthOverlay, openApiToPostmanCollection } from "../postman/openapi-to-postman.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(" ");
+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 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 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,
+        "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 pick("\n  Postman workspace: ", wsChoices, (c)=>c.label);
+    let workspaceId;
+    if (!wsPicked || wsPicked.id === null) {
+        const { ask } = await import("../../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
+    };
+}
+/** Build Postman collection: OpenAPI routes + Auth0 auth overlay. */ export async function buildHybridPostmanCollection(projectName, auth) {
+    const openapi = buildHelloOpenApiDocument(projectName);
+    const base = await openApiToPostmanCollection(openapi);
+    if (base.info._postman_id == null) {
+        base.info._postman_id = randomUUID();
+    }
+    return 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 = join(targetDir, "postman/environments", `${projectName}-Local.environment.yaml`);
+    if (!existsSync(envPath)) return undefined;
+    const text = 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(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 = buildLocalViewFilesFromCollection(collection, projectName, auth0Env, {
+        callbacks: POSTMAN_CALLBACKS,
+        scopes: POSTMAN_SCOPES
+    });
+    const envYaml = 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");
+        }
+    }
+}
+export const PostmanFeature = {
+    getOptions,
+    scaffold
+};
+export { buildHelloOpenApiDocument } from "../postman/hello-openapi.js";
+export { POSTMAN_CALLBACKS, POSTMAN_SCOPES };
+
+//# 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":["randomUUID","existsSync","readFileSync","join","pick","WELL_KNOWN_FILES","buildHelloOpenApiDocument","buildEnvironmentYaml","buildLocalViewFilesFromCollection","applyPostmanAuthOverlay","openApiToPostmanCollection","auth0Cli","POSTMAN_CALLBACKS","POSTMAN_SCOPES","COLLECTION_DESCRIPTION","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","buildHybridPostmanCollection","projectName","auth","openapi","base","info","_postman_id","callbacks","scopes","readExistingSpaClientId","targetDir","envPath","undefined","text","match","value","trim","length","resolveSpaClientId","appName","app","ensureSpaApp","reused","client_id","enableConnectionForClient","DB_CONNECTION_NAME","err","Error","message","existing","detail","String","isAuth0EntityLimitError","scaffold","options","authConfigModel","getModel","AUTH_CONFIG","authCfg","config","spaClientId","issuerBaseUrl","auth0Env","auth0Domain","replace","auth0Audience","audience","auth0ClientId","envName","collection","localFiles","envYaml","addFile","files","filePath","content","colRes","envValues","key","enabled","envRes","environment","values","PostmanFeature"],"mappings":"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"}

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

@@ -0,0 +1,55 @@
+import { WELL_KNOWN_FILES } from "../../models/const.js";
+import { sortStringMap } from "../../models/package-json.model.js";
+import { CREATE_VERSION } from "../../version.js";
+/**
+ * Builder for `projects/<api>/package.json`.
+ *
+ * Starts with the core cortex + crucible deps. Features can call
+ * `addDependency` / `addDevDependency` to extend.
+ */ export class ApiPackageJson {
+    workspaceName;
+    apiName;
+    key = WELL_KNOWN_FILES.API_PACKAGE_JSON;
+    _dependencies;
+    _devDependencies = {};
+    constructor(workspaceName, apiName = "api"){
+        this.workspaceName = workspaceName;
+        this.apiName = apiName;
+        this._dependencies = {
+            "@decohere/cortex": CREATE_VERSION,
+            "@decohere/crucible": 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: sortStringMap(this._dependencies)
+        };
+        if (Object.keys(this._devDependencies).length > 0) {
+            pkg.devDependencies = sortStringMap(this._devDependencies);
+        }
+        return [
+            {
+                filePath: "package.json",
+                content: JSON.stringify(pkg, null, 2)
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,22 @@
+import { WELL_KNOWN_FILES } from "../../models/const.js";
+/**
+ * Data-carrier model for auth configuration.
+ *
+ * Registered by AuthFeature when auth0 is configured. Other features (e.g.
+ * PostmanFeature) retrieve it via workspace.getModel(WELL_KNOWN_FILES.AUTH_CONFIG).
+ * Produces no files — exists solely so features can communicate auth details.
+ */ export class AuthConfigModel {
+    config;
+    key = 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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

package/es6/src/webapi/models/controller-source-file.model.js

@@ -0,0 +1,184 @@
+import { WELL_KNOWN_FILES } from "../../models/const.js";
+/** Tracks named imports from a single module path, split into values and types. */ class ImportGroup {
+    _values = [];
+    _types = [];
+    add(name, typeOnly = false) {
+        if (typeOnly) {
+            // Value import already present — value wins, skip
+            if (!this._values.includes(name) && !this._types.includes(name)) {
+                this._types.push(name);
+            }
+        } else {
+            // Promote: remove from types if it was previously type-only
+            const typeIdx = this._types.indexOf(name);
+            if (typeIdx !== -1) this._types.splice(typeIdx, 1);
+            if (!this._values.includes(name)) this._values.push(name);
+        }
+        return this;
+    }
+    render(from) {
+        const values = [
+            ...this._values
+        ].sort();
+        const types = [
+            ...this._types
+        ].sort().map((n)=>`type ${n}`);
+        return `import { ${[
+            ...values,
+            ...types
+        ].join(", ")} } from "${from}";`;
+    }
+}
+/**
+ * A controller method. Features call `addDecorator()` to prepend decorators
+ * before the HTTP verb decorator (e.g. `@AllowAnonymous` before `@Get()`).
+ */ export class ControllerMethod {
+    name;
+    _httpDecorator;
+    _params;
+    _extraDecorators = [];
+    _body;
+    _isAsync;
+    constructor(name, _httpDecorator, _params, isAsync, body){
+        this.name = name;
+        this._httpDecorator = _httpDecorator;
+        this._params = _params;
+        this._isAsync = isAsync;
+        this._body = body;
+    }
+    addDecorator(decorator) {
+        this._extraDecorators.push(decorator);
+        return this;
+    }
+    /** Replace the method body lines (used by features that extend generated behaviour). */ setBody(body) {
+        this._body = body;
+        return this;
+    }
+    setAsync(isAsync = true) {
+        this._isAsync = isAsync;
+        return this;
+    }
+    render() {
+        const lines = [];
+        for (const d of this._extraDecorators){
+            lines.push(`\t${d}`);
+        }
+        lines.push(`\t${this._httpDecorator}`);
+        const asyncKw = this._isAsync ? "async " : "";
+        lines.push(`\tpublic ${asyncKw}${this.name}(${this._params}) {`);
+        for (const line of this._body){
+            lines.push(`\t\t${line}`);
+        }
+        lines.push("\t}");
+        return lines;
+    }
+}
+/**
+ * Model for `projects/api/src/controllers/hello.controller.ts`.
+ *
+ * Pre-initialised with all routes and their HTTP decorators. Features mutate
+ * the model via `getMethod(name).addDecorator(...)`, `addDecorator(...)` (class
+ * level), `addCortexImport(...)`, `addImport(...)`, and `addConstructorParam(...)`.
+ */ export class ControllerSourceFile {
+    key = WELL_KNOWN_FILES.CONTROLLER_TS;
+    _cortexImports = new ImportGroup().add("Controller").add("Delete").add("Field").add("Get").add("Param").add("Post").add("Put").add("Query");
+    _extraImportGroups = new Map([
+        [
+            "@decohere/crucible/decorators",
+            new ImportGroup().add("inject")
+        ]
+    ]);
+    _classDecorators = [];
+    /** Explicit @inject — design:paramtypes can collapse to Object under SWC when the class is still undefined at decorate time. */ _ctorParams = [
+        '@inject("SampleService") private readonly sample: SampleService'
+    ];
+    _methods = new Map([
+        [
+            "getAll",
+            new ControllerMethod("getAll", "@Get()", '@Query("filter") filter: string', true, [
+                "const greeting = await this.sample.getGreeting();",
+                "return { filter, message: greeting };"
+            ])
+        ],
+        [
+            "getOne",
+            new ControllerMethod("getOne", '@Get("/:id")', '@Param("id") id: string', false, // biome-ignore lint/suspicious/noTemplateCurlyInString: template literal in generated code
+            [
+                "return { id, message: `Hello ${id}!` };"
+            ])
+        ],
+        [
+            "create",
+            new ControllerMethod("create", "@Post()", "body: HelloBody", false, [
+                "return { message: body.message };"
+            ])
+        ],
+        [
+            "update",
+            new ControllerMethod("update", '@Put("/:id")', '@Param("id") id: string, body: HelloBody', false, [
+                "return { id, message: body.message };"
+            ])
+        ],
+        [
+            "remove",
+            new ControllerMethod("remove", '@Delete("/:id")', '@Param("id") id: string', false, [
+                "return { id, deleted: true };"
+            ])
+        ]
+    ]);
+    /** Retrieve a method by name to mutate its decorators. */ getMethod(name) {
+        const m = this._methods.get(name);
+        if (m == null) throw new Error(`No method '${name}' on ControllerSourceFile`);
+        return m;
+    }
+    /** Add a class-level decorator (e.g. `@Authorize`). */ addDecorator(decorator) {
+        this._classDecorators.push(decorator);
+        return this;
+    }
+    /** Add a named import from `@decohere/cortex`. */ addCortexImport(name, typeOnly = false) {
+        this._cortexImports.add(name, typeOnly);
+        return this;
+    }
+    /** Add a named import from any other module. */ addImport(name, from, typeOnly = false) {
+        const group = this._extraImportGroups.get(from) ?? new ImportGroup();
+        group.add(name, typeOnly);
+        this._extraImportGroups.set(from, group);
+        return this;
+    }
+    /** Add a constructor parameter (e.g. an injected dependency). */ addConstructorParam(param) {
+        this._ctorParams.push(param);
+        return this;
+    }
+    files() {
+        const lines = [
+            this._cortexImports.render("@decohere/cortex"),
+            'import { SampleService } from "../services/sample.service.js";'
+        ];
+        for (const [from, group] of this._extraImportGroups){
+            lines.push(group.render(from));
+        }
+        lines.push("", "class HelloBody {", '\t@Field("body", "message")', "\tpublic message!: string;", "}", "");
+        for (const d of this._classDecorators){
+            lines.push(d);
+        }
+        lines.push('@Controller({ prefix: "/hello" })', "export class HelloController {", "");
+        lines.push("\tpublic constructor(");
+        for (const p of this._ctorParams){
+            lines.push(`\t\t${p},`);
+        }
+        lines.push("\t) {}");
+        lines.push("");
+        for (const method of this._methods.values()){
+            lines.push(...method.render(), "");
+        }
+        lines.push("}", "");
+        return [
+            {
+                filePath: "src/controllers/hello.controller.ts",
+                content: lines.join("\n")
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/webapi/models/controller-source-file.model.ts"],"sourcesContent":["import { WELL_KNOWN_FILES } from \"../../models/const.js\";\nimport type { KeyedModel, SourceFile } from \"../../models/source-file.js\";\n\n/** Tracks named imports from a single module path, split into values and types. */\nclass ImportGroup {\n\tprivate readonly _values: string[] = [];\n\tprivate readonly _types: string[] = [];\n\n\tpublic add(name: string, typeOnly = false): this {\n\t\tif (typeOnly) {\n\t\t\t// Value import already present — value wins, skip\n\t\t\tif (!this._values.includes(name) && !this._types.includes(name)) {\n\t\t\t\tthis._types.push(name);\n\t\t\t}\n\t\t} else {\n\t\t\t// Promote: remove from types if it was previously type-only\n\t\t\tconst typeIdx = this._types.indexOf(name);\n\t\t\tif (typeIdx !== -1) this._types.splice(typeIdx, 1);\n\t\t\tif (!this._values.includes(name)) this._values.push(name);\n\t\t}\n\t\treturn this;\n\t}\n\n\tpublic render(from: string): string {\n\t\tconst values = [...this._values].sort();\n\t\tconst types = [...this._types].sort().map((n) => `type ${n}`);\n\t\treturn `import { ${[...values, ...types].join(\", \")} } from \"${from}\";`;\n\t}\n}\n\n/**\n * A controller method. Features call `addDecorator()` to prepend decorators\n * before the HTTP verb decorator (e.g. `@AllowAnonymous` before `@Get()`).\n */\nexport class ControllerMethod {\n\tprivate readonly _extraDecorators: string[] = [];\n\tprivate _body: string[];\n\tprivate _isAsync: boolean;\n\n\tpublic constructor(\n\t\tpublic readonly name: string,\n\t\tprivate readonly _httpDecorator: string,\n\t\tprivate readonly _params: string,\n\t\tisAsync: boolean,\n\t\tbody: string[],\n\t) {\n\t\tthis._isAsync = isAsync;\n\t\tthis._body = body;\n\t}\n\n\tpublic addDecorator(decorator: string): this {\n\t\tthis._extraDecorators.push(decorator);\n\t\treturn this;\n\t}\n\n\t/** Replace the method body lines (used by features that extend generated behaviour). */\n\tpublic setBody(body: string[]): this {\n\t\tthis._body = body;\n\t\treturn this;\n\t}\n\n\tpublic setAsync(isAsync = true): this {\n\t\tthis._isAsync = isAsync;\n\t\treturn this;\n\t}\n\n\tpublic render(): string[] {\n\t\tconst lines: string[] = [];\n\t\tfor (const d of this._extraDecorators) {\n\t\t\tlines.push(`\\t${d}`);\n\t\t}\n\t\tlines.push(`\\t${this._httpDecorator}`);\n\t\tconst asyncKw = this._isAsync ? \"async \" : \"\";\n\t\tlines.push(`\\tpublic ${asyncKw}${this.name}(${this._params}) {`);\n\t\tfor (const line of this._body) {\n\t\t\tlines.push(`\\t\\t${line}`);\n\t\t}\n\t\tlines.push(\"\\t}\");\n\t\treturn lines;\n\t}\n}\n\n/**\n * Model for `projects/api/src/controllers/hello.controller.ts`.\n *\n * Pre-initialised with all routes and their HTTP decorators. Features mutate\n * the model via `getMethod(name).addDecorator(...)`, `addDecorator(...)` (class\n * level), `addCortexImport(...)`, `addImport(...)`, and `addConstructorParam(...)`.\n */\nexport class ControllerSourceFile implements KeyedModel {\n\tpublic readonly key = WELL_KNOWN_FILES.CONTROLLER_TS;\n\n\tprivate readonly _cortexImports = new ImportGroup()\n\t\t.add(\"Controller\")\n\t\t.add(\"Delete\")\n\t\t.add(\"Field\")\n\t\t.add(\"Get\")\n\t\t.add(\"Param\")\n\t\t.add(\"Post\")\n\t\t.add(\"Put\")\n\t\t.add(\"Query\");\n\n\tprivate readonly _extraImportGroups = new Map<string, ImportGroup>([\n\t\t[\"@decohere/crucible/decorators\", new ImportGroup().add(\"inject\")],\n\t]);\n\tprivate readonly _classDecorators: string[] = [];\n\t/** Explicit @inject — design:paramtypes can collapse to Object under SWC when the class is still undefined at decorate time. */\n\tprivate readonly _ctorParams: string[] = [\n\t\t'@inject(\"SampleService\") private readonly sample: SampleService',\n\t];\n\n\tprivate readonly _methods = new Map<string, ControllerMethod>([\n\t\t[\n\t\t\t\"getAll\",\n\t\t\tnew ControllerMethod(\"getAll\", \"@Get()\", '@Query(\"filter\") filter: string', true, [\n\t\t\t\t\"const greeting = await this.sample.getGreeting();\",\n\t\t\t\t\"return { filter, message: greeting };\",\n\t\t\t]),\n\t\t],\n\t\t[\n\t\t\t\"getOne\",\n\t\t\tnew ControllerMethod(\n\t\t\t\t\"getOne\",\n\t\t\t\t'@Get(\"/:id\")',\n\t\t\t\t'@Param(\"id\") id: string',\n\t\t\t\tfalse,\n\t\t\t\t// biome-ignore lint/suspicious/noTemplateCurlyInString: template literal in generated code\n\t\t\t\t[\"return { id, message: `Hello ${id}!` };\"],\n\t\t\t),\n\t\t],\n\t\t[\n\t\t\t\"create\",\n\t\t\tnew ControllerMethod(\"create\", \"@Post()\", \"body: HelloBody\", false, [\n\t\t\t\t\"return { message: body.message };\",\n\t\t\t]),\n\t\t],\n\t\t[\n\t\t\t\"update\",\n\t\t\tnew ControllerMethod(\n\t\t\t\t\"update\",\n\t\t\t\t'@Put(\"/:id\")',\n\t\t\t\t'@Param(\"id\") id: string, body: HelloBody',\n\t\t\t\tfalse,\n\t\t\t\t[\"return { id, message: body.message };\"],\n\t\t\t),\n\t\t],\n\t\t[\n\t\t\t\"remove\",\n\t\t\tnew ControllerMethod(\"remove\", '@Delete(\"/:id\")', '@Param(\"id\") id: string', false, [\n\t\t\t\t\"return { id, deleted: true };\",\n\t\t\t]),\n\t\t],\n\t]);\n\n\t/** Retrieve a method by name to mutate its decorators. */\n\tpublic getMethod(name: string): ControllerMethod {\n\t\tconst m = this._methods.get(name);\n\t\tif (m == null) throw new Error(`No method '${name}' on ControllerSourceFile`);\n\t\treturn m;\n\t}\n\n\t/** Add a class-level decorator (e.g. `@Authorize`). */\n\tpublic addDecorator(decorator: string): this {\n\t\tthis._classDecorators.push(decorator);\n\t\treturn this;\n\t}\n\n\t/** Add a named import from `@decohere/cortex`. */\n\tpublic addCortexImport(name: string, typeOnly = false): this {\n\t\tthis._cortexImports.add(name, typeOnly);\n\t\treturn this;\n\t}\n\n\t/** Add a named import from any other module. */\n\tpublic addImport(name: string, from: string, typeOnly = false): this {\n\t\tconst group = this._extraImportGroups.get(from) ?? new ImportGroup();\n\t\tgroup.add(name, typeOnly);\n\t\tthis._extraImportGroups.set(from, group);\n\t\treturn this;\n\t}\n\n\t/** Add a constructor parameter (e.g. an injected dependency). */\n\tpublic addConstructorParam(param: string): this {\n\t\tthis._ctorParams.push(param);\n\t\treturn this;\n\t}\n\n\tpublic files(): SourceFile[] {\n\t\tconst lines: string[] = [\n\t\t\tthis._cortexImports.render(\"@decohere/cortex\"),\n\t\t\t'import { SampleService } from \"../services/sample.service.js\";',\n\t\t];\n\n\t\tfor (const [from, group] of this._extraImportGroups) {\n\t\t\tlines.push(group.render(from));\n\t\t}\n\n\t\tlines.push(\n\t\t\t\"\",\n\t\t\t\"class HelloBody {\",\n\t\t\t'\\t@Field(\"body\", \"message\")',\n\t\t\t\"\\tpublic message!: string;\",\n\t\t\t\"}\",\n\t\t\t\"\",\n\t\t);\n\n\t\tfor (const d of this._classDecorators) {\n\t\t\tlines.push(d);\n\t\t}\n\t\tlines.push('@Controller({ prefix: \"/hello\" })', \"export class HelloController {\", \"\");\n\n\t\tlines.push(\"\\tpublic constructor(\");\n\t\tfor (const p of this._ctorParams) {\n\t\t\tlines.push(`\\t\\t${p},`);\n\t\t}\n\t\tlines.push(\"\\t) {}\");\n\t\tlines.push(\"\");\n\n\t\tfor (const method of this._methods.values()) {\n\t\t\tlines.push(...method.render(), \"\");\n\t\t}\n\n\t\tlines.push(\"}\", \"\");\n\n\t\treturn [\n\t\t\t{\n\t\t\t\tfilePath: \"src/controllers/hello.controller.ts\",\n\t\t\t\tcontent: lines.join(\"\\n\"),\n\t\t\t},\n\t\t];\n\t}\n}\n"],"names":["WELL_KNOWN_FILES","ImportGroup","_values","_types","add","name","typeOnly","includes","push","typeIdx","indexOf","splice","render","from","values","sort","types","map","n","join","ControllerMethod","_extraDecorators","_body","_isAsync","_httpDecorator","_params","isAsync","body","addDecorator","decorator","setBody","setAsync","lines","d","asyncKw","line","ControllerSourceFile","key","CONTROLLER_TS","_cortexImports","_extraImportGroups","Map","_classDecorators","_ctorParams","_methods","getMethod","m","get","Error","addCortexImport","addImport","group","set","addConstructorParam","param","files","p","method","filePath","content"],"mappings":"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"}