@decohere/create 0.0.1-dev.15 → 0.0.1-dev.17

package/commonjs/src/cli.js

@@ -7,9 +7,9 @@ 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").action(async (directory, opts)=>{
+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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvY2xpLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIiMhL3Vzci9iaW4vZW52IG5vZGVcbmltcG9ydCB7IHJlc29sdmUgfSBmcm9tIFwibm9kZTpwYXRoXCI7XG5pbXBvcnQgeyBDb21tYW5kIH0gZnJvbSBcImNvbW1hbmRlclwiO1xuaW1wb3J0IHsgc2NhZmZvbGQgfSBmcm9tIFwiLi9zY2FmZm9sZC5qc1wiO1xuXG5jb25zdCBwcm9ncmFtID0gbmV3IENvbW1hbmQoKTtcblxucHJvZ3JhbVxuXHQubmFtZShcImRlY29oZXJlXCIpXG5cdC5kZXNjcmlwdGlvbihcIlNjYWZmb2xkIGEgbmV3IERlY29oZXJlIHByb2plY3RcIilcblx0LmFyZ3VtZW50KFwiW2RpcmVjdG9yeV1cIiwgXCJUYXJnZXQgZGlyZWN0b3J5IChkZWZhdWx0OiBjdXJyZW50IGRpcmVjdG9yeSlcIiwgXCIuXCIpXG5cdC5vcHRpb24oXCIteSwgLS15ZXNcIiwgXCJTa2lwIGNvbmZpcm1hdGlvbiBwcm9tcHRzXCIpXG5cdC5hY3Rpb24oYXN5bmMgKGRpcmVjdG9yeTogc3RyaW5nLCBvcHRzOiB7IHllcz86IGJvb2xlYW4gfSkgPT4ge1xuXHRcdGF3YWl0IHNjYWZmb2xkKHJlc29sdmUoZGlyZWN0b3J5KSwgb3B0cyk7XG5cdH0pO1xuXG5wcm9ncmFtLnBhcnNlKCk7XG4iXSwibmFtZXMiOlsicHJvZ3JhbSIsIkNvbW1hbmQiLCJuYW1lIiwiZGVzY3JpcHRpb24iLCJhcmd1bWVudCIsIm9wdGlvbiIsImFjdGlvbiIsImRpcmVjdG9yeSIsIm9wdHMiLCJzY2FmZm9sZCIsInJlc29sdmUiLCJwYXJzZSJdLCJtYXBwaW5ncyI6Ijs7Ozs7MEJBQ3dCOzJCQUNBOzBCQUNDO0FBRXpCLE1BQU1BLFVBQVUsSUFBSUMsa0JBQU87QUFFM0JELFFBQ0VFLElBQUksQ0FBQyxZQUNMQyxXQUFXLENBQUMsbUNBQ1pDLFFBQVEsQ0FBQyxlQUFlLGlEQUFpRCxLQUN6RUMsTUFBTSxDQUFDLGFBQWEsNkJBQ3BCQyxNQUFNLENBQUMsT0FBT0MsV0FBbUJDO0lBQ2pDLE1BQU1DLElBQUFBLGtCQUFRLEVBQUNDLElBQUFBLGlCQUFPLEVBQUNILFlBQVlDO0FBQ3BDO0FBRURSLFFBQVFXLEtBQUsifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvY2xpLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIiMhL3Vzci9iaW4vZW52IG5vZGVcbmltcG9ydCB7IHJlc29sdmUgfSBmcm9tIFwibm9kZTpwYXRoXCI7XG5pbXBvcnQgeyBDb21tYW5kIH0gZnJvbSBcImNvbW1hbmRlclwiO1xuaW1wb3J0IHsgc2NhZmZvbGQgfSBmcm9tIFwiLi9zY2FmZm9sZC5qc1wiO1xuXG5jb25zdCBwcm9ncmFtID0gbmV3IENvbW1hbmQoKTtcblxucHJvZ3JhbVxuXHQubmFtZShcImRlY29oZXJlXCIpXG5cdC5kZXNjcmlwdGlvbihcIlNjYWZmb2xkIGEgbmV3IERlY29oZXJlIHByb2plY3RcIilcblx0LmFyZ3VtZW50KFwiW2RpcmVjdG9yeV1cIiwgXCJUYXJnZXQgZGlyZWN0b3J5IChkZWZhdWx0OiBjdXJyZW50IGRpcmVjdG9yeSlcIiwgXCIuXCIpXG5cdC5vcHRpb24oXCIteSwgLS15ZXNcIiwgXCJTa2lwIGNvbmZpcm1hdGlvbiBwcm9tcHRzXCIpXG5cdC5vcHRpb24oXCItdCwgLS10ZW1wbGF0ZSA8dGVtcGxhdGU+XCIsIFwiUHJvamVjdCB0ZW1wbGF0ZTogYmFzaWMgKGRlZmF1bHQpIG9yIHdlYmFwaVwiLCBcImJhc2ljXCIpXG5cdC5vcHRpb24oXCItZCwgLS1kYXRhYmFzZSA8cHJvdmlkZXI+XCIsIFwiRGF0YWJhc2UgcHJvdmlkZXIgdG8gaW5jbHVkZSAod2ViYXBpIG9ubHkpOiB0eXBlb3JtXCIpXG5cdC5hY3Rpb24oXG5cdFx0YXN5bmMgKFxuXHRcdFx0ZGlyZWN0b3J5OiBzdHJpbmcsXG5cdFx0XHRvcHRzOiB7IHllcz86IGJvb2xlYW47IHRlbXBsYXRlPzogXCJiYXNpY1wiIHwgXCJ3ZWJhcGlcIjsgZGF0YWJhc2U/OiBcInR5cGVvcm1cIiB9LFxuXHRcdCkgPT4ge1xuXHRcdFx0YXdhaXQgc2NhZmZvbGQocmVzb2x2ZShkaXJlY3RvcnkpLCBvcHRzKTtcblx0XHR9LFxuXHQpO1xuXG5wcm9ncmFtLnBhcnNlKCk7XG4iXSwibmFtZXMiOlsicHJvZ3JhbSIsIkNvbW1hbmQiLCJuYW1lIiwiZGVzY3JpcHRpb24iLCJhcmd1bWVudCIsIm9wdGlvbiIsImFjdGlvbiIsImRpcmVjdG9yeSIsIm9wdHMiLCJzY2FmZm9sZCIsInJlc29sdmUiLCJwYXJzZSJdLCJtYXBwaW5ncyI6Ijs7Ozs7MEJBQ3dCOzJCQUNBOzBCQUNDO0FBRXpCLE1BQU1BLFVBQVUsSUFBSUMsa0JBQU87QUFFM0JELFFBQ0VFLElBQUksQ0FBQyxZQUNMQyxXQUFXLENBQUMsbUNBQ1pDLFFBQVEsQ0FBQyxlQUFlLGlEQUFpRCxLQUN6RUMsTUFBTSxDQUFDLGFBQWEsNkJBQ3BCQSxNQUFNLENBQUMsNkJBQTZCLCtDQUErQyxTQUNuRkEsTUFBTSxDQUFDLDZCQUE2Qix1REFDcENDLE1BQU0sQ0FDTixPQUNDQyxXQUNBQztJQUVBLE1BQU1DLElBQUFBLGtCQUFRLEVBQUNDLElBQUFBLGlCQUFPLEVBQUNILFlBQVlDO0FBQ3BDO0FBR0ZSLFFBQVFXLEtBQUsifQ==

package/commonjs/src/scaffold.js

@@ -12,6 +12,7 @@ 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);
@@ -27,22 +28,62 @@ async function scaffold(targetDir, opts) {
             process.exit(0);
         }
     }
-    await (0, _promises.mkdir)((0, _nodepath.join)(targetDir, "projects", "app", "src"), {
-        recursive: true
+    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
     });
-    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}. Next steps:\n`);
+    console.log(`\nDone! Next steps:\n`);
     if ((0, _nodepath.basename)(targetDir) !== targetDir) {
         console.log(`  cd ${name}`);
     }
-    console.log("  pnpm install");
     console.log("  pnpm build     # forge build");
     console.log("  pnpm dev       # flux serve\n");
 }
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvc2NhZmZvbGQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZXhpc3RzU3luYywgcmVhZGRpclN5bmMgfSBmcm9tIFwibm9kZTpmc1wiO1xuaW1wb3J0IHsgbWtkaXIsIHdyaXRlRmlsZSB9IGZyb20gXCJub2RlOmZzL3Byb21pc2VzXCI7XG5pbXBvcnQgeyBiYXNlbmFtZSwgam9pbiB9IGZyb20gXCJub2RlOnBhdGhcIjtcbmltcG9ydCB7IGNyZWF0ZUludGVyZmFjZSB9IGZyb20gXCJub2RlOnJlYWRsaW5lL3Byb21pc2VzXCI7XG5pbXBvcnQgeyBBUFBfUEFDS0FHRV9KU09OLCBNQUlOX1RTLCBST09UX1BBQ0tBR0VfSlNPTiwgVFNDT05GSUcgfSBmcm9tIFwiLi90ZW1wbGF0ZXMuanNcIjtcblxuZXhwb3J0IGludGVyZmFjZSBTY2FmZm9sZE9wdGlvbnMge1xuXHR5ZXM/OiBib29sZWFuO1xufVxuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gc2NhZmZvbGQodGFyZ2V0RGlyOiBzdHJpbmcsIG9wdHM6IFNjYWZmb2xkT3B0aW9ucyk6IFByb21pc2U8dm9pZD4ge1xuXHRjb25zdCBuYW1lID0gYmFzZW5hbWUodGFyZ2V0RGlyKTtcblxuXHRpZiAoZXhpc3RzU3luYyh0YXJnZXREaXIpICYmIHJlYWRkaXJTeW5jKHRhcmdldERpcikubGVuZ3RoID4gMCAmJiAhb3B0cy55ZXMpIHtcblx0XHRjb25zdCBybCA9IGNyZWF0ZUludGVyZmFjZSh7XG5cdFx0XHRpbnB1dDogcHJvY2Vzcy5zdGRpbixcblx0XHRcdG91dHB1dDogcHJvY2Vzcy5zdGRvdXQsXG5cdFx0fSk7XG5cdFx0Y29uc3QgYW5zd2VyID0gYXdhaXQgcmwucXVlc3Rpb24oYERpcmVjdG9yeSBcIiR7bmFtZX1cIiBpcyBub3QgZW1wdHkuIENvbnRpbnVlPyBbeS9OXSBgKTtcblx0XHRybC5jbG9zZSgpO1xuXHRcdGlmICghYW5zd2VyLnRyaW0oKS50b0xvd2VyQ2FzZSgpLnN0YXJ0c1dpdGgoXCJ5XCIpKSB7XG5cdFx0XHRjb25zb2xlLmxvZyhcIkFib3J0ZWQuXCIpO1xuXHRcdFx0cHJvY2Vzcy5leGl0KDApO1xuXHRcdH1cblx0fVxuXG5cdGF3YWl0IG1rZGlyKGpvaW4odGFyZ2V0RGlyLCBcInByb2plY3RzXCIsIFwiYXBwXCIsIFwic3JjXCIpLCB7IHJlY3Vyc2l2ZTogdHJ1ZSB9KTtcblxuXHRhd2FpdCBQcm9taXNlLmFsbChbXG5cdFx0d3JpdGVGaWxlKGpvaW4odGFyZ2V0RGlyLCBcInBhY2thZ2UuanNvblwiKSwgUk9PVF9QQUNLQUdFX0pTT04obmFtZSkpLFxuXHRcdHdyaXRlRmlsZShqb2luKHRhcmdldERpciwgXCJ0c2NvbmZpZy5qc29uXCIpLCBUU0NPTkZJRyksXG5cdFx0d3JpdGVGaWxlKGpvaW4odGFyZ2V0RGlyLCBcInByb2plY3RzXCIsIFwiYXBwXCIsIFwicGFja2FnZS5qc29uXCIpLCBBUFBfUEFDS0FHRV9KU09OKG5hbWUpKSxcblx0XHR3cml0ZUZpbGUoam9pbih0YXJnZXREaXIsIFwicHJvamVjdHNcIiwgXCJhcHBcIiwgXCJzcmNcIiwgXCJtYWluLnRzXCIpLCBNQUlOX1RTKSxcblx0XSk7XG5cblx0Y29uc29sZS5sb2coYFxcblNjYWZmb2xkZWQgJHtuYW1lfS4gTmV4dCBzdGVwczpcXG5gKTtcblx0aWYgKGJhc2VuYW1lKHRhcmdldERpcikgIT09IHRhcmdldERpcikge1xuXHRcdGNvbnNvbGUubG9nKGAgIGNkICR7bmFtZX1gKTtcblx0fVxuXHRjb25zb2xlLmxvZyhcIiAgcG5wbSBpbnN0YWxsXCIpO1xuXHRjb25zb2xlLmxvZyhcIiAgcG5wbSBidWlsZCAgICAgIyBmb3JnZSBidWlsZFwiKTtcblx0Y29uc29sZS5sb2coXCIgIHBucG0gZGV2ICAgICAgICMgZmx1eCBzZXJ2ZVxcblwiKTtcbn1cbiJdLCJuYW1lcyI6WyJzY2FmZm9sZCIsInRhcmdldERpciIsIm9wdHMiLCJuYW1lIiwiYmFzZW5hbWUiLCJleGlzdHNTeW5jIiwicmVhZGRpclN5bmMiLCJsZW5ndGgiLCJ5ZXMiLCJybCIsImNyZWF0ZUludGVyZmFjZSIsImlucHV0IiwicHJvY2VzcyIsInN0ZGluIiwib3V0cHV0Iiwic3Rkb3V0IiwiYW5zd2VyIiwicXVlc3Rpb24iLCJjbG9zZSIsInRyaW0iLCJ0b0xvd2VyQ2FzZSIsInN0YXJ0c1dpdGgiLCJjb25zb2xlIiwibG9nIiwiZXhpdCIsIm1rZGlyIiwiam9pbiIsInJlY3Vyc2l2ZSIsIlByb21pc2UiLCJhbGwiLCJ3cml0ZUZpbGUiLCJST09UX1BBQ0tBR0VfSlNPTiIsIlRTQ09ORklHIiwiQVBQX1BBQ0tBR0VfSlNPTiIsIk1BSU5fVFMiXSwibWFwcGluZ3MiOiI7Ozs7K0JBVXNCQTs7O2VBQUFBOzs7d0JBVmtCOzBCQUNQOzBCQUNGOzJCQUNDOzJCQUN1QztBQU1oRSxlQUFlQSxTQUFTQyxTQUFpQixFQUFFQyxJQUFxQjtJQUN0RSxNQUFNQyxPQUFPQyxJQUFBQSxrQkFBUSxFQUFDSDtJQUV0QixJQUFJSSxJQUFBQSxrQkFBVSxFQUFDSixjQUFjSyxJQUFBQSxtQkFBVyxFQUFDTCxXQUFXTSxNQUFNLEdBQUcsS0FBSyxDQUFDTCxLQUFLTSxHQUFHLEVBQUU7UUFDNUUsTUFBTUMsS0FBS0MsSUFBQUEsMEJBQWUsRUFBQztZQUMxQkMsT0FBT0MsUUFBUUMsS0FBSztZQUNwQkMsUUFBUUYsUUFBUUcsTUFBTTtRQUN2QjtRQUNBLE1BQU1DLFNBQVMsTUFBTVAsR0FBR1EsUUFBUSxDQUFDLENBQUMsV0FBVyxFQUFFZCxLQUFLLGdDQUFnQyxDQUFDO1FBQ3JGTSxHQUFHUyxLQUFLO1FBQ1IsSUFBSSxDQUFDRixPQUFPRyxJQUFJLEdBQUdDLFdBQVcsR0FBR0MsVUFBVSxDQUFDLE1BQU07WUFDakRDLFFBQVFDLEdBQUcsQ0FBQztZQUNaWCxRQUFRWSxJQUFJLENBQUM7UUFDZDtJQUNEO0lBRUEsTUFBTUMsSUFBQUEsZUFBSyxFQUFDQyxJQUFBQSxjQUFJLEVBQUN6QixXQUFXLFlBQVksT0FBTyxRQUFRO1FBQUUwQixXQUFXO0lBQUs7SUFFekUsTUFBTUMsUUFBUUMsR0FBRyxDQUFDO1FBQ2pCQyxJQUFBQSxtQkFBUyxFQUFDSixJQUFBQSxjQUFJLEVBQUN6QixXQUFXLGlCQUFpQjhCLElBQUFBLDRCQUFpQixFQUFDNUI7UUFDN0QyQixJQUFBQSxtQkFBUyxFQUFDSixJQUFBQSxjQUFJLEVBQUN6QixXQUFXLGtCQUFrQitCLG1CQUFRO1FBQ3BERixJQUFBQSxtQkFBUyxFQUFDSixJQUFBQSxjQUFJLEVBQUN6QixXQUFXLFlBQVksT0FBTyxpQkFBaUJnQyxJQUFBQSwyQkFBZ0IsRUFBQzlCO1FBQy9FMkIsSUFBQUEsbUJBQVMsRUFBQ0osSUFBQUEsY0FBSSxFQUFDekIsV0FBVyxZQUFZLE9BQU8sT0FBTyxZQUFZaUMsa0JBQU87S0FDdkU7SUFFRFosUUFBUUMsR0FBRyxDQUFDLENBQUMsYUFBYSxFQUFFcEIsS0FBSyxlQUFlLENBQUM7SUFDakQsSUFBSUMsSUFBQUEsa0JBQVEsRUFBQ0gsZUFBZUEsV0FBVztRQUN0Q3FCLFFBQVFDLEdBQUcsQ0FBQyxDQUFDLEtBQUssRUFBRXBCLE1BQU07SUFDM0I7SUFDQW1CLFFBQVFDLEdBQUcsQ0FBQztJQUNaRCxRQUFRQyxHQUFHLENBQUM7SUFDWkQsUUFBUUMsR0FBRyxDQUFDO0FBQ2IifQ==
+//# 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

@@ -12,14 +12,50 @@ _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) {
@@ -38,6 +74,34 @@ function ROOT_PACKAGE_JSON(name) {
         }
     }, 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`,
@@ -60,5 +124,183 @@ const TSCONFIG = JSON.stringify({
 }, 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",
+            "@decohere/crucible": "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,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
+//# 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\t\"@decohere/crucible\": \"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

@@ -3,9 +3,9 @@ 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").action(async (directory, opts)=>{
+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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvY2xpLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIiMhL3Vzci9iaW4vZW52IG5vZGVcbmltcG9ydCB7IHJlc29sdmUgfSBmcm9tIFwibm9kZTpwYXRoXCI7XG5pbXBvcnQgeyBDb21tYW5kIH0gZnJvbSBcImNvbW1hbmRlclwiO1xuaW1wb3J0IHsgc2NhZmZvbGQgfSBmcm9tIFwiLi9zY2FmZm9sZC5qc1wiO1xuXG5jb25zdCBwcm9ncmFtID0gbmV3IENvbW1hbmQoKTtcblxucHJvZ3JhbVxuXHQubmFtZShcImRlY29oZXJlXCIpXG5cdC5kZXNjcmlwdGlvbihcIlNjYWZmb2xkIGEgbmV3IERlY29oZXJlIHByb2plY3RcIilcblx0LmFyZ3VtZW50KFwiW2RpcmVjdG9yeV1cIiwgXCJUYXJnZXQgZGlyZWN0b3J5IChkZWZhdWx0OiBjdXJyZW50IGRpcmVjdG9yeSlcIiwgXCIuXCIpXG5cdC5vcHRpb24oXCIteSwgLS15ZXNcIiwgXCJTa2lwIGNvbmZpcm1hdGlvbiBwcm9tcHRzXCIpXG5cdC5hY3Rpb24oYXN5bmMgKGRpcmVjdG9yeTogc3RyaW5nLCBvcHRzOiB7IHllcz86IGJvb2xlYW4gfSkgPT4ge1xuXHRcdGF3YWl0IHNjYWZmb2xkKHJlc29sdmUoZGlyZWN0b3J5KSwgb3B0cyk7XG5cdH0pO1xuXG5wcm9ncmFtLnBhcnNlKCk7XG4iXSwibmFtZXMiOlsicmVzb2x2ZSIsIkNvbW1hbmQiLCJzY2FmZm9sZCIsInByb2dyYW0iLCJuYW1lIiwiZGVzY3JpcHRpb24iLCJhcmd1bWVudCIsIm9wdGlvbiIsImFjdGlvbiIsImRpcmVjdG9yeSIsIm9wdHMiLCJwYXJzZSJdLCJtYXBwaW5ncyI6IjtBQUNBLFNBQVNBLE9BQU8sUUFBUSxZQUFZO0FBQ3BDLFNBQVNDLE9BQU8sUUFBUSxZQUFZO0FBQ3BDLFNBQVNDLFFBQVEsUUFBUSxnQkFBZ0I7QUFFekMsTUFBTUMsVUFBVSxJQUFJRjtBQUVwQkUsUUFDRUMsSUFBSSxDQUFDLFlBQ0xDLFdBQVcsQ0FBQyxtQ0FDWkMsUUFBUSxDQUFDLGVBQWUsaURBQWlELEtBQ3pFQyxNQUFNLENBQUMsYUFBYSw2QkFDcEJDLE1BQU0sQ0FBQyxPQUFPQyxXQUFtQkM7SUFDakMsTUFBTVIsU0FBU0YsUUFBUVMsWUFBWUM7QUFDcEM7QUFFRFAsUUFBUVEsS0FBSyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvY2xpLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIiMhL3Vzci9iaW4vZW52IG5vZGVcbmltcG9ydCB7IHJlc29sdmUgfSBmcm9tIFwibm9kZTpwYXRoXCI7XG5pbXBvcnQgeyBDb21tYW5kIH0gZnJvbSBcImNvbW1hbmRlclwiO1xuaW1wb3J0IHsgc2NhZmZvbGQgfSBmcm9tIFwiLi9zY2FmZm9sZC5qc1wiO1xuXG5jb25zdCBwcm9ncmFtID0gbmV3IENvbW1hbmQoKTtcblxucHJvZ3JhbVxuXHQubmFtZShcImRlY29oZXJlXCIpXG5cdC5kZXNjcmlwdGlvbihcIlNjYWZmb2xkIGEgbmV3IERlY29oZXJlIHByb2plY3RcIilcblx0LmFyZ3VtZW50KFwiW2RpcmVjdG9yeV1cIiwgXCJUYXJnZXQgZGlyZWN0b3J5IChkZWZhdWx0OiBjdXJyZW50IGRpcmVjdG9yeSlcIiwgXCIuXCIpXG5cdC5vcHRpb24oXCIteSwgLS15ZXNcIiwgXCJTa2lwIGNvbmZpcm1hdGlvbiBwcm9tcHRzXCIpXG5cdC5vcHRpb24oXCItdCwgLS10ZW1wbGF0ZSA8dGVtcGxhdGU+XCIsIFwiUHJvamVjdCB0ZW1wbGF0ZTogYmFzaWMgKGRlZmF1bHQpIG9yIHdlYmFwaVwiLCBcImJhc2ljXCIpXG5cdC5vcHRpb24oXCItZCwgLS1kYXRhYmFzZSA8cHJvdmlkZXI+XCIsIFwiRGF0YWJhc2UgcHJvdmlkZXIgdG8gaW5jbHVkZSAod2ViYXBpIG9ubHkpOiB0eXBlb3JtXCIpXG5cdC5hY3Rpb24oXG5cdFx0YXN5bmMgKFxuXHRcdFx0ZGlyZWN0b3J5OiBzdHJpbmcsXG5cdFx0XHRvcHRzOiB7IHllcz86IGJvb2xlYW47IHRlbXBsYXRlPzogXCJiYXNpY1wiIHwgXCJ3ZWJhcGlcIjsgZGF0YWJhc2U/OiBcInR5cGVvcm1cIiB9LFxuXHRcdCkgPT4ge1xuXHRcdFx0YXdhaXQgc2NhZmZvbGQocmVzb2x2ZShkaXJlY3RvcnkpLCBvcHRzKTtcblx0XHR9LFxuXHQpO1xuXG5wcm9ncmFtLnBhcnNlKCk7XG4iXSwibmFtZXMiOlsicmVzb2x2ZSIsIkNvbW1hbmQiLCJzY2FmZm9sZCIsInByb2dyYW0iLCJuYW1lIiwiZGVzY3JpcHRpb24iLCJhcmd1bWVudCIsIm9wdGlvbiIsImFjdGlvbiIsImRpcmVjdG9yeSIsIm9wdHMiLCJwYXJzZSJdLCJtYXBwaW5ncyI6IjtBQUNBLFNBQVNBLE9BQU8sUUFBUSxZQUFZO0FBQ3BDLFNBQVNDLE9BQU8sUUFBUSxZQUFZO0FBQ3BDLFNBQVNDLFFBQVEsUUFBUSxnQkFBZ0I7QUFFekMsTUFBTUMsVUFBVSxJQUFJRjtBQUVwQkUsUUFDRUMsSUFBSSxDQUFDLFlBQ0xDLFdBQVcsQ0FBQyxtQ0FDWkMsUUFBUSxDQUFDLGVBQWUsaURBQWlELEtBQ3pFQyxNQUFNLENBQUMsYUFBYSw2QkFDcEJBLE1BQU0sQ0FBQyw2QkFBNkIsK0NBQStDLFNBQ25GQSxNQUFNLENBQUMsNkJBQTZCLHVEQUNwQ0MsTUFBTSxDQUNOLE9BQ0NDLFdBQ0FDO0lBRUEsTUFBTVIsU0FBU0YsUUFBUVMsWUFBWUM7QUFDcEM7QUFHRlAsUUFBUVEsS0FBSyJ9

package/es6/src/scaffold.js

@@ -2,7 +2,8 @@ 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 { APP_PACKAGE_JSON, MAIN_TS, ROOT_PACKAGE_JSON, TSCONFIG } from "./templates.js";
+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) {
@@ -17,22 +18,62 @@ export async function scaffold(targetDir, opts) {
             process.exit(0);
         }
     }
-    await mkdir(join(targetDir, "projects", "app", "src"), {
-        recursive: true
+    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
     });
-    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}. Next steps:\n`);
+    console.log(`\nDone! Next steps:\n`);
     if (basename(targetDir) !== targetDir) {
         console.log(`  cd ${name}`);
     }
-    console.log("  pnpm install");
     console.log("  pnpm build     # forge build");
     console.log("  pnpm dev       # flux serve\n");
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# 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":"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"}

package/es6/src/templates.js

@@ -14,6 +14,34 @@ export function ROOT_PACKAGE_JSON(name) {
         }
     }, null, 2);
 }
+export 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);
+}
 export function APP_PACKAGE_JSON(name) {
     return JSON.stringify({
         name: `@${name}/app`,
@@ -36,5 +64,183 @@ export const TSCONFIG = JSON.stringify({
 }, null, 2);
 export const MAIN_TS = `console.log("Hello from Decohere!");
 `;
+export 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);
+export 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",
+            "@decohere/crucible": "0.0.1-dev.15"
+        }
+    }, null, 2);
+}
+export 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;
+`;
+}
+export 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 };
+	}
+}
+`;
+export const SAMPLE_CONFIG_TS = `export class SampleConfig {
+	public greeting: string = "";
+}
+`;
+export 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;
+	}
+}
+`;
+export 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}`;
+}
+export const CONFIG_DEV_YAML = `sample:
+  greeting: Hello from dev configuration!
+`;
+export 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}
+`;
+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}
+}
+`;
 
-//# sourceMappingURL=data:application/json;base64,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
+//# 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\t\"@decohere/crucible\": \"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":["ROOT_PACKAGE_JSON","name","JSON","stringify","version","type","scripts","build","dev","devDependencies","typescript","WEB_API_ROOT_PACKAGE_JSON","opts","deps","database","dependencies","APP_PACKAGE_JSON","main","TSCONFIG","compilerOptions","target","module","moduleResolution","strict","skipLibCheck","include","MAIN_TS","WEB_API_TSCONFIG","experimentalDecorators","emitDecoratorMetadata","WEB_API_APP_PACKAGE_JSON","WEB_API_MAIN_TS","dbImport","dbChain","HELLO_CONTROLLER_TS","SAMPLE_CONFIG_TS","SAMPLE_SERVICE_TS","CONFIG_YAML","dbSection","CONFIG_DEV_YAML","CONFIG_PROD_YAML","SAMPLE_ENTITY_TS","SAMPLE_REPOSITORY_TS"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/create",
-  "version": "0.0.1-dev.15",
+  "version": "0.0.1-dev.17",
   "description": "Scaffold a new Decohere project — build with Forge, serve with Flux",
   "keywords": [
     "decohere",
@@ -21,6 +21,7 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
+    "@decohere/nexus": "0.0.1-dev.17",
     "commander": "^13.1.0"
   },
   "devDependencies": {}

package/types/src/scaffold.d.ts

@@ -1,4 +1,6 @@
 export interface ScaffoldOptions {
     yes?: boolean;
+    template?: "basic" | "webapi";
+    database?: "typeorm";
 }
 export declare function scaffold(targetDir: string, opts: ScaffoldOptions): Promise<void>;

package/types/src/templates.d.ts

@@ -1,4 +1,20 @@
 export declare function ROOT_PACKAGE_JSON(name: string): string;
+export type DatabaseProvider = "typeorm";
+export type WebApiOptions = {
+    database?: DatabaseProvider;
+};
+export declare function WEB_API_ROOT_PACKAGE_JSON(name: string, opts?: WebApiOptions): string;
 export declare function APP_PACKAGE_JSON(name: string): string;
 export declare const TSCONFIG: string;
 export declare const MAIN_TS = "console.log(\"Hello from Decohere!\");\n";
+export declare const WEB_API_TSCONFIG: string;
+export declare function WEB_API_APP_PACKAGE_JSON(name: string): string;
+export declare function WEB_API_MAIN_TS(name: string, opts?: WebApiOptions): string;
+export declare 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";
+export declare const SAMPLE_CONFIG_TS = "export class SampleConfig {\n\tpublic greeting: string = \"\";\n}\n";
+export declare 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";
+export declare function CONFIG_YAML(name: string, opts?: WebApiOptions): string;
+export declare const CONFIG_DEV_YAML = "sample:\n  greeting: Hello from dev configuration!\n";
+export declare 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";
+export declare 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";
+export declare 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";