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

package/commonjs/src/webapi/models/main-source-file.model.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MainSourceFile", {
+    enumerable: true,
+    get: function() {
+        return MainSourceFile;
+    }
+});
+const _const = require("../../models/const.js");
+/** Tracks named imports from a single module path, split into values and types. */ class ImportGroup {
+    _values = [];
+    _types = [];
+    add(name, typeOnly = false) {
+        if (typeOnly) {
+            // Value import already present — value wins, skip
+            if (!this._values.includes(name) && !this._types.includes(name)) {
+                this._types.push(name);
+            }
+        } else {
+            // Promote: remove from types if it was previously type-only
+            const typeIdx = this._types.indexOf(name);
+            if (typeIdx !== -1) this._types.splice(typeIdx, 1);
+            if (!this._values.includes(name)) this._values.push(name);
+        }
+        return this;
+    }
+    render(from) {
+        const values = [
+            ...this._values
+        ].sort();
+        const types = [
+            ...this._types
+        ].sort().map((n)=>`type ${n}`);
+        return `import { ${[
+            ...values,
+            ...types
+        ].join(", ")} } from "${from}";`;
+    }
+}
+class MainSourceFile {
+    appName;
+    key = _const.WELL_KNOWN_FILES.MAIN_TS;
+    _sideEffectImports = [];
+    _extraImports = new Map();
+    _builderCalls = [];
+    _entities = [];
+    _repositories = [];
+    constructor(appName){
+        this.appName = appName;
+    }
+    /** Adds a bare side-effect import, e.g. `@decohere/cortex/auth`. */ addSideEffectImport(path) {
+        if (!this._sideEffectImports.includes(path)) this._sideEffectImports.push(path);
+        return this;
+    }
+    /** Adds a named import, e.g. `import { Foo } from "bar"`. */ addImport(name, from, typeOnly = false) {
+        const group = this._extraImports.get(from) ?? new ImportGroup();
+        group.add(name, typeOnly);
+        this._extraImports.set(from, group);
+        return this;
+    }
+    /**
+	 * Adds a builder call inserted after `.withConfiguration()` and before
+	 * `.withServices()`. Pass the call without leading dot, e.g. `.withAuth()`.
+	 */ addBuilderCall(call) {
+        this._builderCalls.push(call);
+        return this;
+    }
+    /** Adds a TypeORM entity — import and entry in `withTypeOrm({ entities })`. */ addEntity(entity) {
+        this._entities.push(entity);
+        return this;
+    }
+    /** Adds a TypeORM repository — import and entry in `withTypeOrm({ repositories })`. */ addRepository(repo) {
+        this._repositories.push(repo);
+        return this;
+    }
+    files() {
+        const imports = [
+            'import "@decohere/scribe-pino";',
+            'import "@decohere/cortex/http";'
+        ];
+        for (const path of this._sideEffectImports){
+            imports.push(`import "${path}";`);
+        }
+        imports.push('import "@decohere/protocol";', 'import { YamlDataSource } from "@decohere/protocol";', 'import { Builder } from "@decohere/cortex";', 'import { FastifyProvider } from "@decohere/cortex/providers";', 'import { scribe } from "@decohere/scribe";', 'import { SampleService } from "./services/sample.service.js";');
+        for (const e of this._entities){
+            imports.push(`import { ${e.className} } from "${e.importPath}";`);
+        }
+        for (const r of this._repositories){
+            imports.push(`import { ${r.className} } from "${r.importPath}";`);
+        }
+        for (const [from, group] of this._extraImports){
+            imports.push(group.render(from));
+        }
+        imports.push('import { HelloController } from "./controllers/hello.controller.js";');
+        const builderCalls = [
+            `\t.withHttpProvider(FastifyProvider)`,
+            `\t.withConfiguration(YamlDataSource)`,
+            ...this._builderCalls.map((c)=>`\t${c}`),
+            `\t.withServices((cb) => { cb.registerSingleton(SampleService); })`
+        ];
+        if (this._entities.length > 0) {
+            const entities = this._entities.map((e)=>e.className).join(", ");
+            const repos = this._repositories.map((r)=>r.className).join(", ");
+            builderCalls.push(`\t.withTypeOrm({ entities: [${entities}], repositories: [${repos}] })`);
+        }
+        builderCalls.push(`\t.withControllers(HelloController)`);
+        const content = [
+            ...imports,
+            "",
+            "scribe.extend.withPinoPretty();",
+            "",
+            `const app = await Builder.create({ applicationName: "${this.appName}" })`,
+            ...builderCalls,
+            `\t.build();`,
+            "",
+            "await app.start({ port: 3000 });",
+            "",
+            "export default app;",
+            ""
+        ].join("\n");
+        return [
+            {
+                filePath: "src/main.ts",
+                content
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/models/main-source-file.model.ts"],"sourcesContent":["import { WELL_KNOWN_FILES } from \"../../models/const.js\";\nimport type { KeyedModel, SourceFile } from \"../../models/source-file.js\";\n\nexport type TypeOrmImport = { className: string; importPath: string };\n\n/** Tracks named imports from a single module path, split into values and types. */\nclass ImportGroup {\n\tprivate readonly _values: string[] = [];\n\tprivate readonly _types: string[] = [];\n\n\tpublic add(name: string, typeOnly = false): this {\n\t\tif (typeOnly) {\n\t\t\t// Value import already present — value wins, skip\n\t\t\tif (!this._values.includes(name) && !this._types.includes(name)) {\n\t\t\t\tthis._types.push(name);\n\t\t\t}\n\t\t} else {\n\t\t\t// Promote: remove from types if it was previously type-only\n\t\t\tconst typeIdx = this._types.indexOf(name);\n\t\t\tif (typeIdx !== -1) this._types.splice(typeIdx, 1);\n\t\t\tif (!this._values.includes(name)) this._values.push(name);\n\t\t}\n\t\treturn this;\n\t}\n\n\tpublic render(from: string): string {\n\t\tconst values = [...this._values].sort();\n\t\tconst types = [...this._types].sort().map((n) => `type ${n}`);\n\t\treturn `import { ${[...values, ...types].join(\", \")} } from \"${from}\";`;\n\t}\n}\n\n/**\n * Model for `projects/api/src/main.ts`.\n *\n * Starts with the minimal HTTP + YAML config setup. Features mutate the model\n * by calling addSideEffectImport / addImport / addBuilderCall / addEntity /\n * addRepository. files() renders whatever has been accumulated.\n */\nexport class MainSourceFile implements KeyedModel {\n\tpublic readonly key = WELL_KNOWN_FILES.MAIN_TS;\n\n\tprivate readonly _sideEffectImports: string[] = [];\n\tprivate readonly _extraImports = new Map<string, ImportGroup>();\n\tprivate readonly _builderCalls: string[] = [];\n\tprivate readonly _entities: TypeOrmImport[] = [];\n\tprivate readonly _repositories: TypeOrmImport[] = [];\n\n\tpublic constructor(private readonly appName: string) {}\n\n\t/** Adds a bare side-effect import, e.g. `@decohere/cortex/auth`. */\n\tpublic addSideEffectImport(path: string): this {\n\t\tif (!this._sideEffectImports.includes(path)) this._sideEffectImports.push(path);\n\t\treturn this;\n\t}\n\n\t/** Adds a named import, e.g. `import { Foo } from \"bar\"`. */\n\tpublic addImport(name: string, from: string, typeOnly = false): this {\n\t\tconst group = this._extraImports.get(from) ?? new ImportGroup();\n\t\tgroup.add(name, typeOnly);\n\t\tthis._extraImports.set(from, group);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a builder call inserted after `.withConfiguration()` and before\n\t * `.withServices()`. Pass the call without leading dot, e.g. `.withAuth()`.\n\t */\n\tpublic addBuilderCall(call: string): this {\n\t\tthis._builderCalls.push(call);\n\t\treturn this;\n\t}\n\n\t/** Adds a TypeORM entity — import and entry in `withTypeOrm({ entities })`. */\n\tpublic addEntity(entity: TypeOrmImport): this {\n\t\tthis._entities.push(entity);\n\t\treturn this;\n\t}\n\n\t/** Adds a TypeORM repository — import and entry in `withTypeOrm({ repositories })`. */\n\tpublic addRepository(repo: TypeOrmImport): this {\n\t\tthis._repositories.push(repo);\n\t\treturn this;\n\t}\n\n\tpublic files(): SourceFile[] {\n\t\tconst imports: string[] = [\n\t\t\t'import \"@decohere/scribe-pino\";',\n\t\t\t'import \"@decohere/cortex/http\";',\n\t\t];\n\n\t\tfor (const path of this._sideEffectImports) {\n\t\t\timports.push(`import \"${path}\";`);\n\t\t}\n\n\t\timports.push(\n\t\t\t'import \"@decohere/protocol\";',\n\t\t\t'import { YamlDataSource } from \"@decohere/protocol\";',\n\t\t\t'import { Builder } from \"@decohere/cortex\";',\n\t\t\t'import { FastifyProvider } from \"@decohere/cortex/providers\";',\n\t\t\t'import { scribe } from \"@decohere/scribe\";',\n\t\t\t'import { SampleService } from \"./services/sample.service.js\";',\n\t\t);\n\n\t\tfor (const e of this._entities) {\n\t\t\timports.push(`import { ${e.className} } from \"${e.importPath}\";`);\n\t\t}\n\n\t\tfor (const r of this._repositories) {\n\t\t\timports.push(`import { ${r.className} } from \"${r.importPath}\";`);\n\t\t}\n\n\t\tfor (const [from, group] of this._extraImports) {\n\t\t\timports.push(group.render(from));\n\t\t}\n\n\t\timports.push('import { HelloController } from \"./controllers/hello.controller.js\";');\n\n\t\tconst builderCalls: string[] = [\n\t\t\t`\\t.withHttpProvider(FastifyProvider)`,\n\t\t\t`\\t.withConfiguration(YamlDataSource)`,\n\t\t\t...this._builderCalls.map((c) => `\\t${c}`),\n\t\t\t`\\t.withServices((cb) => { cb.registerSingleton(SampleService); })`,\n\t\t];\n\n\t\tif (this._entities.length > 0) {\n\t\t\tconst entities = this._entities.map((e) => e.className).join(\", \");\n\t\t\tconst repos = this._repositories.map((r) => r.className).join(\", \");\n\t\t\tbuilderCalls.push(\n\t\t\t\t`\\t.withTypeOrm({ entities: [${entities}], repositories: [${repos}] })`,\n\t\t\t);\n\t\t}\n\n\t\tbuilderCalls.push(`\\t.withControllers(HelloController)`);\n\n\t\tconst content = [\n\t\t\t...imports,\n\t\t\t\"\",\n\t\t\t\"scribe.extend.withPinoPretty();\",\n\t\t\t\"\",\n\t\t\t`const app = await Builder.create({ applicationName: \"${this.appName}\" })`,\n\t\t\t...builderCalls,\n\t\t\t`\\t.build();`,\n\t\t\t\"\",\n\t\t\t\"await app.start({ port: 3000 });\",\n\t\t\t\"\",\n\t\t\t\"export default app;\",\n\t\t\t\"\",\n\t\t].join(\"\\n\");\n\n\t\treturn [\n\t\t\t{\n\t\t\t\tfilePath: \"src/main.ts\",\n\t\t\t\tcontent,\n\t\t\t},\n\t\t];\n\t}\n}\n"],"names":["MainSourceFile","ImportGroup","_values","_types","add","name","typeOnly","includes","push","typeIdx","indexOf","splice","render","from","values","sort","types","map","n","join","key","WELL_KNOWN_FILES","MAIN_TS","_sideEffectImports","_extraImports","Map","_builderCalls","_entities","_repositories","appName","addSideEffectImport","path","addImport","group","get","set","addBuilderCall","call","addEntity","entity","addRepository","repo","files","imports","e","className","importPath","r","builderCalls","c","length","entities","repos","content","filePath"],"mappings":"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"}

package/commonjs/src/webapi/models/sample-files.model.js

@@ -0,0 +1,60 @@
+"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 SampleConfigModel () {
+        return SampleConfigModel;
+    },
+    get SampleServiceModel () {
+        return SampleServiceModel;
+    }
+});
+const SAMPLE_CONFIG_CONTENT = `export class SampleConfig {\n\tpublic greeting: string = "";\n}\n`;
+const SAMPLE_SERVICE_CONTENT = [
+    `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 {`,
+    `\tpublic constructor(`,
+    `\t\t@inject(ConfigurationServiceToken) private readonly config: IConfigurationService,`,
+    `\t) {}`,
+    ``,
+    `\tpublic async getGreeting(): Promise<string> {`,
+    `\t\tconst config = await this.config.get(SampleConfig);`,
+    `\t\treturn config.greeting;`,
+    `\t}`,
+    `}`,
+    ``
+].join("\n");
+class SampleConfigModel {
+    files() {
+        return [
+            {
+                filePath: "src/sample.config.ts",
+                content: SAMPLE_CONFIG_CONTENT
+            }
+        ];
+    }
+}
+class SampleServiceModel {
+    files() {
+        return [
+            {
+                filePath: "src/services/sample.service.ts",
+                content: SAMPLE_SERVICE_CONTENT
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/v1/cli.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+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: api (default) or cli").option("-d, --database <provider>", "Database provider to include (api only): typeorm").option("-i, --idp <provider>", "Identity provider to configure (api only): auth0").option("-p, --postman", "Configure a Postman workspace, collection, and environment").action(async (directory, opts)=>{
+    await (0, _scaffold.scaffold)((0, _nodepath.resolve)(directory), opts);
+});
+program.parse();
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS92MS9jbGkudHMiXSwic291cmNlc0NvbnRlbnQiOlsiIyEvdXNyL2Jpbi9lbnYgbm9kZVxuaW1wb3J0IHsgcmVzb2x2ZSB9IGZyb20gXCJub2RlOnBhdGhcIjtcbmltcG9ydCB7IENvbW1hbmQgfSBmcm9tIFwiY29tbWFuZGVyXCI7XG5pbXBvcnQgeyBzY2FmZm9sZCB9IGZyb20gXCIuL3NjYWZmb2xkLmpzXCI7XG5cbmNvbnN0IHByb2dyYW0gPSBuZXcgQ29tbWFuZCgpO1xuXG5wcm9ncmFtXG5cdC5uYW1lKFwiZGVjb2hlcmVcIilcblx0LmRlc2NyaXB0aW9uKFwiU2NhZmZvbGQgYSBuZXcgRGVjb2hlcmUgcHJvamVjdFwiKVxuXHQuYXJndW1lbnQoXCJbZGlyZWN0b3J5XVwiLCBcIlRhcmdldCBkaXJlY3RvcnkgKGRlZmF1bHQ6IGN1cnJlbnQgZGlyZWN0b3J5KVwiLCBcIi5cIilcblx0Lm9wdGlvbihcIi15LCAtLXllc1wiLCBcIlNraXAgY29uZmlybWF0aW9uIHByb21wdHNcIilcblx0Lm9wdGlvbihcIi10LCAtLXRlbXBsYXRlIDx0ZW1wbGF0ZT5cIiwgXCJQcm9qZWN0IHRlbXBsYXRlOiBhcGkgKGRlZmF1bHQpIG9yIGNsaVwiKVxuXHQub3B0aW9uKFwiLWQsIC0tZGF0YWJhc2UgPHByb3ZpZGVyPlwiLCBcIkRhdGFiYXNlIHByb3ZpZGVyIHRvIGluY2x1ZGUgKGFwaSBvbmx5KTogdHlwZW9ybVwiKVxuXHQub3B0aW9uKFwiLWksIC0taWRwIDxwcm92aWRlcj5cIiwgXCJJZGVudGl0eSBwcm92aWRlciB0byBjb25maWd1cmUgKGFwaSBvbmx5KTogYXV0aDBcIilcblx0Lm9wdGlvbihcIi1wLCAtLXBvc3RtYW5cIiwgXCJDb25maWd1cmUgYSBQb3N0bWFuIHdvcmtzcGFjZSwgY29sbGVjdGlvbiwgYW5kIGVudmlyb25tZW50XCIpXG5cdC5hY3Rpb24oXG5cdFx0YXN5bmMgKFxuXHRcdFx0ZGlyZWN0b3J5OiBzdHJpbmcsXG5cdFx0XHRvcHRzOiB7XG5cdFx0XHRcdHllcz86IGJvb2xlYW47XG5cdFx0XHRcdHRlbXBsYXRlPzogXCJhcGlcIiB8IFwiY2xpXCI7XG5cdFx0XHRcdGRhdGFiYXNlPzogXCJ0eXBlb3JtXCI7XG5cdFx0XHRcdGlkcD86IFwiYXV0aDBcIjtcblx0XHRcdFx0cG9zdG1hbj86IGJvb2xlYW47XG5cdFx0XHR9LFxuXHRcdCkgPT4ge1xuXHRcdFx0YXdhaXQgc2NhZmZvbGQocmVzb2x2ZShkaXJlY3RvcnkpLCBvcHRzKTtcblx0XHR9LFxuXHQpO1xuXG5wcm9ncmFtLnBhcnNlKCk7XG4iXSwibmFtZXMiOlsicHJvZ3JhbSIsIkNvbW1hbmQiLCJuYW1lIiwiZGVzY3JpcHRpb24iLCJhcmd1bWVudCIsIm9wdGlvbiIsImFjdGlvbiIsImRpcmVjdG9yeSIsIm9wdHMiLCJzY2FmZm9sZCIsInJlc29sdmUiLCJwYXJzZSJdLCJtYXBwaW5ncyI6Ijs7Ozs7MEJBQ3dCOzJCQUNBOzBCQUNDO0FBRXpCLE1BQU1BLFVBQVUsSUFBSUMsa0JBQU87QUFFM0JELFFBQ0VFLElBQUksQ0FBQyxZQUNMQyxXQUFXLENBQUMsbUNBQ1pDLFFBQVEsQ0FBQyxlQUFlLGlEQUFpRCxLQUN6RUMsTUFBTSxDQUFDLGFBQWEsNkJBQ3BCQSxNQUFNLENBQUMsNkJBQTZCLDBDQUNwQ0EsTUFBTSxDQUFDLDZCQUE2QixvREFDcENBLE1BQU0sQ0FBQyx3QkFBd0Isb0RBQy9CQSxNQUFNLENBQUMsaUJBQWlCLDhEQUN4QkMsTUFBTSxDQUNOLE9BQ0NDLFdBQ0FDO0lBUUEsTUFBTUMsSUFBQUEsa0JBQVEsRUFBQ0MsSUFBQUEsaUJBQU8sRUFBQ0gsWUFBWUM7QUFDcEM7QUFHRlIsUUFBUVcsS0FBSyJ9

package/commonjs/v1/domain/class-model.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ClassModel", {
+    enumerable: true,
+    get: function() {
+        return ClassModel;
+    }
+});
+const _importmap = require("./import-map.js");
+class ClassModel {
+    className;
+    fileName;
+    _imports = new _importmap.ImportMap();
+    _classDecorators = [];
+    _constructorParams = [];
+    _bodyClasses = [];
+    _methods = [];
+    constructor(className, fileName){
+        this.className = className;
+        this.fileName = fileName;
+    }
+    // ── imports ──────────────────────────────────────────────────────────────
+    /**
+	 * Add named value imports from `pkg`.
+	 * Called with no names, registers a side-effect `import "pkg"`.
+	 */ addImport(pkg, ...names) {
+        this._imports.add(pkg, ...names);
+        return this;
+    }
+    /** Add named type-only imports from `pkg`. */ addTypeImport(pkg, ...names) {
+        this._imports.addType(pkg, ...names);
+        return this;
+    }
+    // ── class-level ──────────────────────────────────────────────────────────
+    /** Prepend a class-level decorator (goes above any already-registered ones). */ decorateClass(decorator) {
+        if (!this._classDecorators.includes(decorator)) {
+            this._classDecorators.unshift(decorator);
+        }
+        return this;
+    }
+    addBodyClass(def) {
+        this._bodyClasses.push(def);
+        return this;
+    }
+    addConstructorParam(param) {
+        this._constructorParams.push(param);
+        return this;
+    }
+    // ── methods ──────────────────────────────────────────────────────────────
+    defineMethod(def) {
+        this._methods.push({
+            name: def.name,
+            decorators: [
+                ...def.decorators
+            ],
+            isAsync: def.isAsync ?? false,
+            params: def.params ?? [],
+            body: def.body
+        });
+        return this;
+    }
+    /**
+	 * Prepend a decorator onto an existing method.
+	 * Silently ignored if `methodName` is not found, so features are
+	 * resilient to controllers that don't expose a particular method.
+	 */ decorateMethod(methodName, ...decorators) {
+        const method = this._methods.find((m)=>m.name === methodName);
+        if (method) method.decorators.unshift(...decorators);
+        return this;
+    }
+    // ── rendering ─────────────────────────────────────────────────────────────
+    render() {
+        const importLines = this._imports.render();
+        const bodyClassBlocks = this._bodyClasses.map((bc)=>{
+            const fields = bc.fields.map((f)=>`\t${f.decorator}\n\tpublic ${f.name}!: ${f.typeName};`).join("\n");
+            return `class ${bc.name} {\n${fields}\n}`;
+        });
+        const constructorParams = this._constructorParams.map((p)=>{
+            const prefix = p.paramDecorators.length > 0 ? `${p.paramDecorators.join(" ")} ` : "";
+            const access = `${p.isPrivate ? "private " : ""}${p.isReadonly ? "readonly " : ""}`;
+            return `\t\t${prefix}${access}${p.name}: ${p.typeName},`;
+        }).join("\n");
+        const methodBlocks = this._methods.map((m)=>{
+            const decorators = m.decorators.map((d)=>`\t${d}`).join("\n");
+            const params = m.params.map((p)=>p.decorator ? `${p.decorator} ${p.name}: ${p.typeName}` : `${p.name}: ${p.typeName}`).join(", ");
+            const asyncKw = m.isAsync ? "async " : "";
+            return `${decorators}\n\tpublic ${asyncKw}${m.name}(${params}) {\n\t\t${m.body}\n\t}`;
+        });
+        const sections = [
+            importLines.join("\n"),
+            ...bodyClassBlocks,
+            [
+                ...this._classDecorators,
+                `export class ${this.className} {`
+            ].join("\n"),
+            `\tpublic constructor(\n${constructorParams}\n\t) {}`,
+            ...methodBlocks,
+            "}"
+        ];
+        return `${sections.join("\n\n")}\n`;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/v1/domain/class-model.ts"],"sourcesContent":["import { ImportMap } from \"./import-map.js\";\n\nexport interface ConstructorParam {\n\t/** e.g. [\"@inject(IPrincipalProviderToken)\"] */\n\tparamDecorators: string[];\n\tname: string;\n\ttypeName: string;\n\tisPrivate: boolean;\n\tisReadonly: boolean;\n}\n\nexport interface MethodParam {\n\t/** e.g. `@Query(\"filter\")` */\n\tdecorator?: string;\n\tname: string;\n\ttypeName: string;\n}\n\nexport interface MethodDef {\n\t/** Base HTTP decorator(s), e.g. [\"@Get()\"]. Rendered bottom-most. */\n\tdecorators: string[];\n\tname: string;\n\tisAsync?: boolean;\n\tparams?: MethodParam[];\n\tbody: string;\n}\n\nexport interface BodyClassField {\n\tdecorator: string;\n\tname: string;\n\ttypeName: string;\n}\n\nexport interface BodyClassDef {\n\tname: string;\n\tfields: BodyClassField[];\n}\n\ninterface Method extends Required<MethodDef> {}\n\n/**\n * A live, mutable model of a generated TypeScript class.\n *\n * Features call the fluent API to contribute imports, decorators, constructor\n * params, and method decorators.  When all configure phases are done, `render()`\n * produces the final TypeScript source.\n *\n * Subclass to model controllers, services, repositories, etc.\n */\nexport class ClassModel {\n\tpublic readonly className: string;\n\tpublic readonly fileName: string;\n\n\tprotected readonly _imports = new ImportMap();\n\tprivate readonly _classDecorators: string[] = [];\n\tprivate readonly _constructorParams: ConstructorParam[] = [];\n\tprivate readonly _bodyClasses: BodyClassDef[] = [];\n\tprivate readonly _methods: Method[] = [];\n\n\tpublic constructor(className: string, fileName: string) {\n\t\tthis.className = className;\n\t\tthis.fileName = fileName;\n\t}\n\n\t// ── imports ──────────────────────────────────────────────────────────────\n\n\t/**\n\t * Add named value imports from `pkg`.\n\t * Called with no names, registers a side-effect `import \"pkg\"`.\n\t */\n\tpublic addImport(pkg: string, ...names: string[]): this {\n\t\tthis._imports.add(pkg, ...names);\n\t\treturn this;\n\t}\n\n\t/** Add named type-only imports from `pkg`. */\n\tpublic addTypeImport(pkg: string, ...names: string[]): this {\n\t\tthis._imports.addType(pkg, ...names);\n\t\treturn this;\n\t}\n\n\t// ── class-level ──────────────────────────────────────────────────────────\n\n\t/** Prepend a class-level decorator (goes above any already-registered ones). */\n\tpublic decorateClass(decorator: string): this {\n\t\tif (!this._classDecorators.includes(decorator)) {\n\t\t\tthis._classDecorators.unshift(decorator);\n\t\t}\n\t\treturn this;\n\t}\n\n\tpublic addBodyClass(def: BodyClassDef): this {\n\t\tthis._bodyClasses.push(def);\n\t\treturn this;\n\t}\n\n\tpublic addConstructorParam(param: ConstructorParam): this {\n\t\tthis._constructorParams.push(param);\n\t\treturn this;\n\t}\n\n\t// ── methods ──────────────────────────────────────────────────────────────\n\n\tpublic defineMethod(def: MethodDef): this {\n\t\tthis._methods.push({\n\t\t\tname: def.name,\n\t\t\tdecorators: [...def.decorators],\n\t\t\tisAsync: def.isAsync ?? false,\n\t\t\tparams: def.params ?? [],\n\t\t\tbody: def.body,\n\t\t});\n\t\treturn this;\n\t}\n\n\t/**\n\t * Prepend a decorator onto an existing method.\n\t * Silently ignored if `methodName` is not found, so features are\n\t * resilient to controllers that don't expose a particular method.\n\t */\n\tpublic decorateMethod(methodName: string, ...decorators: string[]): this {\n\t\tconst method = this._methods.find((m) => m.name === methodName);\n\t\tif (method) method.decorators.unshift(...decorators);\n\t\treturn this;\n\t}\n\n\t// ── rendering ─────────────────────────────────────────────────────────────\n\n\tpublic render(): string {\n\t\tconst importLines = this._imports.render();\n\n\t\tconst bodyClassBlocks = this._bodyClasses.map((bc) => {\n\t\t\tconst fields = bc.fields\n\t\t\t\t.map((f) => `\\t${f.decorator}\\n\\tpublic ${f.name}!: ${f.typeName};`)\n\t\t\t\t.join(\"\\n\");\n\t\t\treturn `class ${bc.name} {\\n${fields}\\n}`;\n\t\t});\n\n\t\tconst constructorParams = this._constructorParams\n\t\t\t.map((p) => {\n\t\t\t\tconst prefix = p.paramDecorators.length > 0 ? `${p.paramDecorators.join(\" \")} ` : \"\";\n\t\t\t\tconst access = `${p.isPrivate ? \"private \" : \"\"}${p.isReadonly ? \"readonly \" : \"\"}`;\n\t\t\t\treturn `\\t\\t${prefix}${access}${p.name}: ${p.typeName},`;\n\t\t\t})\n\t\t\t.join(\"\\n\");\n\n\t\tconst methodBlocks = this._methods.map((m) => {\n\t\t\tconst decorators = m.decorators.map((d) => `\\t${d}`).join(\"\\n\");\n\t\t\tconst params = m.params\n\t\t\t\t.map((p) =>\n\t\t\t\t\tp.decorator ? `${p.decorator} ${p.name}: ${p.typeName}` : `${p.name}: ${p.typeName}`,\n\t\t\t\t)\n\t\t\t\t.join(\", \");\n\t\t\tconst asyncKw = m.isAsync ? \"async \" : \"\";\n\t\t\treturn `${decorators}\\n\\tpublic ${asyncKw}${m.name}(${params}) {\\n\\t\\t${m.body}\\n\\t}`;\n\t\t});\n\n\t\tconst sections: string[] = [\n\t\t\timportLines.join(\"\\n\"),\n\t\t\t...bodyClassBlocks,\n\t\t\t[...this._classDecorators, `export class ${this.className} {`].join(\"\\n\"),\n\t\t\t`\\tpublic constructor(\\n${constructorParams}\\n\\t) {}`,\n\t\t\t...methodBlocks,\n\t\t\t\"}\",\n\t\t];\n\n\t\treturn `${sections.join(\"\\n\\n\")}\\n`;\n\t}\n}\n"],"names":["ClassModel","className","fileName","_imports","ImportMap","_classDecorators","_constructorParams","_bodyClasses","_methods","addImport","pkg","names","add","addTypeImport","addType","decorateClass","decorator","includes","unshift","addBodyClass","def","push","addConstructorParam","param","defineMethod","name","decorators","isAsync","params","body","decorateMethod","methodName","method","find","m","render","importLines","bodyClassBlocks","map","bc","fields","f","typeName","join","constructorParams","p","prefix","paramDecorators","length","access","isPrivate","isReadonly","methodBlocks","d","asyncKw","sections"],"mappings":"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"}

package/commonjs/v1/domain/compose.model.js

@@ -0,0 +1,74 @@
+"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 COMPOSE_KEY () {
+        return COMPOSE_KEY;
+    },
+    get ComposeModel () {
+        return ComposeModel;
+    }
+});
+const _context = require("./context.js");
+const COMPOSE_KEY = (0, _context.modelKey)("compose");
+class ComposeModel {
+    _services = new Map();
+    _volumes = new Set();
+    addService(name, config) {
+        this._services.set(name, config);
+        return this;
+    }
+    addVolume(name) {
+        this._volumes.add(name);
+        return this;
+    }
+    render() {
+        const lines = [
+            "services:"
+        ];
+        for (const [name, svc] of this._services){
+            lines.push(`  ${name}:`);
+            if (svc.build) lines.push(`    build: ${svc.build}`);
+            if (svc.image) lines.push(`    image: ${svc.image}`);
+            if (svc.command) lines.push(`    command: ${svc.command}`);
+            if (svc.restart) lines.push(`    restart: ${svc.restart}`);
+            if (svc.env_file && svc.env_file.length > 0) {
+                lines.push("    env_file:");
+                for (const f of svc.env_file)lines.push(`      - ${f}`);
+            }
+            if (svc.environment && Object.keys(svc.environment).length > 0) {
+                lines.push("    environment:");
+                for (const [k, v] of Object.entries(svc.environment)){
+                    lines.push(`      ${k}: ${v}`);
+                }
+            }
+            if (svc.ports && svc.ports.length > 0) {
+                lines.push("    ports:");
+                for (const p of svc.ports)lines.push(`      - "${p}"`);
+            }
+            if (svc.volumes && svc.volumes.length > 0) {
+                lines.push("    volumes:");
+                for (const v of svc.volumes)lines.push(`      - ${v}`);
+            }
+            if (svc.depends_on && svc.depends_on.length > 0) {
+                lines.push("    depends_on:");
+                for (const d of svc.depends_on)lines.push(`      - ${d}`);
+            }
+        }
+        if (this._volumes.size > 0) {
+            lines.push("");
+            lines.push("volumes:");
+            for (const v of this._volumes)lines.push(`  ${v}:`);
+        }
+        return `${lines.join("\n")}\n`;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/v1/domain/context.js

@@ -0,0 +1,53 @@
+"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 FeatureModelStore () {
+        return FeatureModelStore;
+    },
+    get createContext () {
+        return createContext;
+    },
+    get modelKey () {
+        return modelKey;
+    }
+});
+const _nodepath = require("node:path");
+function modelKey(name) {
+    return {
+        _sym: Symbol(name)
+    };
+}
+class FeatureModelStore {
+    _store;
+    constructor(store){
+        this._store = store ?? new Map();
+    }
+    get(key) {
+        return this._store.get(key._sym);
+    }
+    set(key, value) {
+        const next = new Map(this._store);
+        next.set(key._sym, value);
+        return new FeatureModelStore(next);
+    }
+}
+function createContext(targetDir, opts, template = "api") {
+    return {
+        projectName: (0, _nodepath.basename)(targetDir),
+        targetDir,
+        opts,
+        template,
+        models: new FeatureModelStore(),
+        controllers: []
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/v1/domain/devcontainer.model.js

@@ -0,0 +1,116 @@
+"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 DEVCONTAINER_KEY () {
+        return DEVCONTAINER_KEY;
+    },
+    get DevcontainerModel () {
+        return DevcontainerModel;
+    }
+});
+const _context = require("./context.js");
+const _dockerfilemodel = require("./dockerfile.model.js");
+const DEVCONTAINER_KEY = (0, _context.modelKey)("devcontainer");
+class DevcontainerModel {
+    _name;
+    _image;
+    _composeFile = null;
+    _composeService = "app";
+    _dockerfile = null;
+    _extensions = [];
+    _ports = [];
+    _postCreateCommands = [];
+    _postStartCommands = [];
+    _devcontainerFeatures = new Map();
+    constructor(name, image = "node:24"){
+        this._name = name;
+        this._image = image;
+    }
+    get image() {
+        return this._image;
+    }
+    setImage(image) {
+        this._image = image;
+        return this;
+    }
+    /** Switch to Docker Compose mode. Call from a feature that adds a compose service. */ useCompose(file = "docker-compose.yml", service = "devcontainer") {
+        this._composeFile = file;
+        this._composeService = service;
+        this._dockerfile = new _dockerfilemodel.DockerfileModel();
+        return this;
+    }
+    /** The Dockerfile model, available only when in compose mode. */ get dockerfile() {
+        return this._dockerfile;
+    }
+    addExtension(...ids) {
+        for (const id of ids){
+            if (!this._extensions.includes(id)) this._extensions.push(id);
+        }
+        return this;
+    }
+    forwardPort(...ports) {
+        for (const port of ports){
+            if (!this._ports.includes(port)) this._ports.push(port);
+        }
+        return this;
+    }
+    addPostCreateCommand(cmd) {
+        if (!this._postCreateCommands.includes(cmd)) this._postCreateCommands.push(cmd);
+        return this;
+    }
+    addPostStartCommand(cmd) {
+        if (!this._postStartCommands.includes(cmd)) this._postStartCommands.push(cmd);
+        return this;
+    }
+    /** Add a devcontainer Feature, e.g. `ghcr.io/devcontainers/features/node:1`. */ addFeature(id, options = {}) {
+        this._devcontainerFeatures.set(id, options);
+        return this;
+    }
+    render() {
+        const obj = {
+            name: this._name
+        };
+        if (this._composeFile) {
+            obj.dockerComposeFile = [
+                this._composeFile
+            ];
+            obj.service = this._composeService;
+            obj.workspaceFolder = "/workspace";
+            obj.mounts = [
+                "source=..,target=/workspace,type=bind,consistency=cached"
+            ];
+        } else {
+            obj.image = this._image;
+        }
+        if (this._devcontainerFeatures.size > 0) {
+            obj.features = Object.fromEntries(this._devcontainerFeatures);
+        }
+        if (this._extensions.length > 0) {
+            obj.customizations = {
+                vscode: {
+                    extensions: this._extensions
+                }
+            };
+        }
+        if (this._ports.length > 0) {
+            obj.forwardPorts = this._ports;
+        }
+        if (this._postCreateCommands.length > 0) {
+            obj.postCreateCommand = this._postCreateCommands.length === 1 ? this._postCreateCommands[0] : this._postCreateCommands.join(" && ");
+        }
+        if (this._postStartCommands.length > 0) {
+            obj.postStartCommand = this._postStartCommands.length === 1 ? this._postStartCommands[0] : this._postStartCommands.join(" && ");
+        }
+        return `${JSON.stringify(obj, null, 2)}\n`;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/v1/domain/devcontainer.model.ts"],"sourcesContent":["import { modelKey } from \"./context.js\";\nimport { DockerfileModel } from \"./dockerfile.model.js\";\n\nexport const DEVCONTAINER_KEY = modelKey<DevcontainerModel>(\"devcontainer\");\n\n/**\n * Live builder for `.devcontainer/devcontainer.json`.\n *\n * The api-core feature creates an instance in its `configure` phase.\n * Other features (typeorm, auth0, …) call `addExtension` / `addFeature` / etc.\n * in their own `configure` phases.  The devcontainer `render` phase calls `render()`.\n */\nexport class DevcontainerModel {\n\tprivate readonly _name: string;\n\tprivate _image: string;\n\tprivate _composeFile: string | null = null;\n\tprivate _composeService = \"app\";\n\tprivate _dockerfile: DockerfileModel | null = null;\n\tprivate readonly _extensions: string[] = [];\n\tprivate readonly _ports: number[] = [];\n\tprivate readonly _postCreateCommands: string[] = [];\n\tprivate readonly _postStartCommands: string[] = [];\n\tprivate readonly _devcontainerFeatures: Map<string, Record<string, unknown>> = new Map();\n\n\tpublic constructor(name: string, image = \"node:24\") {\n\t\tthis._name = name;\n\t\tthis._image = image;\n\t}\n\n\tpublic get image(): string {\n\t\treturn this._image;\n\t}\n\n\tpublic setImage(image: string): this {\n\t\tthis._image = image;\n\t\treturn this;\n\t}\n\n\t/** Switch to Docker Compose mode. Call from a feature that adds a compose service. */\n\tpublic useCompose(file = \"docker-compose.yml\", service = \"devcontainer\"): this {\n\t\tthis._composeFile = file;\n\t\tthis._composeService = service;\n\t\tthis._dockerfile = new DockerfileModel();\n\t\treturn this;\n\t}\n\n\t/** The Dockerfile model, available only when in compose mode. */\n\tpublic get dockerfile(): DockerfileModel | null {\n\t\treturn this._dockerfile;\n\t}\n\n\tpublic addExtension(...ids: string[]): this {\n\t\tfor (const id of ids) {\n\t\t\tif (!this._extensions.includes(id)) this._extensions.push(id);\n\t\t}\n\t\treturn this;\n\t}\n\n\tpublic forwardPort(...ports: number[]): this {\n\t\tfor (const port of ports) {\n\t\t\tif (!this._ports.includes(port)) this._ports.push(port);\n\t\t}\n\t\treturn this;\n\t}\n\n\tpublic addPostCreateCommand(cmd: string): this {\n\t\tif (!this._postCreateCommands.includes(cmd)) this._postCreateCommands.push(cmd);\n\t\treturn this;\n\t}\n\n\tpublic addPostStartCommand(cmd: string): this {\n\t\tif (!this._postStartCommands.includes(cmd)) this._postStartCommands.push(cmd);\n\t\treturn this;\n\t}\n\n\t/** Add a devcontainer Feature, e.g. `ghcr.io/devcontainers/features/node:1`. */\n\tpublic addFeature(id: string, options: Record<string, unknown> = {}): this {\n\t\tthis._devcontainerFeatures.set(id, options);\n\t\treturn this;\n\t}\n\n\tpublic render(): string {\n\t\tconst obj: Record<string, unknown> = { name: this._name };\n\n\t\tif (this._composeFile) {\n\t\t\tobj.dockerComposeFile = [this._composeFile];\n\t\t\tobj.service = this._composeService;\n\t\t\tobj.workspaceFolder = \"/workspace\";\n\t\t\tobj.mounts = [\"source=..,target=/workspace,type=bind,consistency=cached\"];\n\t\t} else {\n\t\t\tobj.image = this._image;\n\t\t}\n\n\t\tif (this._devcontainerFeatures.size > 0) {\n\t\t\tobj.features = Object.fromEntries(this._devcontainerFeatures);\n\t\t}\n\n\t\tif (this._extensions.length > 0) {\n\t\t\tobj.customizations = {\n\t\t\t\tvscode: {\n\t\t\t\t\textensions: this._extensions,\n\t\t\t\t},\n\t\t\t};\n\t\t}\n\n\t\tif (this._ports.length > 0) {\n\t\t\tobj.forwardPorts = this._ports;\n\t\t}\n\n\t\tif (this._postCreateCommands.length > 0) {\n\t\t\tobj.postCreateCommand =\n\t\t\t\tthis._postCreateCommands.length === 1\n\t\t\t\t\t? this._postCreateCommands[0]\n\t\t\t\t\t: this._postCreateCommands.join(\" && \");\n\t\t}\n\n\t\tif (this._postStartCommands.length > 0) {\n\t\t\tobj.postStartCommand =\n\t\t\t\tthis._postStartCommands.length === 1\n\t\t\t\t\t? this._postStartCommands[0]\n\t\t\t\t\t: this._postStartCommands.join(\" && \");\n\t\t}\n\n\t\treturn `${JSON.stringify(obj, null, 2)}\\n`;\n\t}\n}\n"],"names":["DEVCONTAINER_KEY","DevcontainerModel","modelKey","_name","_image","_composeFile","_composeService","_dockerfile","_extensions","_ports","_postCreateCommands","_postStartCommands","_devcontainerFeatures","Map","name","image","setImage","useCompose","file","service","DockerfileModel","dockerfile","addExtension","ids","id","includes","push","forwardPort","ports","port","addPostCreateCommand","cmd","addPostStartCommand","addFeature","options","set","render","obj","dockerComposeFile","workspaceFolder","mounts","size","features","Object","fromEntries","length","customizations","vscode","extensions","forwardPorts","postCreateCommand","join","postStartCommand","JSON","stringify"],"mappings":"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"}