@decohere/create 0.0.1-dev.16 → 0.0.1-dev.18

package/es6/v1/features/devcontainer/feature.js

@@ -0,0 +1,28 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { COMPOSE_KEY } from "../../domain/compose.model.js";
+import { DEVCONTAINER_KEY } from "../../domain/devcontainer.model.js";
+async function render(ctx) {
+    const model = ctx.models.get(DEVCONTAINER_KEY);
+    if (!model) return ctx;
+    const dir = join(ctx.targetDir, ".devcontainer");
+    await mkdir(dir, {
+        recursive: true
+    });
+    await writeFile(join(dir, "devcontainer.json"), model.render());
+    const compose = ctx.models.get(COMPOSE_KEY);
+    if (compose) {
+        await writeFile(join(dir, "docker-compose.yml"), compose.render());
+        const dockerfile = model.dockerfile;
+        if (dockerfile) {
+            await writeFile(join(dir, "Dockerfile"), dockerfile.render());
+        }
+    }
+    return ctx;
+}
+export const devcontainerFeature = {
+    name: "devcontainer",
+    render
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/v1/features/finalize/feature.js

@@ -0,0 +1,38 @@
+import { basename } from "node:path";
+import { detectPackageManager, promptForPackageManager } from "@decohere/nexus/interop";
+import { ask } from "../../domain/index.js";
+async function finalize(ctx) {
+    let pm = detectPackageManager(ctx.targetDir);
+    if (pm == null) {
+        pm = await promptForPackageManager();
+    }
+    let shouldInstall;
+    if (ctx.opts.yes) {
+        shouldInstall = true;
+    } else {
+        const answer = await ask("\nInstall dependencies now? [yes/no] (yes): ", "yes");
+        shouldInstall = answer.toLowerCase() !== "no";
+    }
+    if (shouldInstall) {
+        console.log(`\nScaffolded ${ctx.projectName}. Installing dependencies...\n`);
+        await pm.install({
+            cwd: ctx.targetDir
+        });
+    }
+    console.log(`\nDone! ${shouldInstall ? "Next" : "To get started:"} steps:\n`);
+    if (basename(ctx.targetDir) !== ctx.targetDir) {
+        console.log(`  cd ${ctx.projectName}`);
+    }
+    if (!shouldInstall) {
+        console.log(`  ${pm.name} install`);
+    }
+    console.log("  pnpm build     # forge build");
+    console.log("  pnpm dev       # flux serve\n");
+    return ctx;
+}
+export const finalizeFeature = {
+    name: "finalize",
+    finalize
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/v1/features/postgresql/feature.js

@@ -0,0 +1,71 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { COMPOSE_KEY, ComposeModel } from "../../domain/compose.model.js";
+import { DEVCONTAINER_KEY } from "../../domain/devcontainer.model.js";
+import { POSTGRES_CREDS_KEY } from "./models.js";
+const enabled = (ctx)=>ctx.opts.database === "typeorm";
+async function configure(ctx) {
+    const devcontainer = ctx.models.get(DEVCONTAINER_KEY);
+    const nodeModulesVolume = `${ctx.projectName}-node-modules`;
+    const db = `${ctx.projectName}_dev`;
+    const user = "postgres";
+    const password = randomBytes(16).toString("hex");
+    const compose = new ComposeModel().addService("devcontainer", {
+        build: ".",
+        volumes: [
+            `\${HOME}/.npm/${ctx.projectName}:/home/node/.npm`,
+            `${nodeModulesVolume}:/workspace/node_modules`
+        ],
+        environment: {
+            NPM_CONFIG_USERCONFIG: "/home/node/.npm/.npmrc"
+        },
+        command: "sleep infinity"
+    }).addService("postgres", {
+        image: "postgres:16",
+        restart: "unless-stopped",
+        environment: {
+            // biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose reads these from .env
+            POSTGRES_DB: "${POSTGRES_DB}",
+            // biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose reads these from .env
+            POSTGRES_USER: "${POSTGRES_USER}",
+            // biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose reads these from .env
+            POSTGRES_PASSWORD: "${POSTGRES_PASSWORD}"
+        },
+        ports: [
+            "5432:5432"
+        ],
+        volumes: [
+            "postgres-data:/var/lib/postgresql/data"
+        ]
+    }).addVolume(nodeModulesVolume).addVolume("postgres-data");
+    devcontainer?.useCompose();
+    const creds = {
+        db,
+        user,
+        password
+    };
+    return {
+        ...ctx,
+        models: ctx.models.set(COMPOSE_KEY, compose).set(POSTGRES_CREDS_KEY, creds)
+    };
+}
+async function render(ctx) {
+    const creds = ctx.models.get(POSTGRES_CREDS_KEY);
+    if (!creds) return ctx;
+    const devcontainerDir = join(ctx.targetDir, ".devcontainer");
+    await mkdir(devcontainerDir, {
+        recursive: true
+    });
+    const envContent = `POSTGRES_DB=${creds.db}\nPOSTGRES_USER=${creds.user}\nPOSTGRES_PASSWORD=${creds.password}\n`;
+    await writeFile(join(devcontainerDir, ".env"), envContent);
+    return ctx;
+}
+export const postgresqlFeature = {
+    name: "postgresql",
+    enabled,
+    configure,
+    render
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/v1/features/postgresql/models.js

@@ -0,0 +1,4 @@
+import { modelKey } from "../../domain/context.js";
+export const POSTGRES_CREDS_KEY = modelKey("postgres-creds");
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS92MS9mZWF0dXJlcy9wb3N0Z3Jlc3FsL21vZGVscy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBtb2RlbEtleSB9IGZyb20gXCIuLi8uLi9kb21haW4vY29udGV4dC5qc1wiO1xuXG5leHBvcnQgaW50ZXJmYWNlIFBvc3RncmVzQ3JlZHMge1xuXHRkYjogc3RyaW5nO1xuXHR1c2VyOiBzdHJpbmc7XG5cdHBhc3N3b3JkOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBjb25zdCBQT1NUR1JFU19DUkVEU19LRVkgPSBtb2RlbEtleTxQb3N0Z3Jlc0NyZWRzPihcInBvc3RncmVzLWNyZWRzXCIpO1xuIl0sIm5hbWVzIjpbIm1vZGVsS2V5IiwiUE9TVEdSRVNfQ1JFRFNfS0VZIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxRQUFRLFFBQVEsMEJBQTBCO0FBUW5ELE9BQU8sTUFBTUMscUJBQXFCRCxTQUF3QixrQkFBa0IifQ==

package/es6/v1/features/postman/collection.template.js

@@ -0,0 +1,70 @@
+export function buildPostmanCollection(projectName, withAuth0) {
+    const auth = withAuth0 ? {
+        type: "oauth2",
+        oauth2: [
+            {
+                key: "grant_type",
+                value: "authorization_code_with_pkce",
+                type: "string"
+            },
+            {
+                key: "authUrl",
+                value: "https://{{auth0Domain}}/authorize?audience={{auth0Audience}}",
+                type: "string"
+            },
+            {
+                key: "accessTokenUrl",
+                value: "https://{{auth0Domain}}/oauth/token",
+                type: "string"
+            },
+            {
+                key: "clientId",
+                value: "{{auth0ClientId}}",
+                type: "string"
+            },
+            {
+                key: "scope",
+                value: "openid profile email",
+                type: "string"
+            },
+            {
+                key: "addTokenTo",
+                value: "header",
+                type: "string"
+            },
+            {
+                key: "challengeAlgorithm",
+                value: "S256",
+                type: "string"
+            }
+        ]
+    } : undefined;
+    return {
+        info: {
+            name: `${projectName} WebAPI`,
+            schema: "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+        },
+        ...auth ? {
+            auth
+        } : {},
+        item: [
+            {
+                name: "Hello",
+                request: {
+                    method: "GET",
+                    url: {
+                        raw: "{{baseUrl}}/hello",
+                        host: [
+                            "{{baseUrl}}"
+                        ],
+                        path: [
+                            "hello"
+                        ]
+                    }
+                }
+            }
+        ]
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/v1/features/postman/environment.template.js

@@ -0,0 +1,14 @@
+export function postmanEnvironmentYaml(name, opts) {
+    const auth0Section = opts?.auth0Domain ? `${[
+        "  - key: auth0Domain",
+        `    value: ${opts.auth0Domain}`,
+        "  - key: auth0Audience",
+        `    value: '${opts.auth0Audience ?? ""}'`,
+        "  - key: auth0ClientId",
+        `    value: '${opts.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}`;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS92MS9mZWF0dXJlcy9wb3N0bWFuL2Vudmlyb25tZW50LnRlbXBsYXRlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgUG9zdG1hbkVudk9wdGlvbnMge1xuXHRhdXRoMERvbWFpbj86IHN0cmluZztcblx0YXV0aDBBdWRpZW5jZT86IHN0cmluZztcblx0YXV0aDBDbGllbnRJZD86IHN0cmluZztcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHBvc3RtYW5FbnZpcm9ubWVudFlhbWwobmFtZTogc3RyaW5nLCBvcHRzPzogUG9zdG1hbkVudk9wdGlvbnMpOiBzdHJpbmcge1xuXHRjb25zdCBhdXRoMFNlY3Rpb24gPSBvcHRzPy5hdXRoMERvbWFpblxuXHRcdD8gYCR7W1xuXHRcdFx0XHRcIiAgLSBrZXk6IGF1dGgwRG9tYWluXCIsXG5cdFx0XHRcdGAgICAgdmFsdWU6ICR7b3B0cy5hdXRoMERvbWFpbn1gLFxuXHRcdFx0XHRcIiAgLSBrZXk6IGF1dGgwQXVkaWVuY2VcIixcblx0XHRcdFx0YCAgICB2YWx1ZTogJyR7b3B0cy5hdXRoMEF1ZGllbmNlID8/IFwiXCJ9J2AsXG5cdFx0XHRcdFwiICAtIGtleTogYXV0aDBDbGllbnRJZFwiLFxuXHRcdFx0XHRgICAgIHZhbHVlOiAnJHtvcHRzLmF1dGgwQ2xpZW50SWQgPz8gXCJcIn0nYCxcblx0XHRcdFx0XCIgICAgZGVzY3JpcHRpb246IENsaWVudCBJRCBvZiB0aGUgQXV0aDAgU1BBIGFwcGxpY2F0aW9uIHVzZWQgYnkgUG9zdG1hbiBmb3IgUEtDRSBhdXRoZW50aWNhdGlvblwiLFxuXHRcdFx0XS5qb2luKFwiXFxuXCIpfVxcbmBcblx0XHQ6IFwiXCI7XG5cdHJldHVybiBgbmFtZTogJHtuYW1lfVxcbnZhbHVlczpcXG4gIC0ga2V5OiBiYXNlVXJsXFxuICAgIHZhbHVlOiAnaHR0cDovL2xvY2FsaG9zdDozMDAwJ1xcbiR7YXV0aDBTZWN0aW9ufWA7XG59XG4iXSwibmFtZXMiOlsicG9zdG1hbkVudmlyb25tZW50WWFtbCIsIm5hbWUiLCJvcHRzIiwiYXV0aDBTZWN0aW9uIiwiYXV0aDBEb21haW4iLCJhdXRoMEF1ZGllbmNlIiwiYXV0aDBDbGllbnRJZCIsImpvaW4iXSwibWFwcGluZ3MiOiJBQU1BLE9BQU8sU0FBU0EsdUJBQXVCQyxJQUFZLEVBQUVDLElBQXdCO0lBQzVFLE1BQU1DLGVBQWVELE1BQU1FLGNBQ3hCLEdBQUc7UUFDSDtRQUNBLENBQUMsV0FBVyxFQUFFRixLQUFLRSxXQUFXLEVBQUU7UUFDaEM7UUFDQSxDQUFDLFlBQVksRUFBRUYsS0FBS0csYUFBYSxJQUFJLEdBQUcsQ0FBQyxDQUFDO1FBQzFDO1FBQ0EsQ0FBQyxZQUFZLEVBQUVILEtBQUtJLGFBQWEsSUFBSSxHQUFHLENBQUMsQ0FBQztRQUMxQztLQUNBLENBQUNDLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQyxHQUNmO0lBQ0gsT0FBTyxDQUFDLE1BQU0sRUFBRU4sS0FBSyxpRUFBaUUsRUFBRUUsY0FBYztBQUN2RyJ9

package/es6/v1/features/postman/feature.js

@@ -0,0 +1,141 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { ask } from "../../domain/index.js";
+import * as auth0 from "../auth0/auth0-cli.js";
+import { AUTH0_CONFIG_KEY } from "../auth0/models.js";
+import { buildPostmanCollection } from "./collection.template.js";
+import { postmanEnvironmentYaml } from "./environment.template.js";
+const enabled = (ctx)=>!!ctx.opts.postman && !ctx.opts.yes;
+/**
+ * Integrate phase: drives the Postman REST API (and optionally the auth0 CLI
+ * to create a SPA app for PKCE auth). Also writes a local environment yaml
+ * for the VS Code Postman extension.
+ */ async function integrate(ctx) {
+    const { projectName, targetDir } = ctx;
+    const auth0Config = ctx.models.get(AUTH0_CONFIG_KEY);
+    const apiKey = process.env.POSTMAN_API_KEY ?? await ask("\n  Postman API key (from 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 is invalid or request failed. Skipping Postman setup.");
+        return ctx;
+    }
+    const { workspaces } = await wsRes.json();
+    console.log("\n  Postman workspaces:");
+    for (const [i, w] of workspaces.entries()){
+        console.log(`    ${i + 1}. ${w.name} (${w.type})`);
+    }
+    console.log("    0. Create new workspace");
+    const wsInput = await ask("  Select workspace [0]: ", "0");
+    const wsIdx = Number.parseInt(wsInput, 10);
+    let workspaceId;
+    if (Number.isNaN(wsIdx) || wsIdx === 0 || wsIdx > workspaces.length) {
+        const wsName = await ask(`  New workspace name [${projectName}]: `, projectName);
+        const createRes = await fetch("https://api.getpostman.com/workspaces", {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                workspace: {
+                    name: wsName,
+                    type: "personal"
+                }
+            })
+        });
+        const { workspace } = await createRes.json();
+        workspaceId = workspace.id;
+        console.log(`  ✓ Workspace created: ${wsName}`);
+    } else {
+        workspaceId = workspaces[wsIdx - 1].id;
+        console.log(`  ✓ Workspace selected: ${workspaces[wsIdx - 1].name}`);
+    }
+    // Create SPA app in Auth0 for Postman PKCE flow
+    let spaClientId;
+    if (auth0Config) {
+        console.log("\n  Creating Auth0 SPA application for Postman...");
+        try {
+            spaClientId = auth0.createSpaApp(`${projectName} Postman`, "https://oauth.pstmn.io/v1/callback").client_id;
+            console.log(`  ✓ SPA app created: ${spaClientId}`);
+        } catch  {
+            console.error(`  ✗ Failed to create SPA app. Re-login with required scopes:\n    auth0 login --scopes ${auth0.REQUIRED_SCOPES}`);
+        }
+    }
+    // Create collection
+    const colRes = await fetch(`https://api.getpostman.com/collections?workspace=${workspaceId}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+            collection: buildPostmanCollection(projectName, auth0Config != null)
+        })
+    });
+    if (colRes.ok) {
+        console.log("  ✓ Postman collection created");
+    } else {
+        console.error("  ✗ Failed to create Postman collection");
+    }
+    // Create environment
+    const envVars = [
+        {
+            key: "baseUrl",
+            value: "http://localhost:3000",
+            type: "default",
+            enabled: true
+        }
+    ];
+    if (auth0Config) {
+        envVars.push({
+            key: "auth0Domain",
+            value: auth0Config.issuerBaseUrl.replace("https://", ""),
+            type: "default",
+            enabled: true
+        }, {
+            key: "auth0Audience",
+            value: auth0Config.audience,
+            type: "default",
+            enabled: true
+        }, {
+            key: "auth0ClientId",
+            value: spaClientId ?? "",
+            type: "default",
+            enabled: true
+        });
+    }
+    const envRes = await fetch(`https://api.getpostman.com/environments?workspace=${workspaceId}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+            environment: {
+                name: `${projectName} — Local`,
+                values: envVars
+            }
+        })
+    });
+    if (envRes.ok) {
+        console.log("  ✓ Postman environment created");
+    } else {
+        console.error("  ✗ Failed to create Postman environment");
+    }
+    // Write local environment YAML for VS Code Postman extension
+    const envDir = join(targetDir, "postman", "environments");
+    await mkdir(envDir, {
+        recursive: true
+    });
+    await writeFile(join(envDir, `${projectName} — Local.environment.yaml`), postmanEnvironmentYaml(`${projectName} — Local`, auth0Config ? {
+        auth0Domain: auth0Config.issuerBaseUrl.replace("https://", ""),
+        auth0Audience: auth0Config.audience,
+        auth0ClientId: spaClientId ?? ""
+    } : undefined));
+    console.log("  ✓ Local environment file written to postman/environments/");
+    return ctx;
+}
+export const postmanFeature = {
+    name: "postman",
+    enabled,
+    integrate
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/v1/features/postman/feature.ts"],"sourcesContent":["import { mkdir, writeFile } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { ask, type Feature, type ScaffoldContext } from \"../../domain/index.js\";\nimport * as auth0 from \"../auth0/auth0-cli.js\";\nimport { AUTH0_CONFIG_KEY } from \"../auth0/models.js\";\nimport { buildPostmanCollection } from \"./collection.template.js\";\nimport { postmanEnvironmentYaml } from \"./environment.template.js\";\n\nconst enabled = (ctx: ScaffoldContext) => !!ctx.opts.postman && !ctx.opts.yes;\n\n/**\n * Integrate phase: drives the Postman REST API (and optionally the auth0 CLI\n * to create a SPA app for PKCE auth). Also writes a local environment yaml\n * for the VS Code Postman extension.\n */\nasync function integrate(ctx: ScaffoldContext): Promise<ScaffoldContext> {\n\tconst { projectName, targetDir } = ctx;\n\tconst auth0Config = ctx.models.get(AUTH0_CONFIG_KEY);\n\n\tconst apiKey =\n\t\tprocess.env.POSTMAN_API_KEY ??\n\t\t(await ask(\"\\n  Postman API key (from app.getpostman.com/settings/me/api-keys): \"));\n\n\tconst headers = { \"X-Api-Key\": apiKey, \"Content-Type\": \"application/json\" };\n\n\tconst wsRes = await fetch(\"https://api.getpostman.com/workspaces\", { headers });\n\tif (!wsRes.ok) {\n\t\tconsole.error(\"\\n  Postman API key is invalid or request failed. Skipping Postman setup.\");\n\t\treturn ctx;\n\t}\n\tconst { workspaces } = (await wsRes.json()) as {\n\t\tworkspaces: Array<{ id: string; name: string; type: string }>;\n\t};\n\n\tconsole.log(\"\\n  Postman workspaces:\");\n\tfor (const [i, w] of workspaces.entries()) {\n\t\tconsole.log(`    ${i + 1}. ${w.name} (${w.type})`);\n\t}\n\tconsole.log(\"    0. Create new workspace\");\n\n\tconst wsInput = await ask(\"  Select workspace [0]: \", \"0\");\n\tconst wsIdx = Number.parseInt(wsInput, 10);\n\n\tlet workspaceId: string;\n\tif (Number.isNaN(wsIdx) || wsIdx === 0 || wsIdx > workspaces.length) {\n\t\tconst wsName = await ask(`  New workspace name [${projectName}]: `, projectName);\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 } = (await createRes.json()) as { workspace: { id: string } };\n\t\tworkspaceId = workspace.id;\n\t\tconsole.log(`  ✓ Workspace created: ${wsName}`);\n\t} else {\n\t\tworkspaceId = workspaces[wsIdx - 1].id;\n\t\tconsole.log(`  ✓ Workspace selected: ${workspaces[wsIdx - 1].name}`);\n\t}\n\n\t// Create SPA app in Auth0 for Postman PKCE flow\n\tlet spaClientId: string | undefined;\n\tif (auth0Config) {\n\t\tconsole.log(\"\\n  Creating Auth0 SPA application for Postman...\");\n\t\ttry {\n\t\t\tspaClientId = auth0.createSpaApp(\n\t\t\t\t`${projectName} Postman`,\n\t\t\t\t\"https://oauth.pstmn.io/v1/callback\",\n\t\t\t).client_id;\n\t\t\tconsole.log(`  ✓ SPA app created: ${spaClientId}`);\n\t\t} catch {\n\t\t\tconsole.error(\n\t\t\t\t`  ✗ Failed to create SPA app. Re-login with required scopes:\\n    auth0 login --scopes ${auth0.REQUIRED_SCOPES}`,\n\t\t\t);\n\t\t}\n\t}\n\n\t// Create collection\n\tconst colRes = await fetch(\n\t\t`https://api.getpostman.com/collections?workspace=${workspaceId}`,\n\t\t{\n\t\t\tmethod: \"POST\",\n\t\t\theaders,\n\t\t\tbody: JSON.stringify({\n\t\t\t\tcollection: buildPostmanCollection(projectName, auth0Config != null),\n\t\t\t}),\n\t\t},\n\t);\n\tif (colRes.ok) {\n\t\tconsole.log(\"  ✓ Postman collection created\");\n\t} else {\n\t\tconsole.error(\"  ✗ Failed to create Postman collection\");\n\t}\n\n\t// Create environment\n\tconst envVars: Array<{ key: string; value: string; type: string; enabled: boolean }> = [\n\t\t{ key: \"baseUrl\", value: \"http://localhost:3000\", type: \"default\", enabled: true },\n\t];\n\tif (auth0Config) {\n\t\tenvVars.push(\n\t\t\t{\n\t\t\t\tkey: \"auth0Domain\",\n\t\t\t\tvalue: auth0Config.issuerBaseUrl.replace(\"https://\", \"\"),\n\t\t\t\ttype: \"default\",\n\t\t\t\tenabled: true,\n\t\t\t},\n\t\t\t{ key: \"auth0Audience\", value: auth0Config.audience, type: \"default\", enabled: true },\n\t\t\t{\n\t\t\t\tkey: \"auth0ClientId\",\n\t\t\t\tvalue: spaClientId ?? \"\",\n\t\t\t\ttype: \"default\",\n\t\t\t\tenabled: true,\n\t\t\t},\n\t\t);\n\t}\n\tconst envRes = await fetch(\n\t\t`https://api.getpostman.com/environments?workspace=${workspaceId}`,\n\t\t{\n\t\t\tmethod: \"POST\",\n\t\t\theaders,\n\t\t\tbody: JSON.stringify({\n\t\t\t\tenvironment: { name: `${projectName} — Local`, values: envVars },\n\t\t\t}),\n\t\t},\n\t);\n\tif (envRes.ok) {\n\t\tconsole.log(\"  ✓ Postman environment created\");\n\t} else {\n\t\tconsole.error(\"  ✗ Failed to create Postman environment\");\n\t}\n\n\t// Write local environment YAML for VS Code Postman extension\n\tconst envDir = join(targetDir, \"postman\", \"environments\");\n\tawait mkdir(envDir, { recursive: true });\n\tawait writeFile(\n\t\tjoin(envDir, `${projectName} — Local.environment.yaml`),\n\t\tpostmanEnvironmentYaml(\n\t\t\t`${projectName} — Local`,\n\t\t\tauth0Config\n\t\t\t\t? {\n\t\t\t\t\t\tauth0Domain: auth0Config.issuerBaseUrl.replace(\"https://\", \"\"),\n\t\t\t\t\t\tauth0Audience: auth0Config.audience,\n\t\t\t\t\t\tauth0ClientId: spaClientId ?? \"\",\n\t\t\t\t\t}\n\t\t\t\t: undefined,\n\t\t),\n\t);\n\tconsole.log(\"  ✓ Local environment file written to postman/environments/\");\n\n\treturn ctx;\n}\n\nexport const postmanFeature: Feature = {\n\tname: \"postman\",\n\tenabled,\n\tintegrate,\n};\n"],"names":["mkdir","writeFile","join","ask","auth0","AUTH0_CONFIG_KEY","buildPostmanCollection","postmanEnvironmentYaml","enabled","ctx","opts","postman","yes","integrate","projectName","targetDir","auth0Config","models","get","apiKey","process","env","POSTMAN_API_KEY","headers","wsRes","fetch","ok","console","error","workspaces","json","log","i","w","entries","name","type","wsInput","wsIdx","Number","parseInt","workspaceId","isNaN","length","wsName","createRes","method","body","JSON","stringify","workspace","id","spaClientId","createSpaApp","client_id","REQUIRED_SCOPES","colRes","collection","envVars","key","value","push","issuerBaseUrl","replace","audience","envRes","environment","values","envDir","recursive","auth0Domain","auth0Audience","auth0ClientId","undefined","postmanFeature"],"mappings":"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"}

package/es6/v1/features/typeorm/feature.js

@@ -0,0 +1,56 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { DEVCONTAINER_KEY } from "../../domain/devcontainer.model.js";
+import { CREATE_VERSION } from "../../version.js";
+import { MAIN_TS_KEY } from "../api-core/main-ts.model.js";
+import { POSTGRES_CREDS_KEY } from "../postgresql/models.js";
+import { DATABASE_BASE_CONFIG_YAML, databaseDevConfigYaml, SAMPLE_ENTITY_TS, SAMPLE_REPOSITORY_TS } from "./scaffold-files.template.js";
+const enabled = (ctx)=>ctx.opts.database === "typeorm";
+async function configure(ctx) {
+    const mainTs = ctx.models.get(MAIN_TS_KEY);
+    if (!mainTs) return ctx;
+    mainTs.addImport("@decohere/codex-typeorm").addImport("./entities/sample.entity.js", "SampleEntity").addImport("./repositories/sample.repository.js", "SampleEntityRepository").appendBuilderChain(`.withTypeOrm({ entities: [SampleEntity], repositories: [SampleEntityRepository] })`);
+    ctx.models.get(DEVCONTAINER_KEY)?.addExtension("mtxr.sqltools");
+    return ctx;
+}
+async function render(ctx) {
+    const { targetDir, projectName } = ctx;
+    await mkdir(join(targetDir, "projects", "api", "src", "entities"), {
+        recursive: true
+    });
+    await mkdir(join(targetDir, "projects", "api", "src", "repositories"), {
+        recursive: true
+    });
+    await Promise.all([
+        writeFile(join(targetDir, "projects", "api", "src", "entities", "sample.entity.ts"), SAMPLE_ENTITY_TS),
+        writeFile(join(targetDir, "projects", "api", "src", "repositories", "sample.repository.ts"), SAMPLE_REPOSITORY_TS)
+    ]);
+    // Patch root package.json — add codex dependencies
+    const pkgPath = join(targetDir, "package.json");
+    const pkg = JSON.parse(await readFile(pkgPath, "utf8"));
+    pkg.dependencies["@decohere/codex"] = CREATE_VERSION;
+    pkg.dependencies.typeorm = "^0.3.28";
+    pkg.dependencies["@decohere/codex-typeorm"] = CREATE_VERSION;
+    await writeFile(pkgPath, JSON.stringify(pkg, null, 2));
+    // Append database base section (env-var refs) to config/config.yaml
+    const configPath = join(targetDir, "config", "config.yaml");
+    const existingConfig = await readFile(configPath, "utf8");
+    await writeFile(configPath, existingConfig + DATABASE_BASE_CONFIG_YAML);
+    // Append dev overrides (local creds + synchronize:true) to config/config.dev.yaml
+    const devConfigPath = join(targetDir, "config", "config.dev.yaml");
+    let existingDev = "";
+    try {
+        existingDev = await readFile(devConfigPath, "utf8");
+    } catch  {}
+    const devFragment = databaseDevConfigYaml(projectName, ctx.models.get(POSTGRES_CREDS_KEY));
+    await writeFile(devConfigPath, existingDev ? `${existingDev}\n${devFragment}` : devFragment);
+    return ctx;
+}
+export const typeormFeature = {
+    name: "typeorm",
+    enabled,
+    configure,
+    render
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/v1/features/typeorm/scaffold-files.template.js

@@ -0,0 +1,56 @@
+export const SAMPLE_ENTITY_TS = `import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+import type { Entity as IEntity } from "@decohere/codex";
+
+@Entity()
+export class SampleEntity implements IEntity {
+\t@PrimaryGeneratedColumn()
+\tpublic id!: number;
+
+\t@Column()
+\tpublic name!: string;
+}
+`;
+export const SAMPLE_REPOSITORY_TS = `import { injectable } from "@decohere/crucible/decorators";
+import { injectUnitOfWork } from "@decohere/codex";
+import { TypeOrmRepository, TypeOrmUnitOfWork } from "@decohere/codex-typeorm";
+import { SampleEntity } from "../entities/sample.entity.js";
+
+@injectable()
+export class SampleEntityRepository extends TypeOrmRepository<SampleEntity> {
+\tpublic constructor(@injectUnitOfWork() unitOfWork: TypeOrmUnitOfWork) {
+\t\tsuper(unitOfWork, SampleEntity);
+\t}
+}
+`;
+export function databaseDevConfigYaml(name, creds) {
+    const db = creds?.db ?? `${name}_dev`;
+    const user = creds?.user ?? "postgres";
+    const password = creds?.password ?? "postgres";
+    return `database:
+  dataSources:
+    - host: localhost
+      port: 5432
+      database: ${db}
+      username: ${user}
+      password: ${password}
+      synchronize: true
+      adminUser: ${user}
+      adminPassword: ${password}
+`;
+}
+export const DATABASE_BASE_CONFIG_YAML = `database:
+  dataSources:
+    - name: default
+      provider: postgres
+      host: \${DB_HOST}
+      port: \${DB_PORT}
+      database: \${DB_NAME}
+      username: \${DB_USER}
+      password: \${DB_PASSWORD}
+      synchronize: false
+      seed: false
+      adminUser: \${DB_ADMIN_USER}
+      adminPassword: \${DB_ADMIN_PASSWORD}
+`;
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/v1/scaffold.js

@@ -0,0 +1,40 @@
+import { existsSync, readdirSync } from "node:fs";
+import { basename } from "node:path";
+import { ask, createContext, runWorkflow } from "./domain/index.js";
+import { apiWorkflow } from "./workflows/api.js";
+import { cliWorkflow } from "./workflows/cli.js";
+const WORKFLOWS = {
+    api: apiWorkflow,
+    cli: cliWorkflow
+};
+const TEMPLATE_ALIASES = {
+    webapi: "api"
+};
+async function resolveTemplate(_targetDir, opts) {
+    if (opts.yes || opts.template != null) {
+        const raw = opts.template ?? "api";
+        const key = TEMPLATE_ALIASES[raw] ?? raw;
+        if (!(key in WORKFLOWS)) {
+            console.error(`Unknown template "${raw}". Valid options: ${Object.keys(WORKFLOWS).join(", ")}.`);
+            process.exit(1);
+        }
+        return key;
+    }
+    const answer = await ask("Template? [api/cli] (api): ", "api");
+    return answer.toLowerCase() === "cli" ? "cli" : "api";
+}
+export async function scaffold(targetDir, opts) {
+    if (!opts.yes && existsSync(targetDir) && readdirSync(targetDir).length > 0) {
+        const name = basename(targetDir);
+        const answer = await ask(`Directory "${name}" is not empty. Continue? [y/N] `);
+        if (!answer.toLowerCase().startsWith("y")) {
+            console.log("Aborted.");
+            process.exit(0);
+        }
+    }
+    const template = await resolveTemplate(targetDir, opts);
+    const ctx = createContext(targetDir, opts, template);
+    await runWorkflow(WORKFLOWS[template], ctx);
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/v1/version.js

@@ -0,0 +1,22 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const _require = createRequire(import.meta.url);
+function resolveCreateVersion() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for(let i = 0; i < 5; i++){
+        try {
+            const pkg = _require(join(dir, "package.json"));
+            if (pkg.name === "@decohere/create") {
+                return pkg.version ?? "0.0.1-dev";
+            }
+        } catch  {}
+        const parent = dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    return "0.0.1-dev";
+}
+/** Version of @decohere/create, used to pin scaffolded @decohere/* dependencies. */ export const CREATE_VERSION = resolveCreateVersion();
+
+//# sourceMappingURL=data:application/json;base64,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