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

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

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "postmanFeature", {
+    enumerable: true,
+    get: function() {
+        return postmanFeature;
+    }
+});
+const _promises = require("node:fs/promises");
+const _nodepath = require("node:path");
+const _index = require("../../domain/index.js");
+const _auth0cli = /*#__PURE__*/ _interop_require_wildcard(require("../auth0/auth0-cli.js"));
+const _models = require("../auth0/models.js");
+const _collectiontemplate = require("./collection.template.js");
+const _environmenttemplate = require("./environment.template.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;
+}
+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(_models.AUTH0_CONFIG_KEY);
+    const apiKey = process.env.POSTMAN_API_KEY ?? await (0, _index.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 (0, _index.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 (0, _index.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 = _auth0cli.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 ${_auth0cli.REQUIRED_SCOPES}`);
+        }
+    }
+    // Create collection
+    const colRes = await fetch(`https://api.getpostman.com/collections?workspace=${workspaceId}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+            collection: (0, _collectiontemplate.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 = (0, _nodepath.join)(targetDir, "postman", "environments");
+    await (0, _promises.mkdir)(envDir, {
+        recursive: true
+    });
+    await (0, _promises.writeFile)((0, _nodepath.join)(envDir, `${projectName} — Local.environment.yaml`), (0, _environmenttemplate.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;
+}
+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":["postmanFeature","enabled","ctx","opts","postman","yes","integrate","projectName","targetDir","auth0Config","models","get","AUTH0_CONFIG_KEY","apiKey","process","env","POSTMAN_API_KEY","ask","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","auth0","createSpaApp","client_id","REQUIRED_SCOPES","colRes","collection","buildPostmanCollection","envVars","key","value","push","issuerBaseUrl","replace","audience","envRes","environment","values","envDir","join","mkdir","recursive","writeFile","postmanEnvironmentYaml","auth0Domain","auth0Audience","auth0ClientId","undefined"],"mappings":"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"}

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

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

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

@@ -0,0 +1,80 @@
+"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 DATABASE_BASE_CONFIG_YAML () {
+        return DATABASE_BASE_CONFIG_YAML;
+    },
+    get SAMPLE_ENTITY_TS () {
+        return SAMPLE_ENTITY_TS;
+    },
+    get SAMPLE_REPOSITORY_TS () {
+        return SAMPLE_REPOSITORY_TS;
+    },
+    get databaseDevConfigYaml () {
+        return databaseDevConfigYaml;
+    }
+});
+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;
+}
+`;
+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}
+}
+`;
+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}
+`;
+}
+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/commonjs/v1/scaffold.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "scaffold", {
+    enumerable: true,
+    get: function() {
+        return scaffold;
+    }
+});
+const _nodefs = require("node:fs");
+const _nodepath = require("node:path");
+const _index = require("./domain/index.js");
+const _api = require("./workflows/api.js");
+const _cli = require("./workflows/cli.js");
+const WORKFLOWS = {
+    api: _api.apiWorkflow,
+    cli: _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 (0, _index.ask)("Template? [api/cli] (api): ", "api");
+    return answer.toLowerCase() === "cli" ? "cli" : "api";
+}
+async function scaffold(targetDir, opts) {
+    if (!opts.yes && (0, _nodefs.existsSync)(targetDir) && (0, _nodefs.readdirSync)(targetDir).length > 0) {
+        const name = (0, _nodepath.basename)(targetDir);
+        const answer = await (0, _index.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 = (0, _index.createContext)(targetDir, opts, template);
+    await (0, _index.runWorkflow)(WORKFLOWS[template], ctx);
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/v1/version.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CREATE_VERSION", {
+    enumerable: true,
+    get: function() {
+        return CREATE_VERSION;
+    }
+});
+const _nodemodule = require("node:module");
+const _nodepath = require("node:path");
+const _nodeurl = require("node:url");
+const _require = (0, _nodemodule.createRequire)(require("url").pathToFileURL(__filename).toString());
+function resolveCreateVersion() {
+    let dir = (0, _nodepath.dirname)((0, _nodeurl.fileURLToPath)(require("url").pathToFileURL(__filename).toString()));
+    for(let i = 0; i < 5; i++){
+        try {
+            const pkg = _require((0, _nodepath.join)(dir, "package.json"));
+            if (pkg.name === "@decohere/create") {
+                return pkg.version ?? "0.0.1-dev";
+            }
+        } catch  {}
+        const parent = (0, _nodepath.dirname)(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    return "0.0.1-dev";
+}
+const CREATE_VERSION = resolveCreateVersion();
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/v1/workflows/api.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "apiWorkflow", {
+    enumerable: true,
+    get: function() {
+        return apiWorkflow;
+    }
+});
+const _index = require("../domain/index.js");
+const _feature = require("../features/api-core/feature.js");
+const _feature1 = require("../features/auth0/feature.js");
+const _feature2 = require("../features/devcontainer/feature.js");
+const _feature3 = require("../features/finalize/feature.js");
+const _feature4 = require("../features/postgresql/feature.js");
+const _feature5 = require("../features/postman/feature.js");
+const _feature6 = require("../features/typeorm/feature.js");
+const apiWorkflow = (0, _index.defineWorkflow)("api", [
+    _feature.apiCoreFeature,
+    _feature6.typeormFeature,
+    _feature4.postgresqlFeature,
+    _feature1.auth0Feature,
+    _feature5.postmanFeature,
+    _feature2.devcontainerFeature,
+    _feature3.finalizeFeature
+]);
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/v1/workflows/cli.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "cliWorkflow", {
+    enumerable: true,
+    get: function() {
+        return cliWorkflow;
+    }
+});
+const _index = require("../domain/index.js");
+const _feature = require("../features/cli-core/feature.js");
+const _feature1 = require("../features/finalize/feature.js");
+const cliWorkflow = (0, _index.defineWorkflow)("cli", [
+    _feature.cliCoreFeature,
+    _feature1.finalizeFeature
+]);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS92MS93b3JrZmxvd3MvY2xpLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGRlZmluZVdvcmtmbG93IH0gZnJvbSBcIi4uL2RvbWFpbi9pbmRleC5qc1wiO1xuaW1wb3J0IHsgY2xpQ29yZUZlYXR1cmUgfSBmcm9tIFwiLi4vZmVhdHVyZXMvY2xpLWNvcmUvZmVhdHVyZS5qc1wiO1xuaW1wb3J0IHsgZmluYWxpemVGZWF0dXJlIH0gZnJvbSBcIi4uL2ZlYXR1cmVzL2ZpbmFsaXplL2ZlYXR1cmUuanNcIjtcblxuZXhwb3J0IGNvbnN0IGNsaVdvcmtmbG93ID0gZGVmaW5lV29ya2Zsb3coXCJjbGlcIiwgW2NsaUNvcmVGZWF0dXJlLCBmaW5hbGl6ZUZlYXR1cmVdKTtcbiJdLCJuYW1lcyI6WyJjbGlXb3JrZmxvdyIsImRlZmluZVdvcmtmbG93IiwiY2xpQ29yZUZlYXR1cmUiLCJmaW5hbGl6ZUZlYXR1cmUiXSwibWFwcGluZ3MiOiI7Ozs7K0JBSWFBOzs7ZUFBQUE7Ozt1QkFKa0I7eUJBQ0E7MEJBQ0M7QUFFekIsTUFBTUEsY0FBY0MsSUFBQUEscUJBQWMsRUFBQyxPQUFPO0lBQUNDLHVCQUFjO0lBQUVDLHlCQUFlO0NBQUMifQ==

package/es6/src/cli.js

@@ -1,11 +1,32 @@
 #!/usr/bin/env node
-import { resolve } from "node:path";
 import { Command } from "commander";
-import { scaffold } from "./scaffold.js";
+import { scaffoldApi } from "./webapi/create-api.js";
+// import { scaffold } from "./scaffold.js";
 const program = new Command();
-program.name("decohere").description("Scaffold a new Decohere project").argument("[directory]", "Target directory (default: current directory)", ".").option("-y, --yes", "Skip confirmation prompts").option("-t, --template <template>", "Project template: basic (default) or webapi", "basic").option("-d, --database <provider>", "Database provider to include (webapi only): typeorm").action(async (directory, opts)=>{
-    await scaffold(resolve(directory), opts);
+program.name("decohere").description("Scaffold a new Decohere project");
+// .argument("[directory]", "Target directory (default: current directory)", ".");
+program.command("webapi").option("-d <directory>", "Target directory (default: current directory)", ".").action(async (_name, cmd)=>{
+    await scaffoldApi(cmd.optsWithGlobals());
 });
+// .option("-y, --yes", "Skip confirmation prompts")
+// .option("-t, --template <template>", "Project template: api (default) or cli")
+// .option("-d, --database <provider>", "Database provider to include (api only): typeorm")
+// .option("-i, --idp <provider>", "Identity provider to configure (api only): auth0")
+// .option("-p, --postman", "Configure a Postman workspace, collection, and environment")
+// .action(
+// 	async (
+// 		directory: string,
+// 		opts: {
+// 			yes?: boolean;
+// 			template?: "api" | "cli";
+// 			database?: "typeorm";
+// 			idp?: "auth0";
+// 			postman?: boolean;
+// 		},
+// 	) => {
+// 		await scaffold(resolve(directory), opts);
+// 	},
+// );
 program.parse();
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvY2xpLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIiMhL3Vzci9iaW4vZW52IG5vZGVcbmltcG9ydCB7IHJlc29sdmUgfSBmcm9tIFwibm9kZTpwYXRoXCI7XG5pbXBvcnQgeyBDb21tYW5kIH0gZnJvbSBcImNvbW1hbmRlclwiO1xuaW1wb3J0IHsgc2NhZmZvbGQgfSBmcm9tIFwiLi9zY2FmZm9sZC5qc1wiO1xuXG5jb25zdCBwcm9ncmFtID0gbmV3IENvbW1hbmQoKTtcblxucHJvZ3JhbVxuXHQubmFtZShcImRlY29oZXJlXCIpXG5cdC5kZXNjcmlwdGlvbihcIlNjYWZmb2xkIGEgbmV3IERlY29oZXJlIHByb2plY3RcIilcblx0LmFyZ3VtZW50KFwiW2RpcmVjdG9yeV1cIiwgXCJUYXJnZXQgZGlyZWN0b3J5IChkZWZhdWx0OiBjdXJyZW50IGRpcmVjdG9yeSlcIiwgXCIuXCIpXG5cdC5vcHRpb24oXCIteSwgLS15ZXNcIiwgXCJTa2lwIGNvbmZpcm1hdGlvbiBwcm9tcHRzXCIpXG5cdC5vcHRpb24oXCItdCwgLS10ZW1wbGF0ZSA8dGVtcGxhdGU+XCIsIFwiUHJvamVjdCB0ZW1wbGF0ZTogYmFzaWMgKGRlZmF1bHQpIG9yIHdlYmFwaVwiLCBcImJhc2ljXCIpXG5cdC5vcHRpb24oXCItZCwgLS1kYXRhYmFzZSA8cHJvdmlkZXI+XCIsIFwiRGF0YWJhc2UgcHJvdmlkZXIgdG8gaW5jbHVkZSAod2ViYXBpIG9ubHkpOiB0eXBlb3JtXCIpXG5cdC5hY3Rpb24oXG5cdFx0YXN5bmMgKFxuXHRcdFx0ZGlyZWN0b3J5OiBzdHJpbmcsXG5cdFx0XHRvcHRzOiB7IHllcz86IGJvb2xlYW47IHRlbXBsYXRlPzogXCJiYXNpY1wiIHwgXCJ3ZWJhcGlcIjsgZGF0YWJhc2U/OiBcInR5cGVvcm1cIiB9LFxuXHRcdCkgPT4ge1xuXHRcdFx0YXdhaXQgc2NhZmZvbGQocmVzb2x2ZShkaXJlY3RvcnkpLCBvcHRzKTtcblx0XHR9LFxuXHQpO1xuXG5wcm9ncmFtLnBhcnNlKCk7XG4iXSwibmFtZXMiOlsicmVzb2x2ZSIsIkNvbW1hbmQiLCJzY2FmZm9sZCIsInByb2dyYW0iLCJuYW1lIiwiZGVzY3JpcHRpb24iLCJhcmd1bWVudCIsIm9wdGlvbiIsImFjdGlvbiIsImRpcmVjdG9yeSIsIm9wdHMiLCJwYXJzZSJdLCJtYXBwaW5ncyI6IjtBQUNBLFNBQVNBLE9BQU8sUUFBUSxZQUFZO0FBQ3BDLFNBQVNDLE9BQU8sUUFBUSxZQUFZO0FBQ3BDLFNBQVNDLFFBQVEsUUFBUSxnQkFBZ0I7QUFFekMsTUFBTUMsVUFBVSxJQUFJRjtBQUVwQkUsUUFDRUMsSUFBSSxDQUFDLFlBQ0xDLFdBQVcsQ0FBQyxtQ0FDWkMsUUFBUSxDQUFDLGVBQWUsaURBQWlELEtBQ3pFQyxNQUFNLENBQUMsYUFBYSw2QkFDcEJBLE1BQU0sQ0FBQyw2QkFBNkIsK0NBQStDLFNBQ25GQSxNQUFNLENBQUMsNkJBQTZCLHVEQUNwQ0MsTUFBTSxDQUNOLE9BQ0NDLFdBQ0FDO0lBRUEsTUFBTVIsU0FBU0YsUUFBUVMsWUFBWUM7QUFDcEM7QUFHRlAsUUFBUVEsS0FBSyJ9
+//# sourceMappingURL=data:application/json;base64,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