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

package/commonjs/src/cli.js

@@ -3,5 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _runner = require("./runner.js");
-(0, _runner.runInBuilder)(process.argv.slice(2));
+const _nodepath = require("node:path");
+const _commander = require("commander");
+const _scaffold = require("./scaffold.js");
+const program = new _commander.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 (0, _scaffold.scaffold)((0, _nodepath.resolve)(directory), opts);
+});
+program.parse();
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvY2xpLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIiMhL3Vzci9iaW4vZW52IG5vZGVcbmltcG9ydCB7IHJlc29sdmUgfSBmcm9tIFwibm9kZTpwYXRoXCI7XG5pbXBvcnQgeyBDb21tYW5kIH0gZnJvbSBcImNvbW1hbmRlclwiO1xuaW1wb3J0IHsgc2NhZmZvbGQgfSBmcm9tIFwiLi9zY2FmZm9sZC5qc1wiO1xuXG5jb25zdCBwcm9ncmFtID0gbmV3IENvbW1hbmQoKTtcblxucHJvZ3JhbVxuXHQubmFtZShcImRlY29oZXJlXCIpXG5cdC5kZXNjcmlwdGlvbihcIlNjYWZmb2xkIGEgbmV3IERlY29oZXJlIHByb2plY3RcIilcblx0LmFyZ3VtZW50KFwiW2RpcmVjdG9yeV1cIiwgXCJUYXJnZXQgZGlyZWN0b3J5IChkZWZhdWx0OiBjdXJyZW50IGRpcmVjdG9yeSlcIiwgXCIuXCIpXG5cdC5vcHRpb24oXCIteSwgLS15ZXNcIiwgXCJTa2lwIGNvbmZpcm1hdGlvbiBwcm9tcHRzXCIpXG5cdC5vcHRpb24oXCItdCwgLS10ZW1wbGF0ZSA8dGVtcGxhdGU+XCIsIFwiUHJvamVjdCB0ZW1wbGF0ZTogYmFzaWMgKGRlZmF1bHQpIG9yIHdlYmFwaVwiLCBcImJhc2ljXCIpXG5cdC5vcHRpb24oXCItZCwgLS1kYXRhYmFzZSA8cHJvdmlkZXI+XCIsIFwiRGF0YWJhc2UgcHJvdmlkZXIgdG8gaW5jbHVkZSAod2ViYXBpIG9ubHkpOiB0eXBlb3JtXCIpXG5cdC5hY3Rpb24oXG5cdFx0YXN5bmMgKFxuXHRcdFx0ZGlyZWN0b3J5OiBzdHJpbmcsXG5cdFx0XHRvcHRzOiB7IHllcz86IGJvb2xlYW47IHRlbXBsYXRlPzogXCJiYXNpY1wiIHwgXCJ3ZWJhcGlcIjsgZGF0YWJhc2U/OiBcInR5cGVvcm1cIiB9LFxuXHRcdCkgPT4ge1xuXHRcdFx0YXdhaXQgc2NhZmZvbGQocmVzb2x2ZShkaXJlY3RvcnkpLCBvcHRzKTtcblx0XHR9LFxuXHQpO1xuXG5wcm9ncmFtLnBhcnNlKCk7XG4iXSwibmFtZXMiOlsicHJvZ3JhbSIsIkNvbW1hbmQiLCJuYW1lIiwiZGVzY3JpcHRpb24iLCJhcmd1bWVudCIsIm9wdGlvbiIsImFjdGlvbiIsImRpcmVjdG9yeSIsIm9wdHMiLCJzY2FmZm9sZCIsInJlc29sdmUiLCJwYXJzZSJdLCJtYXBwaW5ncyI6Ijs7Ozs7MEJBQ3dCOzJCQUNBOzBCQUNDO0FBRXpCLE1BQU1BLFVBQVUsSUFBSUMsa0JBQU87QUFFM0JELFFBQ0VFLElBQUksQ0FBQyxZQUNMQyxXQUFXLENBQUMsbUNBQ1pDLFFBQVEsQ0FBQyxlQUFlLGlEQUFpRCxLQUN6RUMsTUFBTSxDQUFDLGFBQWEsNkJBQ3BCQSxNQUFNLENBQUMsNkJBQTZCLCtDQUErQyxTQUNuRkEsTUFBTSxDQUFDLDZCQUE2Qix1REFDcENDLE1BQU0sQ0FDTixPQUNDQyxXQUNBQztJQUVBLE1BQU1DLElBQUFBLGtCQUFRLEVBQUNDLElBQUFBLGlCQUFPLEVBQUNILFlBQVlDO0FBQ3BDO0FBR0ZSLFFBQVFXLEtBQUsifQ==

package/commonjs/src/scaffold.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "scaffold", {
+    enumerable: true,
+    get: function() {
+        return scaffold;
+    }
+});
+const _nodefs = require("node:fs");
+const _promises = require("node:fs/promises");
+const _nodepath = require("node:path");
+const _promises1 = require("node:readline/promises");
+const _interop = require("@decohere/nexus/interop");
+const _templates = require("./templates.js");
+async function scaffold(targetDir, opts) {
+    const name = (0, _nodepath.basename)(targetDir);
+    if ((0, _nodefs.existsSync)(targetDir) && (0, _nodefs.readdirSync)(targetDir).length > 0 && !opts.yes) {
+        const rl = (0, _promises1.createInterface)({
+            input: process.stdin,
+            output: process.stdout
+        });
+        const answer = await rl.question(`Directory "${name}" is not empty. Continue? [y/N] `);
+        rl.close();
+        if (!answer.trim().toLowerCase().startsWith("y")) {
+            console.log("Aborted.");
+            process.exit(0);
+        }
+    }
+    if (opts.template === "webapi") {
+        const dbOpts = opts.database ? {
+            database: opts.database
+        } : undefined;
+        await (0, _promises.mkdir)((0, _nodepath.join)(targetDir, "projects", "api", "src", "controllers"), {
+            recursive: true
+        });
+        await (0, _promises.mkdir)((0, _nodepath.join)(targetDir, "config"), {
+            recursive: true
+        });
+        const writes = [
+            (0, _promises.writeFile)((0, _nodepath.join)(targetDir, "package.json"), (0, _templates.WEB_API_ROOT_PACKAGE_JSON)(name, dbOpts)),
+            (0, _promises.writeFile)((0, _nodepath.join)(targetDir, "tsconfig.json"), _templates.WEB_API_TSCONFIG),
+            (0, _promises.writeFile)((0, _nodepath.join)(targetDir, "projects", "api", "package.json"), (0, _templates.WEB_API_APP_PACKAGE_JSON)(name)),
+            (0, _promises.writeFile)((0, _nodepath.join)(targetDir, "projects", "api", "src", "main.ts"), (0, _templates.WEB_API_MAIN_TS)(name, dbOpts)),
+            (0, _promises.writeFile)((0, _nodepath.join)(targetDir, "projects", "api", "src", "controllers", "hello.controller.ts"), _templates.HELLO_CONTROLLER_TS),
+            (0, _promises.writeFile)((0, _nodepath.join)(targetDir, "projects", "api", "src", "sample.config.ts"), _templates.SAMPLE_CONFIG_TS),
+            (0, _promises.writeFile)((0, _nodepath.join)(targetDir, "projects", "api", "src", "sample.service.ts"), _templates.SAMPLE_SERVICE_TS),
+            (0, _promises.writeFile)((0, _nodepath.join)(targetDir, "config", "config.yaml"), (0, _templates.CONFIG_YAML)(name, dbOpts)),
+            (0, _promises.writeFile)((0, _nodepath.join)(targetDir, "config", "config.dev.yaml"), _templates.CONFIG_DEV_YAML)
+        ];
+        if (opts.database === "typeorm") {
+            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
+            });
+            writes.push((0, _promises.writeFile)((0, _nodepath.join)(targetDir, "projects", "api", "src", "entities", "sample.entity.ts"), _templates.SAMPLE_ENTITY_TS), (0, _promises.writeFile)((0, _nodepath.join)(targetDir, "projects", "api", "src", "repositories", "sample.repository.ts"), _templates.SAMPLE_REPOSITORY_TS), (0, _promises.writeFile)((0, _nodepath.join)(targetDir, "config", "config.prod.yaml"), _templates.CONFIG_PROD_YAML));
+        }
+        await Promise.all(writes);
+    } else {
+        await (0, _promises.mkdir)((0, _nodepath.join)(targetDir, "projects", "app", "src"), {
+            recursive: true
+        });
+        await Promise.all([
+            (0, _promises.writeFile)((0, _nodepath.join)(targetDir, "package.json"), (0, _templates.ROOT_PACKAGE_JSON)(name)),
+            (0, _promises.writeFile)((0, _nodepath.join)(targetDir, "tsconfig.json"), _templates.TSCONFIG),
+            (0, _promises.writeFile)((0, _nodepath.join)(targetDir, "projects", "app", "package.json"), (0, _templates.APP_PACKAGE_JSON)(name)),
+            (0, _promises.writeFile)((0, _nodepath.join)(targetDir, "projects", "app", "src", "main.ts"), _templates.MAIN_TS)
+        ]);
+    }
+    console.log(`\nScaffolded ${name}. Installing dependencies...\n`);
+    let pm = (0, _interop.detectPackageManager)(targetDir);
+    if (pm == null) {
+        pm = await (0, _interop.promptForPackageManager)();
+    }
+    await pm.install({
+        cwd: targetDir
+    });
+    console.log(`\nDone! Next steps:\n`);
+    if ((0, _nodepath.basename)(targetDir) !== targetDir) {
+        console.log(`  cd ${name}`);
+    }
+    console.log("  pnpm build     # forge build");
+    console.log("  pnpm dev       # flux serve\n");
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/scaffold.ts"],"sourcesContent":["import { existsSync, readdirSync } from \"node:fs\";\nimport { mkdir, writeFile } from \"node:fs/promises\";\nimport { basename, join } from \"node:path\";\nimport { createInterface } from \"node:readline/promises\";\nimport { detectPackageManager, promptForPackageManager } from \"@decohere/nexus/interop\";\nimport {\n\tAPP_PACKAGE_JSON,\n\tCONFIG_DEV_YAML,\n\tCONFIG_PROD_YAML,\n\tCONFIG_YAML,\n\tHELLO_CONTROLLER_TS,\n\tMAIN_TS,\n\tROOT_PACKAGE_JSON,\n\tSAMPLE_CONFIG_TS,\n\tSAMPLE_ENTITY_TS,\n\tSAMPLE_REPOSITORY_TS,\n\tSAMPLE_SERVICE_TS,\n\tTSCONFIG,\n\tWEB_API_APP_PACKAGE_JSON,\n\tWEB_API_MAIN_TS,\n\tWEB_API_ROOT_PACKAGE_JSON,\n\tWEB_API_TSCONFIG,\n} from \"./templates.js\";\n\nexport interface ScaffoldOptions {\n\tyes?: boolean;\n\ttemplate?: \"basic\" | \"webapi\";\n\tdatabase?: \"typeorm\";\n}\n\nexport async function scaffold(targetDir: string, opts: ScaffoldOptions): Promise<void> {\n\tconst name = basename(targetDir);\n\n\tif (existsSync(targetDir) && readdirSync(targetDir).length > 0 && !opts.yes) {\n\t\tconst rl = createInterface({\n\t\t\tinput: process.stdin,\n\t\t\toutput: process.stdout,\n\t\t});\n\t\tconst answer = await rl.question(`Directory \"${name}\" is not empty. Continue? [y/N] `);\n\t\trl.close();\n\t\tif (!answer.trim().toLowerCase().startsWith(\"y\")) {\n\t\t\tconsole.log(\"Aborted.\");\n\t\t\tprocess.exit(0);\n\t\t}\n\t}\n\n\tif (opts.template === \"webapi\") {\n\t\tconst dbOpts = opts.database ? { database: opts.database } : undefined;\n\t\tawait mkdir(join(targetDir, \"projects\", \"api\", \"src\", \"controllers\"), { recursive: true });\n\t\tawait mkdir(join(targetDir, \"config\"), { recursive: true });\n\t\tconst writes = [\n\t\t\twriteFile(join(targetDir, \"package.json\"), WEB_API_ROOT_PACKAGE_JSON(name, dbOpts)),\n\t\t\twriteFile(join(targetDir, \"tsconfig.json\"), WEB_API_TSCONFIG),\n\t\t\twriteFile(\n\t\t\t\tjoin(targetDir, \"projects\", \"api\", \"package.json\"),\n\t\t\t\tWEB_API_APP_PACKAGE_JSON(name),\n\t\t\t),\n\t\t\twriteFile(\n\t\t\t\tjoin(targetDir, \"projects\", \"api\", \"src\", \"main.ts\"),\n\t\t\t\tWEB_API_MAIN_TS(name, dbOpts),\n\t\t\t),\n\t\t\twriteFile(\n\t\t\t\tjoin(targetDir, \"projects\", \"api\", \"src\", \"controllers\", \"hello.controller.ts\"),\n\t\t\t\tHELLO_CONTROLLER_TS,\n\t\t\t),\n\t\t\twriteFile(\n\t\t\t\tjoin(targetDir, \"projects\", \"api\", \"src\", \"sample.config.ts\"),\n\t\t\t\tSAMPLE_CONFIG_TS,\n\t\t\t),\n\t\t\twriteFile(\n\t\t\t\tjoin(targetDir, \"projects\", \"api\", \"src\", \"sample.service.ts\"),\n\t\t\t\tSAMPLE_SERVICE_TS,\n\t\t\t),\n\t\t\twriteFile(join(targetDir, \"config\", \"config.yaml\"), CONFIG_YAML(name, dbOpts)),\n\t\t\twriteFile(join(targetDir, \"config\", \"config.dev.yaml\"), CONFIG_DEV_YAML),\n\t\t];\n\t\tif (opts.database === \"typeorm\") {\n\t\t\tawait mkdir(join(targetDir, \"projects\", \"api\", \"src\", \"entities\"), { recursive: true });\n\t\t\tawait mkdir(join(targetDir, \"projects\", \"api\", \"src\", \"repositories\"), {\n\t\t\t\trecursive: true,\n\t\t\t});\n\t\t\twrites.push(\n\t\t\t\twriteFile(\n\t\t\t\t\tjoin(targetDir, \"projects\", \"api\", \"src\", \"entities\", \"sample.entity.ts\"),\n\t\t\t\t\tSAMPLE_ENTITY_TS,\n\t\t\t\t),\n\t\t\t\twriteFile(\n\t\t\t\t\tjoin(targetDir, \"projects\", \"api\", \"src\", \"repositories\", \"sample.repository.ts\"),\n\t\t\t\t\tSAMPLE_REPOSITORY_TS,\n\t\t\t\t),\n\t\t\t\twriteFile(join(targetDir, \"config\", \"config.prod.yaml\"), CONFIG_PROD_YAML),\n\t\t\t);\n\t\t}\n\t\tawait Promise.all(writes);\n\t} else {\n\t\tawait mkdir(join(targetDir, \"projects\", \"app\", \"src\"), { recursive: true });\n\t\tawait Promise.all([\n\t\t\twriteFile(join(targetDir, \"package.json\"), ROOT_PACKAGE_JSON(name)),\n\t\t\twriteFile(join(targetDir, \"tsconfig.json\"), TSCONFIG),\n\t\t\twriteFile(join(targetDir, \"projects\", \"app\", \"package.json\"), APP_PACKAGE_JSON(name)),\n\t\t\twriteFile(join(targetDir, \"projects\", \"app\", \"src\", \"main.ts\"), MAIN_TS),\n\t\t]);\n\t}\n\n\tconsole.log(`\\nScaffolded ${name}. Installing dependencies...\\n`);\n\tlet pm = detectPackageManager(targetDir);\n\tif (pm == null) {\n\t\tpm = await promptForPackageManager();\n\t}\n\tawait pm.install({ cwd: targetDir });\n\n\tconsole.log(`\\nDone! Next steps:\\n`);\n\tif (basename(targetDir) !== targetDir) {\n\t\tconsole.log(`  cd ${name}`);\n\t}\n\tconsole.log(\"  pnpm build     # forge build\");\n\tconsole.log(\"  pnpm dev       # flux serve\\n\");\n}\n"],"names":["scaffold","targetDir","opts","name","basename","existsSync","readdirSync","length","yes","rl","createInterface","input","process","stdin","output","stdout","answer","question","close","trim","toLowerCase","startsWith","console","log","exit","template","dbOpts","database","undefined","mkdir","join","recursive","writes","writeFile","WEB_API_ROOT_PACKAGE_JSON","WEB_API_TSCONFIG","WEB_API_APP_PACKAGE_JSON","WEB_API_MAIN_TS","HELLO_CONTROLLER_TS","SAMPLE_CONFIG_TS","SAMPLE_SERVICE_TS","CONFIG_YAML","CONFIG_DEV_YAML","push","SAMPLE_ENTITY_TS","SAMPLE_REPOSITORY_TS","CONFIG_PROD_YAML","Promise","all","ROOT_PACKAGE_JSON","TSCONFIG","APP_PACKAGE_JSON","MAIN_TS","pm","detectPackageManager","promptForPackageManager","install","cwd"],"mappings":"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"}

package/commonjs/src/templates.js

@@ -0,0 +1,305 @@
+"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 APP_PACKAGE_JSON () {
+        return APP_PACKAGE_JSON;
+    },
+    get CONFIG_DEV_YAML () {
+        return CONFIG_DEV_YAML;
+    },
+    get CONFIG_PROD_YAML () {
+        return CONFIG_PROD_YAML;
+    },
+    get CONFIG_YAML () {
+        return CONFIG_YAML;
+    },
+    get HELLO_CONTROLLER_TS () {
+        return HELLO_CONTROLLER_TS;
+    },
+    get MAIN_TS () {
+        return MAIN_TS;
+    },
+    get ROOT_PACKAGE_JSON () {
+        return ROOT_PACKAGE_JSON;
+    },
+    get SAMPLE_CONFIG_TS () {
+        return SAMPLE_CONFIG_TS;
+    },
+    get SAMPLE_ENTITY_TS () {
+        return SAMPLE_ENTITY_TS;
+    },
+    get SAMPLE_REPOSITORY_TS () {
+        return SAMPLE_REPOSITORY_TS;
+    },
+    get SAMPLE_SERVICE_TS () {
+        return SAMPLE_SERVICE_TS;
+    },
+    get TSCONFIG () {
+        return TSCONFIG;
+    },
+    get WEB_API_APP_PACKAGE_JSON () {
+        return WEB_API_APP_PACKAGE_JSON;
+    },
+    get WEB_API_MAIN_TS () {
+        return WEB_API_MAIN_TS;
+    },
+    get WEB_API_ROOT_PACKAGE_JSON () {
+        return WEB_API_ROOT_PACKAGE_JSON;
+    },
+    get WEB_API_TSCONFIG () {
+        return WEB_API_TSCONFIG;
+    }
+});
+function ROOT_PACKAGE_JSON(name) {
+    return JSON.stringify({
+        name,
+        version: "0.0.1",
+        type: "module",
+        scripts: {
+            build: "forge build",
+            "build:watch": "forge build --watch",
+            dev: "flux serve"
+        },
+        devDependencies: {
+            "@decohere/terminal": "0.0.1-dev.14",
+            typescript: "^6.0.3"
+        }
+    }, null, 2);
+}
+function WEB_API_ROOT_PACKAGE_JSON(name, opts) {
+    const deps = {
+        "@decohere/cortex": "0.0.1-dev.15",
+        "@decohere/protocol": "0.0.1-dev.15",
+        "@decohere/scribe": "0.0.1-dev.15",
+        "@decohere/scribe-pino": "0.0.1-dev.15",
+        "pino-pretty": "^13.0.0"
+    };
+    if (opts?.database === "typeorm") {
+        deps["@decohere/codex"] = "0.0.1-dev.15";
+        deps["@decohere/codex-typeorm"] = "0.0.1-dev.15";
+    }
+    return JSON.stringify({
+        name: `${name}.api`,
+        version: "0.0.1",
+        type: "module",
+        scripts: {
+            build: "forge build",
+            "build:watch": "forge build --watch",
+            dev: "flux serve"
+        },
+        dependencies: deps,
+        devDependencies: {
+            "@decohere/terminal": "0.0.1-dev.15",
+            typescript: "^6.0.3"
+        }
+    }, null, 2);
+}
+function APP_PACKAGE_JSON(name) {
+    return JSON.stringify({
+        name: `@${name}/app`,
+        version: "0.0.1",
+        type: "module",
+        main: "src/main.ts"
+    }, null, 2);
+}
+const TSCONFIG = JSON.stringify({
+    compilerOptions: {
+        target: "ES2022",
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        strict: true,
+        skipLibCheck: true
+    },
+    include: [
+        "projects"
+    ]
+}, null, 2);
+const MAIN_TS = `console.log("Hello from Decohere!");
+`;
+const WEB_API_TSCONFIG = JSON.stringify({
+    compilerOptions: {
+        target: "ES2022",
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        strict: true,
+        skipLibCheck: true,
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true
+    },
+    include: [
+        "projects"
+    ]
+}, null, 2);
+function WEB_API_APP_PACKAGE_JSON(name) {
+    return JSON.stringify({
+        name: `@${name}/api`,
+        version: "0.0.1",
+        type: "module",
+        main: "src/main.ts",
+        dependencies: {
+            "@decohere/cortex": "0.0.1-dev.15"
+        }
+    }, null, 2);
+}
+function WEB_API_MAIN_TS(name, opts) {
+    const dbImport = opts?.database === "typeorm" ? `import "@decohere/codex-typeorm";
+import { SampleEntity } from "./entities/sample.entity.js";
+import { SampleEntityRepository } from "./repositories/sample.repository.js";
+` : "";
+    const dbChain = opts?.database === "typeorm" ? `\n\t.withTypeOrm({ entities: [SampleEntity], repositories: [SampleEntityRepository] })` : "";
+    return `import "@decohere/scribe-pino";
+import "@decohere/cortex/http";
+import "@decohere/protocol";
+${dbImport}import { Builder } from "@decohere/cortex";
+import { FastifyProvider } from "@decohere/cortex/providers";
+import { scribe } from "@decohere/scribe";
+import { YamlDataSource } from "@decohere/protocol";
+import { HelloController } from "./controllers/hello.controller.js";
+import { SampleService } from "./sample.service.js";
+
+scribe.extend.withPinoPretty();
+
+const app = await Builder.create({ applicationName: "${name}.api" })
+\t.withHttpProvider(FastifyProvider)
+\t.withConfiguration(YamlDataSource)
+\t.withServices((cb) => {
+\t\tcb.registerSingleton(SampleService);
+\t})${dbChain}
+\t.withControllers(HelloController)
+\t.build();
+
+await app.start({ port: 3000 });
+
+export default app;
+`;
+}
+const HELLO_CONTROLLER_TS = `import { Controller, Delete, Field, Get, Param, Post, Put, Query } from "@decohere/cortex";
+import { SampleService } from "../sample.service.js";
+
+class HelloBody {
+	@Field("body", "message")
+	public message!: string;
+}
+
+@Controller({ prefix: "/hello" })
+export class HelloController {
+	public constructor(private readonly sample: SampleService) {}
+
+	@Get()
+	public async getAll(@Query("filter") filter: string) {
+		const greeting = await this.sample.getGreeting();
+		return { filter, message: greeting };
+	}
+
+	@Get("/:id")
+	public getOne(@Param("id") id: string) {
+		return { id, message: \`Hello \${id}!\` };
+	}
+
+	@Post("/")
+	public create(body: HelloBody) {
+		return { message: body.message };
+	}
+
+	@Put("/:id")
+	public update(@Param("id") id: string, body: HelloBody) {
+		return { id, message: body.message };
+	}
+
+	@Delete("/:id")
+	public remove(@Param("id") id: string) {
+		return { id, deleted: true };
+	}
+}
+`;
+const SAMPLE_CONFIG_TS = `export class SampleConfig {
+	public greeting: string = "";
+}
+`;
+const SAMPLE_SERVICE_TS = `import { inject, injectable } from "@decohere/crucible/decorators";
+import { ConfigurationServiceToken } from "@decohere/nexus/configuration";
+import type { IConfigurationService } from "@decohere/nexus/configuration";
+import { SampleConfig } from "./sample.config.js";
+
+@injectable()
+export class SampleService {
+	public constructor(
+		@inject(ConfigurationServiceToken) private readonly config: IConfigurationService,
+	) {}
+
+	public async getGreeting(): Promise<string> {
+		const config = await this.config.get(SampleConfig);
+		return config.greeting;
+	}
+}
+`;
+function CONFIG_YAML(name, opts) {
+    const dbSection = opts?.database === "typeorm" ? `database:
+  dataSources:
+    - name: default
+      provider: postgres
+      host: localhost
+      port: 5432
+      database: ${name}_dev
+      username: postgres
+      password: postgres
+      synchronize: true
+      seed: false
+      adminUser: postgres
+      adminPassword: postgres
+` : "";
+    return `sample:
+  greeting: Hello from configuration!
+${dbSection}`;
+}
+const CONFIG_DEV_YAML = `sample:
+  greeting: Hello from dev configuration!
+`;
+const CONFIG_PROD_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}
+`;
+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}
+}
+`;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/templates.ts"],"sourcesContent":["export function ROOT_PACKAGE_JSON(name: string): string {\n\treturn JSON.stringify(\n\t\t{\n\t\t\tname,\n\t\t\tversion: \"0.0.1\",\n\t\t\ttype: \"module\",\n\t\t\tscripts: {\n\t\t\t\tbuild: \"forge build\",\n\t\t\t\t\"build:watch\": \"forge build --watch\",\n\t\t\t\tdev: \"flux serve\",\n\t\t\t},\n\t\t\tdevDependencies: {\n\t\t\t\t\"@decohere/terminal\": \"0.0.1-dev.14\",\n\t\t\t\ttypescript: \"^6.0.3\",\n\t\t\t},\n\t\t},\n\t\tnull,\n\t\t2,\n\t);\n}\n\nexport type DatabaseProvider = \"typeorm\";\n\nexport type WebApiOptions = {\n\tdatabase?: DatabaseProvider;\n};\n\nexport function WEB_API_ROOT_PACKAGE_JSON(name: string, opts?: WebApiOptions): string {\n\tconst deps: Record<string, string> = {\n\t\t\"@decohere/cortex\": \"0.0.1-dev.15\",\n\t\t\"@decohere/protocol\": \"0.0.1-dev.15\",\n\t\t\"@decohere/scribe\": \"0.0.1-dev.15\",\n\t\t\"@decohere/scribe-pino\": \"0.0.1-dev.15\",\n\t\t\"pino-pretty\": \"^13.0.0\",\n\t};\n\tif (opts?.database === \"typeorm\") {\n\t\tdeps[\"@decohere/codex\"] = \"0.0.1-dev.15\";\n\t\tdeps[\"@decohere/codex-typeorm\"] = \"0.0.1-dev.15\";\n\t}\n\treturn JSON.stringify(\n\t\t{\n\t\t\tname: `${name}.api`,\n\t\t\tversion: \"0.0.1\",\n\t\t\ttype: \"module\",\n\t\t\tscripts: {\n\t\t\t\tbuild: \"forge build\",\n\t\t\t\t\"build:watch\": \"forge build --watch\",\n\t\t\t\tdev: \"flux serve\",\n\t\t\t},\n\t\t\tdependencies: deps,\n\t\t\tdevDependencies: {\n\t\t\t\t\"@decohere/terminal\": \"0.0.1-dev.15\",\n\t\t\t\ttypescript: \"^6.0.3\",\n\t\t\t},\n\t\t},\n\t\tnull,\n\t\t2,\n\t);\n}\n\nexport function APP_PACKAGE_JSON(name: string): string {\n\treturn JSON.stringify(\n\t\t{\n\t\t\tname: `@${name}/app`,\n\t\t\tversion: \"0.0.1\",\n\t\t\ttype: \"module\",\n\t\t\tmain: \"src/main.ts\",\n\t\t},\n\t\tnull,\n\t\t2,\n\t);\n}\n\nexport const TSCONFIG = JSON.stringify(\n\t{\n\t\tcompilerOptions: {\n\t\t\ttarget: \"ES2022\",\n\t\t\tmodule: \"NodeNext\",\n\t\t\tmoduleResolution: \"NodeNext\",\n\t\t\tstrict: true,\n\t\t\tskipLibCheck: true,\n\t\t},\n\t\tinclude: [\"projects\"],\n\t},\n\tnull,\n\t2,\n);\n\nexport const MAIN_TS = `console.log(\"Hello from Decohere!\");\n`;\n\nexport const WEB_API_TSCONFIG = JSON.stringify(\n\t{\n\t\tcompilerOptions: {\n\t\t\ttarget: \"ES2022\",\n\t\t\tmodule: \"NodeNext\",\n\t\t\tmoduleResolution: \"NodeNext\",\n\t\t\tstrict: true,\n\t\t\tskipLibCheck: true,\n\t\t\texperimentalDecorators: true,\n\t\t\temitDecoratorMetadata: true,\n\t\t},\n\t\tinclude: [\"projects\"],\n\t},\n\tnull,\n\t2,\n);\n\nexport function WEB_API_APP_PACKAGE_JSON(name: string): string {\n\treturn JSON.stringify(\n\t\t{\n\t\t\tname: `@${name}/api`,\n\t\t\tversion: \"0.0.1\",\n\t\t\ttype: \"module\",\n\t\t\tmain: \"src/main.ts\",\n\t\t\tdependencies: {\n\t\t\t\t\"@decohere/cortex\": \"0.0.1-dev.15\",\n\t\t\t},\n\t\t},\n\t\tnull,\n\t\t2,\n\t);\n}\n\nexport function WEB_API_MAIN_TS(name: string, opts?: WebApiOptions): string {\n\tconst dbImport =\n\t\topts?.database === \"typeorm\"\n\t\t\t? `import \"@decohere/codex-typeorm\";\nimport { SampleEntity } from \"./entities/sample.entity.js\";\nimport { SampleEntityRepository } from \"./repositories/sample.repository.js\";\n`\n\t\t\t: \"\";\n\tconst dbChain =\n\t\topts?.database === \"typeorm\"\n\t\t\t? `\\n\\t.withTypeOrm({ entities: [SampleEntity], repositories: [SampleEntityRepository] })`\n\t\t\t: \"\";\n\treturn `import \"@decohere/scribe-pino\";\nimport \"@decohere/cortex/http\";\nimport \"@decohere/protocol\";\n${dbImport}import { Builder } from \"@decohere/cortex\";\nimport { FastifyProvider } from \"@decohere/cortex/providers\";\nimport { scribe } from \"@decohere/scribe\";\nimport { YamlDataSource } from \"@decohere/protocol\";\nimport { HelloController } from \"./controllers/hello.controller.js\";\nimport { SampleService } from \"./sample.service.js\";\n\nscribe.extend.withPinoPretty();\n\nconst app = await Builder.create({ applicationName: \"${name}.api\" })\n\\t.withHttpProvider(FastifyProvider)\n\\t.withConfiguration(YamlDataSource)\n\\t.withServices((cb) => {\n\\t\\tcb.registerSingleton(SampleService);\n\\t})${dbChain}\n\\t.withControllers(HelloController)\n\\t.build();\n\nawait app.start({ port: 3000 });\n\nexport default app;\n`;\n}\n\nexport const HELLO_CONTROLLER_TS = `import { Controller, Delete, Field, Get, Param, Post, Put, Query } from \"@decohere/cortex\";\nimport { SampleService } from \"../sample.service.js\";\n\nclass HelloBody {\n\t@Field(\"body\", \"message\")\n\tpublic message!: string;\n}\n\n@Controller({ prefix: \"/hello\" })\nexport class HelloController {\n\tpublic constructor(private readonly sample: SampleService) {}\n\n\t@Get()\n\tpublic async getAll(@Query(\"filter\") filter: string) {\n\t\tconst greeting = await this.sample.getGreeting();\n\t\treturn { filter, message: greeting };\n\t}\n\n\t@Get(\"/:id\")\n\tpublic getOne(@Param(\"id\") id: string) {\n\t\treturn { id, message: \\`Hello \\${id}!\\` };\n\t}\n\n\t@Post(\"/\")\n\tpublic create(body: HelloBody) {\n\t\treturn { message: body.message };\n\t}\n\n\t@Put(\"/:id\")\n\tpublic update(@Param(\"id\") id: string, body: HelloBody) {\n\t\treturn { id, message: body.message };\n\t}\n\n\t@Delete(\"/:id\")\n\tpublic remove(@Param(\"id\") id: string) {\n\t\treturn { id, deleted: true };\n\t}\n}\n`;\n\nexport const SAMPLE_CONFIG_TS = `export class SampleConfig {\n\tpublic greeting: string = \"\";\n}\n`;\n\nexport const SAMPLE_SERVICE_TS = `import { inject, injectable } from \"@decohere/crucible/decorators\";\nimport { ConfigurationServiceToken } from \"@decohere/nexus/configuration\";\nimport type { IConfigurationService } from \"@decohere/nexus/configuration\";\nimport { SampleConfig } from \"./sample.config.js\";\n\n@injectable()\nexport class SampleService {\n\tpublic constructor(\n\t\t@inject(ConfigurationServiceToken) private readonly config: IConfigurationService,\n\t) {}\n\n\tpublic async getGreeting(): Promise<string> {\n\t\tconst config = await this.config.get(SampleConfig);\n\t\treturn config.greeting;\n\t}\n}\n`;\n\nexport function CONFIG_YAML(name: string, opts?: WebApiOptions): string {\n\tconst dbSection =\n\t\topts?.database === \"typeorm\"\n\t\t\t? `database:\n  dataSources:\n    - name: default\n      provider: postgres\n      host: localhost\n      port: 5432\n      database: ${name}_dev\n      username: postgres\n      password: postgres\n      synchronize: true\n      seed: false\n      adminUser: postgres\n      adminPassword: postgres\n`\n\t\t\t: \"\";\n\treturn `sample:\n  greeting: Hello from configuration!\n${dbSection}`;\n}\n\nexport const CONFIG_DEV_YAML = `sample:\n  greeting: Hello from dev configuration!\n`;\n\nexport const CONFIG_PROD_YAML = `database:\n  dataSources:\n    - name: default\n      provider: postgres\n      host: \\${DB_HOST}\n      port: \\${DB_PORT}\n      database: \\${DB_NAME}\n      username: \\${DB_USER}\n      password: \\${DB_PASSWORD}\n      synchronize: false\n      seed: false\n      adminUser: \\${DB_ADMIN_USER}\n      adminPassword: \\${DB_ADMIN_PASSWORD}\n`;\n\nexport const SAMPLE_ENTITY_TS = `import { Column, Entity, PrimaryGeneratedColumn } from \"typeorm\";\nimport type { Entity as IEntity } from \"@decohere/codex\";\n\n@Entity()\nexport class SampleEntity implements IEntity {\n\\t@PrimaryGeneratedColumn()\n\\tpublic id!: number;\n\n\\t@Column()\n\\tpublic name!: string;\n}\n`;\n\nexport const SAMPLE_REPOSITORY_TS = `import { injectable } from \"@decohere/crucible/decorators\";\nimport { injectUnitOfWork } from \"@decohere/codex\";\nimport { TypeOrmRepository, TypeOrmUnitOfWork } from \"@decohere/codex-typeorm\";\nimport { SampleEntity } from \"../entities/sample.entity.js\";\n\n@injectable()\nexport class SampleEntityRepository extends TypeOrmRepository<SampleEntity> {\n\\tpublic constructor(@injectUnitOfWork() unitOfWork: TypeOrmUnitOfWork) {\n\\t\\tsuper(unitOfWork, SampleEntity);\n\\t}\n}\n`;\n"],"names":["APP_PACKAGE_JSON","CONFIG_DEV_YAML","CONFIG_PROD_YAML","CONFIG_YAML","HELLO_CONTROLLER_TS","MAIN_TS","ROOT_PACKAGE_JSON","SAMPLE_CONFIG_TS","SAMPLE_ENTITY_TS","SAMPLE_REPOSITORY_TS","SAMPLE_SERVICE_TS","TSCONFIG","WEB_API_APP_PACKAGE_JSON","WEB_API_MAIN_TS","WEB_API_ROOT_PACKAGE_JSON","WEB_API_TSCONFIG","name","JSON","stringify","version","type","scripts","build","dev","devDependencies","typescript","opts","deps","database","dependencies","main","compilerOptions","target","module","moduleResolution","strict","skipLibCheck","include","experimentalDecorators","emitDecoratorMetadata","dbImport","dbChain","dbSection"],"mappings":"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"}

package/es6/src/cli.js

@@ -1,3 +1,11 @@
 #!/usr/bin/env node
-import { runInBuilder } from "./runner.js";
-runInBuilder(process.argv.slice(2));
+import { resolve } from "node:path";
+import { Command } from "commander";
+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.parse();
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvY2xpLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIiMhL3Vzci9iaW4vZW52IG5vZGVcbmltcG9ydCB7IHJlc29sdmUgfSBmcm9tIFwibm9kZTpwYXRoXCI7XG5pbXBvcnQgeyBDb21tYW5kIH0gZnJvbSBcImNvbW1hbmRlclwiO1xuaW1wb3J0IHsgc2NhZmZvbGQgfSBmcm9tIFwiLi9zY2FmZm9sZC5qc1wiO1xuXG5jb25zdCBwcm9ncmFtID0gbmV3IENvbW1hbmQoKTtcblxucHJvZ3JhbVxuXHQubmFtZShcImRlY29oZXJlXCIpXG5cdC5kZXNjcmlwdGlvbihcIlNjYWZmb2xkIGEgbmV3IERlY29oZXJlIHByb2plY3RcIilcblx0LmFyZ3VtZW50KFwiW2RpcmVjdG9yeV1cIiwgXCJUYXJnZXQgZGlyZWN0b3J5IChkZWZhdWx0OiBjdXJyZW50IGRpcmVjdG9yeSlcIiwgXCIuXCIpXG5cdC5vcHRpb24oXCIteSwgLS15ZXNcIiwgXCJTa2lwIGNvbmZpcm1hdGlvbiBwcm9tcHRzXCIpXG5cdC5vcHRpb24oXCItdCwgLS10ZW1wbGF0ZSA8dGVtcGxhdGU+XCIsIFwiUHJvamVjdCB0ZW1wbGF0ZTogYmFzaWMgKGRlZmF1bHQpIG9yIHdlYmFwaVwiLCBcImJhc2ljXCIpXG5cdC5vcHRpb24oXCItZCwgLS1kYXRhYmFzZSA8cHJvdmlkZXI+XCIsIFwiRGF0YWJhc2UgcHJvdmlkZXIgdG8gaW5jbHVkZSAod2ViYXBpIG9ubHkpOiB0eXBlb3JtXCIpXG5cdC5hY3Rpb24oXG5cdFx0YXN5bmMgKFxuXHRcdFx0ZGlyZWN0b3J5OiBzdHJpbmcsXG5cdFx0XHRvcHRzOiB7IHllcz86IGJvb2xlYW47IHRlbXBsYXRlPzogXCJiYXNpY1wiIHwgXCJ3ZWJhcGlcIjsgZGF0YWJhc2U/OiBcInR5cGVvcm1cIiB9LFxuXHRcdCkgPT4ge1xuXHRcdFx0YXdhaXQgc2NhZmZvbGQocmVzb2x2ZShkaXJlY3RvcnkpLCBvcHRzKTtcblx0XHR9LFxuXHQpO1xuXG5wcm9ncmFtLnBhcnNlKCk7XG4iXSwibmFtZXMiOlsicmVzb2x2ZSIsIkNvbW1hbmQiLCJzY2FmZm9sZCIsInByb2dyYW0iLCJuYW1lIiwiZGVzY3JpcHRpb24iLCJhcmd1bWVudCIsIm9wdGlvbiIsImFjdGlvbiIsImRpcmVjdG9yeSIsIm9wdHMiLCJwYXJzZSJdLCJtYXBwaW5ncyI6IjtBQUNBLFNBQVNBLE9BQU8sUUFBUSxZQUFZO0FBQ3BDLFNBQVNDLE9BQU8sUUFBUSxZQUFZO0FBQ3BDLFNBQVNDLFFBQVEsUUFBUSxnQkFBZ0I7QUFFekMsTUFBTUMsVUFBVSxJQUFJRjtBQUVwQkUsUUFDRUMsSUFBSSxDQUFDLFlBQ0xDLFdBQVcsQ0FBQyxtQ0FDWkMsUUFBUSxDQUFDLGVBQWUsaURBQWlELEtBQ3pFQyxNQUFNLENBQUMsYUFBYSw2QkFDcEJBLE1BQU0sQ0FBQyw2QkFBNkIsK0NBQStDLFNBQ25GQSxNQUFNLENBQUMsNkJBQTZCLHVEQUNwQ0MsTUFBTSxDQUNOLE9BQ0NDLFdBQ0FDO0lBRUEsTUFBTVIsU0FBU0YsUUFBUVMsWUFBWUM7QUFDcEM7QUFHRlAsUUFBUVEsS0FBSyJ9

package/es6/src/scaffold.js

@@ -0,0 +1,79 @@
+import { existsSync, readdirSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { detectPackageManager, promptForPackageManager } from "@decohere/nexus/interop";
+import { APP_PACKAGE_JSON, CONFIG_DEV_YAML, CONFIG_PROD_YAML, CONFIG_YAML, HELLO_CONTROLLER_TS, MAIN_TS, ROOT_PACKAGE_JSON, SAMPLE_CONFIG_TS, SAMPLE_ENTITY_TS, SAMPLE_REPOSITORY_TS, SAMPLE_SERVICE_TS, TSCONFIG, WEB_API_APP_PACKAGE_JSON, WEB_API_MAIN_TS, WEB_API_ROOT_PACKAGE_JSON, WEB_API_TSCONFIG } from "./templates.js";
+export async function scaffold(targetDir, opts) {
+    const name = basename(targetDir);
+    if (existsSync(targetDir) && readdirSync(targetDir).length > 0 && !opts.yes) {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        const answer = await rl.question(`Directory "${name}" is not empty. Continue? [y/N] `);
+        rl.close();
+        if (!answer.trim().toLowerCase().startsWith("y")) {
+            console.log("Aborted.");
+            process.exit(0);
+        }
+    }
+    if (opts.template === "webapi") {
+        const dbOpts = opts.database ? {
+            database: opts.database
+        } : undefined;
+        await mkdir(join(targetDir, "projects", "api", "src", "controllers"), {
+            recursive: true
+        });
+        await mkdir(join(targetDir, "config"), {
+            recursive: true
+        });
+        const writes = [
+            writeFile(join(targetDir, "package.json"), WEB_API_ROOT_PACKAGE_JSON(name, dbOpts)),
+            writeFile(join(targetDir, "tsconfig.json"), WEB_API_TSCONFIG),
+            writeFile(join(targetDir, "projects", "api", "package.json"), WEB_API_APP_PACKAGE_JSON(name)),
+            writeFile(join(targetDir, "projects", "api", "src", "main.ts"), WEB_API_MAIN_TS(name, dbOpts)),
+            writeFile(join(targetDir, "projects", "api", "src", "controllers", "hello.controller.ts"), HELLO_CONTROLLER_TS),
+            writeFile(join(targetDir, "projects", "api", "src", "sample.config.ts"), SAMPLE_CONFIG_TS),
+            writeFile(join(targetDir, "projects", "api", "src", "sample.service.ts"), SAMPLE_SERVICE_TS),
+            writeFile(join(targetDir, "config", "config.yaml"), CONFIG_YAML(name, dbOpts)),
+            writeFile(join(targetDir, "config", "config.dev.yaml"), CONFIG_DEV_YAML)
+        ];
+        if (opts.database === "typeorm") {
+            await mkdir(join(targetDir, "projects", "api", "src", "entities"), {
+                recursive: true
+            });
+            await mkdir(join(targetDir, "projects", "api", "src", "repositories"), {
+                recursive: true
+            });
+            writes.push(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), writeFile(join(targetDir, "config", "config.prod.yaml"), CONFIG_PROD_YAML));
+        }
+        await Promise.all(writes);
+    } else {
+        await mkdir(join(targetDir, "projects", "app", "src"), {
+            recursive: true
+        });
+        await Promise.all([
+            writeFile(join(targetDir, "package.json"), ROOT_PACKAGE_JSON(name)),
+            writeFile(join(targetDir, "tsconfig.json"), TSCONFIG),
+            writeFile(join(targetDir, "projects", "app", "package.json"), APP_PACKAGE_JSON(name)),
+            writeFile(join(targetDir, "projects", "app", "src", "main.ts"), MAIN_TS)
+        ]);
+    }
+    console.log(`\nScaffolded ${name}. Installing dependencies...\n`);
+    let pm = detectPackageManager(targetDir);
+    if (pm == null) {
+        pm = await promptForPackageManager();
+    }
+    await pm.install({
+        cwd: targetDir
+    });
+    console.log(`\nDone! Next steps:\n`);
+    if (basename(targetDir) !== targetDir) {
+        console.log(`  cd ${name}`);
+    }
+    console.log("  pnpm build     # forge build");
+    console.log("  pnpm dev       # flux serve\n");
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/scaffold.ts"],"sourcesContent":["import { existsSync, readdirSync } from \"node:fs\";\nimport { mkdir, writeFile } from \"node:fs/promises\";\nimport { basename, join } from \"node:path\";\nimport { createInterface } from \"node:readline/promises\";\nimport { detectPackageManager, promptForPackageManager } from \"@decohere/nexus/interop\";\nimport {\n\tAPP_PACKAGE_JSON,\n\tCONFIG_DEV_YAML,\n\tCONFIG_PROD_YAML,\n\tCONFIG_YAML,\n\tHELLO_CONTROLLER_TS,\n\tMAIN_TS,\n\tROOT_PACKAGE_JSON,\n\tSAMPLE_CONFIG_TS,\n\tSAMPLE_ENTITY_TS,\n\tSAMPLE_REPOSITORY_TS,\n\tSAMPLE_SERVICE_TS,\n\tTSCONFIG,\n\tWEB_API_APP_PACKAGE_JSON,\n\tWEB_API_MAIN_TS,\n\tWEB_API_ROOT_PACKAGE_JSON,\n\tWEB_API_TSCONFIG,\n} from \"./templates.js\";\n\nexport interface ScaffoldOptions {\n\tyes?: boolean;\n\ttemplate?: \"basic\" | \"webapi\";\n\tdatabase?: \"typeorm\";\n}\n\nexport async function scaffold(targetDir: string, opts: ScaffoldOptions): Promise<void> {\n\tconst name = basename(targetDir);\n\n\tif (existsSync(targetDir) && readdirSync(targetDir).length > 0 && !opts.yes) {\n\t\tconst rl = createInterface({\n\t\t\tinput: process.stdin,\n\t\t\toutput: process.stdout,\n\t\t});\n\t\tconst answer = await rl.question(`Directory \"${name}\" is not empty. Continue? [y/N] `);\n\t\trl.close();\n\t\tif (!answer.trim().toLowerCase().startsWith(\"y\")) {\n\t\t\tconsole.log(\"Aborted.\");\n\t\t\tprocess.exit(0);\n\t\t}\n\t}\n\n\tif (opts.template === \"webapi\") {\n\t\tconst dbOpts = opts.database ? { database: opts.database } : undefined;\n\t\tawait mkdir(join(targetDir, \"projects\", \"api\", \"src\", \"controllers\"), { recursive: true });\n\t\tawait mkdir(join(targetDir, \"config\"), { recursive: true });\n\t\tconst writes = [\n\t\t\twriteFile(join(targetDir, \"package.json\"), WEB_API_ROOT_PACKAGE_JSON(name, dbOpts)),\n\t\t\twriteFile(join(targetDir, \"tsconfig.json\"), WEB_API_TSCONFIG),\n\t\t\twriteFile(\n\t\t\t\tjoin(targetDir, \"projects\", \"api\", \"package.json\"),\n\t\t\t\tWEB_API_APP_PACKAGE_JSON(name),\n\t\t\t),\n\t\t\twriteFile(\n\t\t\t\tjoin(targetDir, \"projects\", \"api\", \"src\", \"main.ts\"),\n\t\t\t\tWEB_API_MAIN_TS(name, dbOpts),\n\t\t\t),\n\t\t\twriteFile(\n\t\t\t\tjoin(targetDir, \"projects\", \"api\", \"src\", \"controllers\", \"hello.controller.ts\"),\n\t\t\t\tHELLO_CONTROLLER_TS,\n\t\t\t),\n\t\t\twriteFile(\n\t\t\t\tjoin(targetDir, \"projects\", \"api\", \"src\", \"sample.config.ts\"),\n\t\t\t\tSAMPLE_CONFIG_TS,\n\t\t\t),\n\t\t\twriteFile(\n\t\t\t\tjoin(targetDir, \"projects\", \"api\", \"src\", \"sample.service.ts\"),\n\t\t\t\tSAMPLE_SERVICE_TS,\n\t\t\t),\n\t\t\twriteFile(join(targetDir, \"config\", \"config.yaml\"), CONFIG_YAML(name, dbOpts)),\n\t\t\twriteFile(join(targetDir, \"config\", \"config.dev.yaml\"), CONFIG_DEV_YAML),\n\t\t];\n\t\tif (opts.database === \"typeorm\") {\n\t\t\tawait mkdir(join(targetDir, \"projects\", \"api\", \"src\", \"entities\"), { recursive: true });\n\t\t\tawait mkdir(join(targetDir, \"projects\", \"api\", \"src\", \"repositories\"), {\n\t\t\t\trecursive: true,\n\t\t\t});\n\t\t\twrites.push(\n\t\t\t\twriteFile(\n\t\t\t\t\tjoin(targetDir, \"projects\", \"api\", \"src\", \"entities\", \"sample.entity.ts\"),\n\t\t\t\t\tSAMPLE_ENTITY_TS,\n\t\t\t\t),\n\t\t\t\twriteFile(\n\t\t\t\t\tjoin(targetDir, \"projects\", \"api\", \"src\", \"repositories\", \"sample.repository.ts\"),\n\t\t\t\t\tSAMPLE_REPOSITORY_TS,\n\t\t\t\t),\n\t\t\t\twriteFile(join(targetDir, \"config\", \"config.prod.yaml\"), CONFIG_PROD_YAML),\n\t\t\t);\n\t\t}\n\t\tawait Promise.all(writes);\n\t} else {\n\t\tawait mkdir(join(targetDir, \"projects\", \"app\", \"src\"), { recursive: true });\n\t\tawait Promise.all([\n\t\t\twriteFile(join(targetDir, \"package.json\"), ROOT_PACKAGE_JSON(name)),\n\t\t\twriteFile(join(targetDir, \"tsconfig.json\"), TSCONFIG),\n\t\t\twriteFile(join(targetDir, \"projects\", \"app\", \"package.json\"), APP_PACKAGE_JSON(name)),\n\t\t\twriteFile(join(targetDir, \"projects\", \"app\", \"src\", \"main.ts\"), MAIN_TS),\n\t\t]);\n\t}\n\n\tconsole.log(`\\nScaffolded ${name}. Installing dependencies...\\n`);\n\tlet pm = detectPackageManager(targetDir);\n\tif (pm == null) {\n\t\tpm = await promptForPackageManager();\n\t}\n\tawait pm.install({ cwd: targetDir });\n\n\tconsole.log(`\\nDone! Next steps:\\n`);\n\tif (basename(targetDir) !== targetDir) {\n\t\tconsole.log(`  cd ${name}`);\n\t}\n\tconsole.log(\"  pnpm build     # forge build\");\n\tconsole.log(\"  pnpm dev       # flux serve\\n\");\n}\n"],"names":["existsSync","readdirSync","mkdir","writeFile","basename","join","createInterface","detectPackageManager","promptForPackageManager","APP_PACKAGE_JSON","CONFIG_DEV_YAML","CONFIG_PROD_YAML","CONFIG_YAML","HELLO_CONTROLLER_TS","MAIN_TS","ROOT_PACKAGE_JSON","SAMPLE_CONFIG_TS","SAMPLE_ENTITY_TS","SAMPLE_REPOSITORY_TS","SAMPLE_SERVICE_TS","TSCONFIG","WEB_API_APP_PACKAGE_JSON","WEB_API_MAIN_TS","WEB_API_ROOT_PACKAGE_JSON","WEB_API_TSCONFIG","scaffold","targetDir","opts","name","length","yes","rl","input","process","stdin","output","stdout","answer","question","close","trim","toLowerCase","startsWith","console","log","exit","template","dbOpts","database","undefined","recursive","writes","push","Promise","all","pm","install","cwd"],"mappings":"AAAA,SAASA,UAAU,EAAEC,WAAW,QAAQ,UAAU;AAClD,SAASC,KAAK,EAAEC,SAAS,QAAQ,mBAAmB;AACpD,SAASC,QAAQ,EAAEC,IAAI,QAAQ,YAAY;AAC3C,SAASC,eAAe,QAAQ,yBAAyB;AACzD,SAASC,oBAAoB,EAAEC,uBAAuB,QAAQ,0BAA0B;AACxF,SACCC,gBAAgB,EAChBC,eAAe,EACfC,gBAAgB,EAChBC,WAAW,EACXC,mBAAmB,EACnBC,OAAO,EACPC,iBAAiB,EACjBC,gBAAgB,EAChBC,gBAAgB,EAChBC,oBAAoB,EACpBC,iBAAiB,EACjBC,QAAQ,EACRC,wBAAwB,EACxBC,eAAe,EACfC,yBAAyB,EACzBC,gBAAgB,QACV,iBAAiB;AAQxB,OAAO,eAAeC,SAASC,SAAiB,EAAEC,IAAqB;IACtE,MAAMC,OAAOxB,SAASsB;IAEtB,IAAI1B,WAAW0B,cAAczB,YAAYyB,WAAWG,MAAM,GAAG,KAAK,CAACF,KAAKG,GAAG,EAAE;QAC5E,MAAMC,KAAKzB,gBAAgB;YAC1B0B,OAAOC,QAAQC,KAAK;YACpBC,QAAQF,QAAQG,MAAM;QACvB;QACA,MAAMC,SAAS,MAAMN,GAAGO,QAAQ,CAAC,CAAC,WAAW,EAAEV,KAAK,gCAAgC,CAAC;QACrFG,GAAGQ,KAAK;QACR,IAAI,CAACF,OAAOG,IAAI,GAAGC,WAAW,GAAGC,UAAU,CAAC,MAAM;YACjDC,QAAQC,GAAG,CAAC;YACZX,QAAQY,IAAI,CAAC;QACd;IACD;IAEA,IAAIlB,KAAKmB,QAAQ,KAAK,UAAU;QAC/B,MAAMC,SAASpB,KAAKqB,QAAQ,GAAG;YAAEA,UAAUrB,KAAKqB,QAAQ;QAAC,IAAIC;QAC7D,MAAM/C,MAAMG,KAAKqB,WAAW,YAAY,OAAO,OAAO,gBAAgB;YAAEwB,WAAW;QAAK;QACxF,MAAMhD,MAAMG,KAAKqB,WAAW,WAAW;YAAEwB,WAAW;QAAK;QACzD,MAAMC,SAAS;YACdhD,UAAUE,KAAKqB,WAAW,iBAAiBH,0BAA0BK,MAAMmB;YAC3E5C,UAAUE,KAAKqB,WAAW,kBAAkBF;YAC5CrB,UACCE,KAAKqB,WAAW,YAAY,OAAO,iBACnCL,yBAAyBO;YAE1BzB,UACCE,KAAKqB,WAAW,YAAY,OAAO,OAAO,YAC1CJ,gBAAgBM,MAAMmB;YAEvB5C,UACCE,KAAKqB,WAAW,YAAY,OAAO,OAAO,eAAe,wBACzDb;YAEDV,UACCE,KAAKqB,WAAW,YAAY,OAAO,OAAO,qBAC1CV;YAEDb,UACCE,KAAKqB,WAAW,YAAY,OAAO,OAAO,sBAC1CP;YAEDhB,UAAUE,KAAKqB,WAAW,UAAU,gBAAgBd,YAAYgB,MAAMmB;YACtE5C,UAAUE,KAAKqB,WAAW,UAAU,oBAAoBhB;SACxD;QACD,IAAIiB,KAAKqB,QAAQ,KAAK,WAAW;YAChC,MAAM9C,MAAMG,KAAKqB,WAAW,YAAY,OAAO,OAAO,aAAa;gBAAEwB,WAAW;YAAK;YACrF,MAAMhD,MAAMG,KAAKqB,WAAW,YAAY,OAAO,OAAO,iBAAiB;gBACtEwB,WAAW;YACZ;YACAC,OAAOC,IAAI,CACVjD,UACCE,KAAKqB,WAAW,YAAY,OAAO,OAAO,YAAY,qBACtDT,mBAEDd,UACCE,KAAKqB,WAAW,YAAY,OAAO,OAAO,gBAAgB,yBAC1DR,uBAEDf,UAAUE,KAAKqB,WAAW,UAAU,qBAAqBf;QAE3D;QACA,MAAM0C,QAAQC,GAAG,CAACH;IACnB,OAAO;QACN,MAAMjD,MAAMG,KAAKqB,WAAW,YAAY,OAAO,QAAQ;YAAEwB,WAAW;QAAK;QACzE,MAAMG,QAAQC,GAAG,CAAC;YACjBnD,UAAUE,KAAKqB,WAAW,iBAAiBX,kBAAkBa;YAC7DzB,UAAUE,KAAKqB,WAAW,kBAAkBN;YAC5CjB,UAAUE,KAAKqB,WAAW,YAAY,OAAO,iBAAiBjB,iBAAiBmB;YAC/EzB,UAAUE,KAAKqB,WAAW,YAAY,OAAO,OAAO,YAAYZ;SAChE;IACF;IAEA6B,QAAQC,GAAG,CAAC,CAAC,aAAa,EAAEhB,KAAK,8BAA8B,CAAC;IAChE,IAAI2B,KAAKhD,qBAAqBmB;IAC9B,IAAI6B,MAAM,MAAM;QACfA,KAAK,MAAM/C;IACZ;IACA,MAAM+C,GAAGC,OAAO,CAAC;QAAEC,KAAK/B;IAAU;IAElCiB,QAAQC,GAAG,CAAC,CAAC,qBAAqB,CAAC;IACnC,IAAIxC,SAASsB,eAAeA,WAAW;QACtCiB,QAAQC,GAAG,CAAC,CAAC,KAAK,EAAEhB,MAAM;IAC3B;IACAe,QAAQC,GAAG,CAAC;IACZD,QAAQC,GAAG,CAAC;AACb"}