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

package/commonjs/v1/features/api-core/main-ts.model.js

@@ -0,0 +1,85 @@
+"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 MAIN_TS_KEY () {
+        return MAIN_TS_KEY;
+    },
+    get MainTsModel () {
+        return MainTsModel;
+    }
+});
+const _importmap = require("../../domain/import-map.js");
+const _index = require("../../domain/index.js");
+const MAIN_TS_KEY = (0, _index.modelKey)("main-ts");
+class MainTsModel {
+    _applicationName;
+    _imports;
+    _builderChain;
+    _controllers = [];
+    constructor(applicationName){
+        this._applicationName = applicationName;
+        // Standard framework imports — insertion order matches desired output order.
+        this._imports = new _importmap.ImportMap().add("@decohere/scribe-pino").add("@decohere/cortex/http").add("@decohere/cortex/auth").add("@decohere/protocol").add("@decohere/cortex", "Builder").add("@decohere/cortex/providers", "FastifyProvider").add("@decohere/scribe", "scribe").add("@decohere/protocol", "YamlDataSource").add("./sample.service.js", "SampleService");
+        // Standard builder chain — features append; render appends .withControllers + .build.
+        this._builderChain = [
+            `.withHttpProvider(FastifyProvider)`,
+            `.withConfiguration(YamlDataSource)`,
+            `.withAuth()`,
+            `.withServices((cb) => { cb.registerSingleton(SampleService); })`
+        ];
+    }
+    // ── feature API ──────────────────────────────────────────────────────────
+    /** Add named value imports (or side-effect when called with no names). */ addImport(pkg, ...names) {
+        this._imports.add(pkg, ...names);
+        return this;
+    }
+    /** Add named type-only imports. */ addTypeImport(pkg, ...names) {
+        this._imports.addType(pkg, ...names);
+        return this;
+    }
+    /**
+	 * Append a builder chain call inserted between `.withServices(…)` and
+	 * `.withControllers(…)`.  Pass the call with its leading dot,
+	 * e.g. `.withTypeOrm({ … })`.
+	 */ appendBuilderChain(call) {
+        this._builderChain.push(call);
+        return this;
+    }
+    // ── render-phase API ─────────────────────────────────────────────────────
+    /** Register a controller; adds its import and queues it for withControllers(). */ addController(model) {
+        const importPath = `./controllers/${model.fileName.replace(/\.ts$/, ".js")}`;
+        this._imports.add(importPath, model.className);
+        this._controllers.push({
+            className: model.className,
+            importPath
+        });
+        return this;
+    }
+    // ── rendering ─────────────────────────────────────────────────────────────
+    render() {
+        const controllersArg = this._controllers.map((c)=>c.className).join(", ");
+        const chainCalls = [
+            ...this._builderChain,
+            `.withControllers(${controllersArg})`,
+            `.build();`
+        ].map((call)=>`\t${call}`).join("\n");
+        const importSection = this._imports.render().join("\n");
+        return `${[
+            importSection,
+            `scribe.extend.withPinoPretty();`,
+            `const app = await Builder.create({ applicationName: "${this._applicationName}" })\n${chainCalls}`,
+            `await app.start({ port: 3000 });`,
+            `export default app;`
+        ].join("\n\n")}\n`;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/v1/features/api-core/main-ts.model.ts"],"sourcesContent":["import type { ClassModel } from \"../../domain/class-model.js\";\nimport { ImportMap } from \"../../domain/import-map.js\";\nimport { modelKey } from \"../../domain/index.js\";\n\n/** Key for retrieving the MainTsModel from the FeatureModelStore. */\nexport const MAIN_TS_KEY = modelKey<MainTsModel>(\"main-ts\");\n\n/**\n * Live builder for `projects/api/src/main.ts`.\n *\n * The api-core feature creates an instance in its `configure` phase.\n * Other features (typeorm, auth0, …) call `addImport` / `appendBuilderChain`\n * in their own `configure` phases.  The api-core `render` phase calls\n * `addController(model)` for each controller, then `render()`.\n */\nexport class MainTsModel {\n\tprivate readonly _applicationName: string;\n\tprivate readonly _imports: ImportMap;\n\tprivate readonly _builderChain: string[];\n\tprivate readonly _controllers: Array<{ className: string; importPath: string }> = [];\n\n\tpublic constructor(applicationName: string) {\n\t\tthis._applicationName = applicationName;\n\n\t\t// Standard framework imports — insertion order matches desired output order.\n\t\tthis._imports = new ImportMap()\n\t\t\t.add(\"@decohere/scribe-pino\")\n\t\t\t.add(\"@decohere/cortex/http\")\n\t\t\t.add(\"@decohere/cortex/auth\")\n\t\t\t.add(\"@decohere/protocol\")\n\t\t\t.add(\"@decohere/cortex\", \"Builder\")\n\t\t\t.add(\"@decohere/cortex/providers\", \"FastifyProvider\")\n\t\t\t.add(\"@decohere/scribe\", \"scribe\")\n\t\t\t.add(\"@decohere/protocol\", \"YamlDataSource\")\n\t\t\t.add(\"./sample.service.js\", \"SampleService\");\n\n\t\t// Standard builder chain — features append; render appends .withControllers + .build.\n\t\tthis._builderChain = [\n\t\t\t`.withHttpProvider(FastifyProvider)`,\n\t\t\t`.withConfiguration(YamlDataSource)`,\n\t\t\t`.withAuth()`,\n\t\t\t`.withServices((cb) => { cb.registerSingleton(SampleService); })`,\n\t\t];\n\t}\n\n\t// ── feature API ──────────────────────────────────────────────────────────\n\n\t/** Add named value imports (or side-effect when called with no names). */\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. */\n\tpublic addTypeImport(pkg: string, ...names: string[]): this {\n\t\tthis._imports.addType(pkg, ...names);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Append a builder chain call inserted between `.withServices(…)` and\n\t * `.withControllers(…)`.  Pass the call with its leading dot,\n\t * e.g. `.withTypeOrm({ … })`.\n\t */\n\tpublic appendBuilderChain(call: string): this {\n\t\tthis._builderChain.push(call);\n\t\treturn this;\n\t}\n\n\t// ── render-phase API ─────────────────────────────────────────────────────\n\n\t/** Register a controller; adds its import and queues it for withControllers(). */\n\tpublic addController(model: ClassModel): this {\n\t\tconst importPath = `./controllers/${model.fileName.replace(/\\.ts$/, \".js\")}`;\n\t\tthis._imports.add(importPath, model.className);\n\t\tthis._controllers.push({ className: model.className, importPath });\n\t\treturn this;\n\t}\n\n\t// ── rendering ─────────────────────────────────────────────────────────────\n\n\tpublic render(): string {\n\t\tconst controllersArg = this._controllers.map((c) => c.className).join(\", \");\n\n\t\tconst chainCalls = [\n\t\t\t...this._builderChain,\n\t\t\t`.withControllers(${controllersArg})`,\n\t\t\t`.build();`,\n\t\t]\n\t\t\t.map((call) => `\\t${call}`)\n\t\t\t.join(\"\\n\");\n\n\t\tconst importSection = this._imports.render().join(\"\\n\");\n\n\t\treturn `${[\n\t\t\timportSection,\n\t\t\t`scribe.extend.withPinoPretty();`,\n\t\t\t`const app = await Builder.create({ applicationName: \"${this._applicationName}\" })\\n${chainCalls}`,\n\t\t\t`await app.start({ port: 3000 });`,\n\t\t\t`export default app;`,\n\t\t].join(\"\\n\\n\")}\\n`;\n\t}\n}\n"],"names":["MAIN_TS_KEY","MainTsModel","modelKey","_applicationName","_imports","_builderChain","_controllers","applicationName","ImportMap","add","addImport","pkg","names","addTypeImport","addType","appendBuilderChain","call","push","addController","model","importPath","fileName","replace","className","render","controllersArg","map","c","join","chainCalls","importSection"],"mappings":";;;;;;;;;;;QAKaA;eAAAA;;QAUAC;eAAAA;;;2BAda;uBACD;AAGlB,MAAMD,cAAcE,IAAAA,eAAQ,EAAc;AAU1C,MAAMD;IACKE,iBAAyB;IACzBC,SAAoB;IACpBC,cAAwB;IACxBC,eAAiE,EAAE,CAAC;IAErF,YAAmBC,eAAuB,CAAE;QAC3C,IAAI,CAACJ,gBAAgB,GAAGI;QAExB,6EAA6E;QAC7E,IAAI,CAACH,QAAQ,GAAG,IAAII,oBAAS,GAC3BC,GAAG,CAAC,yBACJA,GAAG,CAAC,yBACJA,GAAG,CAAC,yBACJA,GAAG,CAAC,sBACJA,GAAG,CAAC,oBAAoB,WACxBA,GAAG,CAAC,8BAA8B,mBAClCA,GAAG,CAAC,oBAAoB,UACxBA,GAAG,CAAC,sBAAsB,kBAC1BA,GAAG,CAAC,uBAAuB;QAE7B,sFAAsF;QACtF,IAAI,CAACJ,aAAa,GAAG;YACpB,CAAC,kCAAkC,CAAC;YACpC,CAAC,kCAAkC,CAAC;YACpC,CAAC,WAAW,CAAC;YACb,CAAC,+DAA+D,CAAC;SACjE;IACF;IAEA,4EAA4E;IAE5E,wEAAwE,GACxE,AAAOK,UAAUC,GAAW,EAAE,GAAGC,KAAe,EAAQ;QACvD,IAAI,CAACR,QAAQ,CAACK,GAAG,CAACE,QAAQC;QAC1B,OAAO,IAAI;IACZ;IAEA,iCAAiC,GACjC,AAAOC,cAAcF,GAAW,EAAE,GAAGC,KAAe,EAAQ;QAC3D,IAAI,CAACR,QAAQ,CAACU,OAAO,CAACH,QAAQC;QAC9B,OAAO,IAAI;IACZ;IAEA;;;;EAIC,GACD,AAAOG,mBAAmBC,IAAY,EAAQ;QAC7C,IAAI,CAACX,aAAa,CAACY,IAAI,CAACD;QACxB,OAAO,IAAI;IACZ;IAEA,4EAA4E;IAE5E,gFAAgF,GAChF,AAAOE,cAAcC,KAAiB,EAAQ;QAC7C,MAAMC,aAAa,CAAC,cAAc,EAAED,MAAME,QAAQ,CAACC,OAAO,CAAC,SAAS,QAAQ;QAC5E,IAAI,CAAClB,QAAQ,CAACK,GAAG,CAACW,YAAYD,MAAMI,SAAS;QAC7C,IAAI,CAACjB,YAAY,CAACW,IAAI,CAAC;YAAEM,WAAWJ,MAAMI,SAAS;YAAEH;QAAW;QAChE,OAAO,IAAI;IACZ;IAEA,6EAA6E;IAEtEI,SAAiB;QACvB,MAAMC,iBAAiB,IAAI,CAACnB,YAAY,CAACoB,GAAG,CAAC,CAACC,IAAMA,EAAEJ,SAAS,EAAEK,IAAI,CAAC;QAEtE,MAAMC,aAAa;eACf,IAAI,CAACxB,aAAa;YACrB,CAAC,iBAAiB,EAAEoB,eAAe,CAAC,CAAC;YACrC,CAAC,SAAS,CAAC;SACX,CACCC,GAAG,CAAC,CAACV,OAAS,CAAC,EAAE,EAAEA,MAAM,EACzBY,IAAI,CAAC;QAEP,MAAME,gBAAgB,IAAI,CAAC1B,QAAQ,CAACoB,MAAM,GAAGI,IAAI,CAAC;QAElD,OAAO,GAAG;YACTE;YACA,CAAC,+BAA+B,CAAC;YACjC,CAAC,qDAAqD,EAAE,IAAI,CAAC3B,gBAAgB,CAAC,MAAM,EAAE0B,YAAY;YAClG,CAAC,gCAAgC,CAAC;YAClC,CAAC,mBAAmB,CAAC;SACrB,CAACD,IAAI,CAAC,QAAQ,EAAE,CAAC;IACnB;AACD"}

package/commonjs/v1/features/api-core/scaffold-files.template.js

@@ -0,0 +1,158 @@
+"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 CONFIG_DEV_YAML () {
+        return CONFIG_DEV_YAML;
+    },
+    get GITIGNORE () {
+        return GITIGNORE;
+    },
+    get SAMPLE_CONFIG_TS () {
+        return SAMPLE_CONFIG_TS;
+    },
+    get SAMPLE_SERVICE_TS () {
+        return SAMPLE_SERVICE_TS;
+    },
+    get TSCONFIG () {
+        return TSCONFIG;
+    },
+    get VSCODE_LAUNCH_JSON () {
+        return VSCODE_LAUNCH_JSON;
+    },
+    get apiPackageJson () {
+        return apiPackageJson;
+    },
+    get configYaml () {
+        return configYaml;
+    },
+    get rootPackageJson () {
+        return rootPackageJson;
+    },
+    get vscodeSettingsJson () {
+        return vscodeSettingsJson;
+    }
+});
+const _version = require("../../version.js");
+function rootPackageJson(name) {
+    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: {
+            "@decohere/cortex": _version.CREATE_VERSION,
+            "@decohere/crucible": _version.CREATE_VERSION,
+            "@decohere/nexus": _version.CREATE_VERSION,
+            "@decohere/protocol": _version.CREATE_VERSION,
+            "@decohere/scribe": _version.CREATE_VERSION,
+            "@decohere/scribe-pino": _version.CREATE_VERSION,
+            "pino-pretty": "^13.0.0"
+        },
+        devDependencies: {
+            "@decohere/terminal": _version.CREATE_VERSION,
+            typescript: "^6.0.3"
+        }
+    }, null, 2);
+}
+function apiPackageJson(name) {
+    return JSON.stringify({
+        name: `@${name}/api`,
+        version: "0.0.1",
+        type: "module",
+        main: "src/main.ts",
+        dependencies: {
+            "@decohere/cortex": _version.CREATE_VERSION,
+            "@decohere/crucible": _version.CREATE_VERSION
+        }
+    }, null, 2);
+}
+const TSCONFIG = JSON.stringify({
+    compilerOptions: {
+        target: "ES2022",
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        strict: true,
+        skipLibCheck: true,
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true
+    }
+}, null, 2);
+const VSCODE_LAUNCH_JSON = JSON.stringify({
+    version: "0.2.0",
+    configurations: [
+        {
+            name: "Build",
+            type: "node",
+            request: "launch",
+            runtimeExecutable: "pnpm",
+            runtimeArgs: [
+                "build"
+            ],
+            console: "integratedTerminal",
+            cwd: `\${workspaceFolder}`
+        },
+        {
+            name: "Serve / Dev",
+            type: "node",
+            request: "launch",
+            runtimeExecutable: "pnpm",
+            runtimeArgs: [
+                "dev"
+            ],
+            console: "integratedTerminal",
+            cwd: `\${workspaceFolder}`
+        }
+    ]
+}, null, 2);
+function vscodeSettingsJson(name) {
+    return JSON.stringify({
+        "window.title": `${name}\${separator}\${activeEditorShort}`,
+        "window.titleSeparator": " | "
+    }, null, 2);
+}
+const GITIGNORE = `node_modules/
+dist/
+.env.local
+.pnpm-store
+`;
+function configYaml() {
+    return `sample:\n  greeting: Hello from configuration!\n`;
+}
+const CONFIG_DEV_YAML = `sample:
+  greeting: Hello from dev configuration!
+`;
+const SAMPLE_CONFIG_TS = `export class SampleConfig {
+\tpublic 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 {
+\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}
+}
+`;
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/v1/features/auth0/auth0-cli.js

@@ -0,0 +1,151 @@
+"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 Auth0AuthError () {
+        return Auth0AuthError;
+    },
+    get REQUIRED_SCOPES () {
+        return REQUIRED_SCOPES;
+    },
+    get createApi () {
+        return createApi;
+    },
+    get createSpaApp () {
+        return createSpaApp;
+    },
+    get isInstalled () {
+        return isInstalled;
+    },
+    get listApis () {
+        return listApis;
+    },
+    get listTenants () {
+        return listTenants;
+    },
+    get login () {
+        return login;
+    }
+});
+const _nodechild_process = require("node:child_process");
+const REQUIRED_SCOPES = "create:clients";
+/** Hard timeout for any Management API call. Prevents indefinite hangs on token re-auth. */ const API_TIMEOUT_MS = 8_000;
+class Auth0AuthError extends Error {
+    constructor(message){
+        super(message);
+        this.name = "Auth0AuthError";
+    }
+}
+/** Returns true if an error or stderr output looks like an expired/missing token. */ function isAuthError(text) {
+    return text.includes("renew access token") || text.includes("log in") || text.includes("Unauthorized");
+}
+/** Run an auth0 CLI command with a hard timeout. Returns stdout on success, throws on failure. */ function runAuth0(args) {
+    const result = (0, _nodechild_process.spawnSync)("auth0", args, {
+        encoding: "utf8",
+        timeout: API_TIMEOUT_MS,
+        input: "",
+        stdio: "pipe"
+    });
+    if (result.error) {
+        // ETIMEDOUT means the process was killed by the timeout
+        const msg = result.error.message;
+        if (isAuthError(msg) || result.error.code === "ETIMEDOUT") {
+            throw new Auth0AuthError(msg);
+        }
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        const stderr = result.stderr ?? "";
+        if (isAuthError(stderr)) throw new Auth0AuthError(stderr);
+        throw new Error(stderr || `auth0 exited with code ${result.status}`);
+    }
+    return result.stdout;
+}
+function isInstalled() {
+    try {
+        (0, _nodechild_process.execFileSync)("auth0", [
+            "--version"
+        ], {
+            stdio: "pipe"
+        });
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function listTenants() {
+    try {
+        const out = (0, _nodechild_process.execFileSync)("auth0", [
+            "tenants",
+            "list",
+            "--json"
+        ], {
+            encoding: "utf8",
+            stdio: "pipe"
+        });
+        return JSON.parse(out);
+    } catch  {
+        return [];
+    }
+}
+function login() {
+    const result = (0, _nodechild_process.spawnSync)("auth0", [
+        "login",
+        "--scopes",
+        REQUIRED_SCOPES
+    ], {
+        stdio: "inherit"
+    });
+    return result.status === 0;
+}
+function listApis() {
+    try {
+        const out = runAuth0([
+            "apis",
+            "list",
+            "--json",
+            "--no-input"
+        ]);
+        return JSON.parse(out);
+    } catch (err) {
+        if (err instanceof Auth0AuthError) throw err;
+        return [];
+    }
+}
+function createApi(name, identifier) {
+    const out = runAuth0([
+        "apis",
+        "create",
+        "--name",
+        name,
+        "--identifier",
+        identifier,
+        "--json",
+        "--no-input"
+    ]);
+    return JSON.parse(out);
+}
+function createSpaApp(name, callbackUrl) {
+    const out = runAuth0([
+        "apps",
+        "create",
+        "--name",
+        name,
+        "--type",
+        "spa",
+        "--callbacks",
+        callbackUrl,
+        "--json",
+        "--no-input"
+    ]);
+    return JSON.parse(out);
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "auth0Feature", {
+    enumerable: true,
+    get: function() {
+        return auth0Feature;
+    }
+});
+const _promises = require("node:fs/promises");
+const _nodepath = require("node:path");
+const _index = require("../../domain/index.js");
+const _auth0cli = /*#__PURE__*/ _interop_require_wildcard(require("./auth0-cli.js"));
+const _models = require("./models.js");
+const _prodconfigtemplate = require("./prod-config.template.js");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const enabled = (ctx)=>ctx.opts.idp === "auth0";
+/**
+ * Resolve phase: drive the auth0 CLI to authenticate the user and gather an
+ * issuer + audience pair. Stored under AUTH0_CONFIG_KEY for downstream
+ * features (render, postman integrate).
+ *
+ * Skipped under --yes (non-interactive).
+ */ async function resolve(ctx) {
+    if (ctx.opts.yes) return ctx;
+    if (!_auth0cli.isInstalled()) {
+        console.error("\n  The Auth0 CLI is required for automated setup.\n" + "  Install: brew install auth0/auth0-cli/auth0\n" + "  Or visit: https://github.com/auth0/auth0-cli\n");
+        process.exit(1);
+    }
+    // Ensure both the regular and Management API tokens are valid before prompting.
+    process.stdout.write("\n  Checking Auth0 credentials...");
+    let tenants = _auth0cli.listTenants();
+    if (tenants.length === 0) {
+        process.stdout.write(" not logged in.\n");
+        console.log("  Logging in to Auth0 (your browser will open)...");
+        if (!_auth0cli.login()) {
+            console.error("\n  Auth0 login failed.");
+            process.exit(1);
+        }
+        tenants = _auth0cli.listTenants();
+    }
+    try {
+        _auth0cli.listApis(); // probes the Management API token
+        process.stdout.write(" ok.\n");
+    } catch (err) {
+        if (err instanceof _auth0cli.Auth0AuthError) {
+            process.stdout.write(" token expired.\n");
+            console.log("  Re-authenticating (your browser will open)...");
+            if (!_auth0cli.login()) {
+                console.error("\n  Auth0 login failed.");
+                process.exit(1);
+            }
+        }
+    }
+    const active = tenants.find((t)=>t.active) ?? tenants[0];
+    const issuerBaseUrl = `https://${active.name}`;
+    console.log(`\n  ✓ Auth0 tenant: ${issuerBaseUrl}`);
+    process.stdout.write("\n  Fetching Auth0 APIs...");
+    const userApis = _auth0cli.listApis().filter((a)=>!a.name.includes("Management API"));
+    process.stdout.write(` found ${userApis.length}.\n`);
+    const choices = [
+        {
+            label: `<new> https://api.${ctx.projectName}`,
+            existing: null
+        },
+        ...userApis.map((a)=>({
+                label: `${a.name} — ${a.identifier}`,
+                existing: a.identifier
+            }))
+    ];
+    const selected = await (0, _index.pick)("\n  Select Auth0 API: ", choices, (c)=>c.label);
+    let audience;
+    if (!selected || selected.existing === null) {
+        const defaultId = `https://api.${ctx.projectName}`;
+        audience = await (0, _index.ask)(`  API Identifier [${defaultId}]: `, defaultId);
+        console.log("\n  Creating Auth0 API...");
+        audience = _auth0cli.createApi(`${ctx.projectName} API`, audience).identifier;
+        console.log(`  ✓ API created: ${audience}`);
+    } else {
+        audience = selected.existing;
+        console.log(`  ✓ Selected: ${audience}`);
+    }
+    return {
+        ...ctx,
+        models: ctx.models.set(_models.AUTH0_CONFIG_KEY, {
+            issuerBaseUrl,
+            audience
+        })
+    };
+}
+/**
+ * Configure phase: decorate all scaffolded controllers with auth guards.
+ * Adds `@Authorize`, `@AllowAnonymous`, and the `IPrincipalProvider`
+ * constructor param so each controller can expose the current principal.
+ */ async function configure(ctx) {
+    if (!enabled(ctx)) return ctx;
+    for (const controller of ctx.controllers){
+        const resource = controller.className.replace(/Controller$/, "");
+        controller.addImport("@decohere/cortex", "AllowAnonymous", "Authorize", "IPrincipalProviderToken").addTypeImport("@decohere/cortex", "IPrincipalProvider").addImport("@decohere/crucible/decorators", "inject").decorateClass(`@Authorize("read", "${resource}")`).decorateMethod("getAll", "@AllowAnonymous()").decorateMethod("remove", `@Authorize("delete", "${resource}")`).addConstructorParam({
+            paramDecorators: [
+                "@inject(IPrincipalProviderToken)"
+            ],
+            name: "principalProvider",
+            typeName: "IPrincipalProvider",
+            isPrivate: true,
+            isReadonly: true
+        });
+    }
+    return ctx;
+}
+/**
+ * Render phase: append the auth section to config/config.prod.yaml. If no
+ * Auth0Config was gathered during resolve (e.g. --yes), env-var placeholders
+ * are written instead.
+ */ async function render(ctx) {
+    const { targetDir } = ctx;
+    const auth0Config = ctx.models.get(_models.AUTH0_CONFIG_KEY);
+    // Append env-var placeholder auth block to the base config.yaml
+    const baseConfigPath = (0, _nodepath.join)(targetDir, "config", "config.yaml");
+    let baseExisting = "";
+    try {
+        baseExisting = await (0, _promises.readFile)(baseConfigPath, "utf8");
+    } catch  {}
+    const baseStripped = baseExisting.replace(/^auth:[\s\S]*?(?=\n\S|\n*$)/m, "").trimEnd();
+    const baseFrag = (0, _prodconfigtemplate.auth0ConfigYaml)();
+    await (0, _promises.writeFile)(baseConfigPath, baseStripped ? `${baseStripped}\n${baseFrag}` : baseFrag);
+    // Append actual dev auth URLs to config.dev.yaml
+    const devConfigPath = (0, _nodepath.join)(targetDir, "config", "config.dev.yaml");
+    let devExisting = "";
+    try {
+        devExisting = await (0, _promises.readFile)(devConfigPath, "utf8");
+    } catch  {}
+    const devStripped = devExisting.replace(/^auth:[\s\S]*?(?=\n\S|\n*$)/m, "").trimEnd();
+    const devFragment = (0, _prodconfigtemplate.auth0ConfigYaml)(auth0Config?.issuerBaseUrl, auth0Config?.audience);
+    await (0, _promises.writeFile)(devConfigPath, devStripped ? `${devStripped}\n\n${devFragment}` : devFragment);
+    return ctx;
+}
+const auth0Feature = {
+    name: "auth0",
+    enabled,
+    resolve,
+    configure,
+    render
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/v1/features/auth0/feature.ts"],"sourcesContent":["import { readFile, writeFile } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { ask, type Feature, pick, type ScaffoldContext } from \"../../domain/index.js\";\nimport * as auth0 from \"./auth0-cli.js\";\nimport { AUTH0_CONFIG_KEY } from \"./models.js\";\nimport { auth0ConfigYaml } from \"./prod-config.template.js\";\n\nconst enabled = (ctx: ScaffoldContext) => ctx.opts.idp === \"auth0\";\n\n/**\n * Resolve phase: drive the auth0 CLI to authenticate the user and gather an\n * issuer + audience pair. Stored under AUTH0_CONFIG_KEY for downstream\n * features (render, postman integrate).\n *\n * Skipped under --yes (non-interactive).\n */\nasync function resolve(ctx: ScaffoldContext): Promise<ScaffoldContext> {\n\tif (ctx.opts.yes) return ctx;\n\n\tif (!auth0.isInstalled()) {\n\t\tconsole.error(\n\t\t\t\"\\n  The Auth0 CLI is required for automated setup.\\n\" +\n\t\t\t\t\"  Install: brew install auth0/auth0-cli/auth0\\n\" +\n\t\t\t\t\"  Or visit: https://github.com/auth0/auth0-cli\\n\",\n\t\t);\n\t\tprocess.exit(1);\n\t}\n\n\t// Ensure both the regular and Management API tokens are valid before prompting.\n\tprocess.stdout.write(\"\\n  Checking Auth0 credentials...\");\n\tlet tenants = auth0.listTenants();\n\tif (tenants.length === 0) {\n\t\tprocess.stdout.write(\" not logged in.\\n\");\n\t\tconsole.log(\"  Logging in to Auth0 (your browser will open)...\");\n\t\tif (!auth0.login()) {\n\t\t\tconsole.error(\"\\n  Auth0 login failed.\");\n\t\t\tprocess.exit(1);\n\t\t}\n\t\ttenants = auth0.listTenants();\n\t}\n\n\ttry {\n\t\tauth0.listApis(); // probes the Management API token\n\t\tprocess.stdout.write(\" ok.\\n\");\n\t} catch (err) {\n\t\tif (err instanceof auth0.Auth0AuthError) {\n\t\t\tprocess.stdout.write(\" token expired.\\n\");\n\t\t\tconsole.log(\"  Re-authenticating (your browser will open)...\");\n\t\t\tif (!auth0.login()) {\n\t\t\t\tconsole.error(\"\\n  Auth0 login failed.\");\n\t\t\t\tprocess.exit(1);\n\t\t\t}\n\t\t}\n\t}\n\n\tconst active = tenants.find((t) => t.active) ?? tenants[0];\n\tconst issuerBaseUrl = `https://${active.name}`;\n\tconsole.log(`\\n  ✓ Auth0 tenant: ${issuerBaseUrl}`);\n\n\tprocess.stdout.write(\"\\n  Fetching Auth0 APIs...\");\n\tconst userApis = auth0.listApis().filter((a) => !a.name.includes(\"Management API\"));\n\tprocess.stdout.write(` found ${userApis.length}.\\n`);\n\n\ttype ApiChoice = { label: string; existing: string | null };\n\tconst choices: ApiChoice[] = [\n\t\t{ label: `<new> https://api.${ctx.projectName}`, existing: null },\n\t\t...userApis.map((a) => ({ label: `${a.name} — ${a.identifier}`, existing: a.identifier })),\n\t];\n\n\tconst selected = await pick(\"\\n  Select Auth0 API: \", choices, (c) => c.label);\n\n\tlet audience: string;\n\tif (!selected || selected.existing === null) {\n\t\tconst defaultId = `https://api.${ctx.projectName}`;\n\t\taudience = await ask(`  API Identifier [${defaultId}]: `, defaultId);\n\t\tconsole.log(\"\\n  Creating Auth0 API...\");\n\t\taudience = auth0.createApi(`${ctx.projectName} API`, audience).identifier;\n\t\tconsole.log(`  ✓ API created: ${audience}`);\n\t} else {\n\t\taudience = selected.existing;\n\t\tconsole.log(`  ✓ Selected: ${audience}`);\n\t}\n\n\treturn {\n\t\t...ctx,\n\t\tmodels: ctx.models.set(AUTH0_CONFIG_KEY, { issuerBaseUrl, audience }),\n\t};\n}\n\n/**\n * Configure phase: decorate all scaffolded controllers with auth guards.\n * Adds `@Authorize`, `@AllowAnonymous`, and the `IPrincipalProvider`\n * constructor param so each controller can expose the current principal.\n */\nasync function configure(ctx: ScaffoldContext): Promise<ScaffoldContext> {\n\tif (!enabled(ctx)) return ctx;\n\tfor (const controller of ctx.controllers) {\n\t\tconst resource = controller.className.replace(/Controller$/, \"\");\n\t\tcontroller\n\t\t\t.addImport(\"@decohere/cortex\", \"AllowAnonymous\", \"Authorize\", \"IPrincipalProviderToken\")\n\t\t\t.addTypeImport(\"@decohere/cortex\", \"IPrincipalProvider\")\n\t\t\t.addImport(\"@decohere/crucible/decorators\", \"inject\")\n\t\t\t.decorateClass(`@Authorize(\"read\", \"${resource}\")`)\n\t\t\t.decorateMethod(\"getAll\", \"@AllowAnonymous()\")\n\t\t\t.decorateMethod(\"remove\", `@Authorize(\"delete\", \"${resource}\")`)\n\t\t\t.addConstructorParam({\n\t\t\t\tparamDecorators: [\"@inject(IPrincipalProviderToken)\"],\n\t\t\t\tname: \"principalProvider\",\n\t\t\t\ttypeName: \"IPrincipalProvider\",\n\t\t\t\tisPrivate: true,\n\t\t\t\tisReadonly: true,\n\t\t\t});\n\t}\n\treturn ctx;\n}\n\n/**\n * Render phase: append the auth section to config/config.prod.yaml. If no\n * Auth0Config was gathered during resolve (e.g. --yes), env-var placeholders\n * are written instead.\n */\nasync function render(ctx: ScaffoldContext): Promise<ScaffoldContext> {\n\tconst { targetDir } = ctx;\n\tconst auth0Config = ctx.models.get(AUTH0_CONFIG_KEY);\n\n\t// Append env-var placeholder auth block to the base config.yaml\n\tconst baseConfigPath = join(targetDir, \"config\", \"config.yaml\");\n\tlet baseExisting = \"\";\n\ttry {\n\t\tbaseExisting = await readFile(baseConfigPath, \"utf8\");\n\t} catch {}\n\tconst baseStripped = baseExisting.replace(/^auth:[\\s\\S]*?(?=\\n\\S|\\n*$)/m, \"\").trimEnd();\n\tconst baseFrag = auth0ConfigYaml();\n\tawait writeFile(baseConfigPath, baseStripped ? `${baseStripped}\\n${baseFrag}` : baseFrag);\n\n\t// Append actual dev auth URLs to config.dev.yaml\n\tconst devConfigPath = join(targetDir, \"config\", \"config.dev.yaml\");\n\tlet devExisting = \"\";\n\ttry {\n\t\tdevExisting = await readFile(devConfigPath, \"utf8\");\n\t} catch {}\n\tconst devStripped = devExisting.replace(/^auth:[\\s\\S]*?(?=\\n\\S|\\n*$)/m, \"\").trimEnd();\n\tconst devFragment = auth0ConfigYaml(auth0Config?.issuerBaseUrl, auth0Config?.audience);\n\tawait writeFile(\n\t\tdevConfigPath,\n\t\tdevStripped ? `${devStripped}\\n\\n${devFragment}` : devFragment,\n\t);\n\n\treturn ctx;\n}\n\nexport const auth0Feature: Feature = {\n\tname: \"auth0\",\n\tenabled,\n\tresolve,\n\tconfigure,\n\trender,\n};\n"],"names":["auth0Feature","enabled","ctx","opts","idp","resolve","yes","auth0","isInstalled","console","error","process","exit","stdout","write","tenants","listTenants","length","log","login","listApis","err","Auth0AuthError","active","find","t","issuerBaseUrl","name","userApis","filter","a","includes","choices","label","projectName","existing","map","identifier","selected","pick","c","audience","defaultId","ask","createApi","models","set","AUTH0_CONFIG_KEY","configure","controller","controllers","resource","className","replace","addImport","addTypeImport","decorateClass","decorateMethod","addConstructorParam","paramDecorators","typeName","isPrivate","isReadonly","render","targetDir","auth0Config","get","baseConfigPath","join","baseExisting","readFile","baseStripped","trimEnd","baseFrag","auth0ConfigYaml","writeFile","devConfigPath","devExisting","devStripped","devFragment"],"mappings":"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"}

package/commonjs/v1/features/auth0/models.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AUTH0_CONFIG_KEY", {
+    enumerable: true,
+    get: function() {
+        return AUTH0_CONFIG_KEY;
+    }
+});
+const _index = require("../../domain/index.js");
+const AUTH0_CONFIG_KEY = (0, _index.modelKey)("auth0-config");
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS92MS9mZWF0dXJlcy9hdXRoMC9tb2RlbHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbW9kZWxLZXkgfSBmcm9tIFwiLi4vLi4vZG9tYWluL2luZGV4LmpzXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQXV0aDBDb25maWcge1xuXHRpc3N1ZXJCYXNlVXJsOiBzdHJpbmc7XG5cdGF1ZGllbmNlOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBjb25zdCBBVVRIMF9DT05GSUdfS0VZID0gbW9kZWxLZXk8QXV0aDBDb25maWc+KFwiYXV0aDAtY29uZmlnXCIpO1xuIl0sIm5hbWVzIjpbIkFVVEgwX0NPTkZJR19LRVkiLCJtb2RlbEtleSJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFPYUE7OztlQUFBQTs7O3VCQVBZO0FBT2xCLE1BQU1BLG1CQUFtQkMsSUFBQUEsZUFBUSxFQUFjIn0=