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

package/es6/src/runner.js

@@ -0,0 +1,55 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { CREATE_VERSION } from "./version.js";
+const BUILDER_IMAGE = `ghcr.io/decohere/scaffold:${CREATE_VERSION}`;
+/**
+ * Run the scaffold inside a pre-built Docker builder image.
+ *
+ * Called when `DECOHERE_BUILDER` is not set — i.e. the CLI is running on the
+ * host, outside the container. Mounts the target directory as `/workspace` so
+ * the scaffolded files are written back to the host filesystem.
+ *
+ * If `~/.config/auth0` exists on the host the directory is also mounted so
+ * the auth0 CLI inside the container can reuse existing credentials silently.
+ */ export function runInBuilder(opts) {
+    const targetDir = resolve(opts.d ?? ".");
+    mkdirSync(targetDir, {
+        recursive: true
+    });
+    // Ensure Docker is available.
+    try {
+        execFileSync("docker", [
+            "info"
+        ], {
+            stdio: "pipe"
+        });
+    } catch  {
+        console.error("\n  Docker is required to scaffold a Decohere project.\n" + "  Install Docker Desktop: https://www.docker.com/products/docker-desktop\n");
+        process.exit(1);
+    }
+    const volumes = [
+        "-v",
+        `${targetDir}:/workspace`
+    ];
+    console.log("  Running scaffolding in a sandboxed container...\n");
+    const result = spawnSync("docker", [
+        "run",
+        "--rm",
+        "-it",
+        ...volumes,
+        "-e",
+        "DECOHERE_BUILDER=1",
+        "-w",
+        "/workspace",
+        BUILDER_IMAGE,
+        "webapi",
+        "-d",
+        "."
+    ], {
+        stdio: "inherit"
+    });
+    process.exit(result.status ?? 0);
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvcnVubmVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGV4ZWNGaWxlU3luYywgc3Bhd25TeW5jIH0gZnJvbSBcIm5vZGU6Y2hpbGRfcHJvY2Vzc1wiO1xuaW1wb3J0IHsgbWtkaXJTeW5jIH0gZnJvbSBcIm5vZGU6ZnNcIjtcbmltcG9ydCB7IHJlc29sdmUgfSBmcm9tIFwibm9kZTpwYXRoXCI7XG5pbXBvcnQgeyBDUkVBVEVfVkVSU0lPTiB9IGZyb20gXCIuL3ZlcnNpb24uanNcIjtcblxuY29uc3QgQlVJTERFUl9JTUFHRSA9IGBnaGNyLmlvL2RlY29oZXJlL3NjYWZmb2xkOiR7Q1JFQVRFX1ZFUlNJT059YDtcblxuLyoqXG4gKiBSdW4gdGhlIHNjYWZmb2xkIGluc2lkZSBhIHByZS1idWlsdCBEb2NrZXIgYnVpbGRlciBpbWFnZS5cbiAqXG4gKiBDYWxsZWQgd2hlbiBgREVDT0hFUkVfQlVJTERFUmAgaXMgbm90IHNldCDigJQgaS5lLiB0aGUgQ0xJIGlzIHJ1bm5pbmcgb24gdGhlXG4gKiBob3N0LCBvdXRzaWRlIHRoZSBjb250YWluZXIuIE1vdW50cyB0aGUgdGFyZ2V0IGRpcmVjdG9yeSBhcyBgL3dvcmtzcGFjZWAgc29cbiAqIHRoZSBzY2FmZm9sZGVkIGZpbGVzIGFyZSB3cml0dGVuIGJhY2sgdG8gdGhlIGhvc3QgZmlsZXN5c3RlbS5cbiAqXG4gKiBJZiBgfi8uY29uZmlnL2F1dGgwYCBleGlzdHMgb24gdGhlIGhvc3QgdGhlIGRpcmVjdG9yeSBpcyBhbHNvIG1vdW50ZWQgc29cbiAqIHRoZSBhdXRoMCBDTEkgaW5zaWRlIHRoZSBjb250YWluZXIgY2FuIHJldXNlIGV4aXN0aW5nIGNyZWRlbnRpYWxzIHNpbGVudGx5LlxuICovXG5leHBvcnQgZnVuY3Rpb24gcnVuSW5CdWlsZGVyKG9wdHM6IHsgZD86IHN0cmluZyB9KTogbmV2ZXIge1xuXHRjb25zdCB0YXJnZXREaXIgPSByZXNvbHZlKG9wdHMuZCA/PyBcIi5cIik7XG5cdG1rZGlyU3luYyh0YXJnZXREaXIsIHsgcmVjdXJzaXZlOiB0cnVlIH0pO1xuXG5cdC8vIEVuc3VyZSBEb2NrZXIgaXMgYXZhaWxhYmxlLlxuXHR0cnkge1xuXHRcdGV4ZWNGaWxlU3luYyhcImRvY2tlclwiLCBbXCJpbmZvXCJdLCB7IHN0ZGlvOiBcInBpcGVcIiB9KTtcblx0fSBjYXRjaCB7XG5cdFx0Y29uc29sZS5lcnJvcihcblx0XHRcdFwiXFxuICBEb2NrZXIgaXMgcmVxdWlyZWQgdG8gc2NhZmZvbGQgYSBEZWNvaGVyZSBwcm9qZWN0LlxcblwiICtcblx0XHRcdFx0XCIgIEluc3RhbGwgRG9ja2VyIERlc2t0b3A6IGh0dHBzOi8vd3d3LmRvY2tlci5jb20vcHJvZHVjdHMvZG9ja2VyLWRlc2t0b3BcXG5cIixcblx0XHQpO1xuXHRcdHByb2Nlc3MuZXhpdCgxKTtcblx0fVxuXG5cdGNvbnN0IHZvbHVtZXM6IHN0cmluZ1tdID0gW1wiLXZcIiwgYCR7dGFyZ2V0RGlyfTovd29ya3NwYWNlYF07XG5cblx0Y29uc29sZS5sb2coXCIgIFJ1bm5pbmcgc2NhZmZvbGRpbmcgaW4gYSBzYW5kYm94ZWQgY29udGFpbmVyLi4uXFxuXCIpO1xuXG5cdGNvbnN0IHJlc3VsdCA9IHNwYXduU3luYyhcblx0XHRcImRvY2tlclwiLFxuXHRcdFtcblx0XHRcdFwicnVuXCIsXG5cdFx0XHRcIi0tcm1cIixcblx0XHRcdFwiLWl0XCIsXG5cdFx0XHQuLi52b2x1bWVzLFxuXHRcdFx0XCItZVwiLFxuXHRcdFx0XCJERUNPSEVSRV9CVUlMREVSPTFcIixcblx0XHRcdFwiLXdcIixcblx0XHRcdFwiL3dvcmtzcGFjZVwiLFxuXHRcdFx0QlVJTERFUl9JTUFHRSxcblx0XHRcdFwid2ViYXBpXCIsXG5cdFx0XHRcIi1kXCIsXG5cdFx0XHRcIi5cIixcblx0XHRdLFxuXHRcdHsgc3RkaW86IFwiaW5oZXJpdFwiIH0sXG5cdCk7XG5cblx0cHJvY2Vzcy5leGl0KHJlc3VsdC5zdGF0dXMgPz8gMCk7XG59XG4iXSwibmFtZXMiOlsiZXhlY0ZpbGVTeW5jIiwic3Bhd25TeW5jIiwibWtkaXJTeW5jIiwicmVzb2x2ZSIsIkNSRUFURV9WRVJTSU9OIiwiQlVJTERFUl9JTUFHRSIsInJ1bkluQnVpbGRlciIsIm9wdHMiLCJ0YXJnZXREaXIiLCJkIiwicmVjdXJzaXZlIiwic3RkaW8iLCJjb25zb2xlIiwiZXJyb3IiLCJwcm9jZXNzIiwiZXhpdCIsInZvbHVtZXMiLCJsb2ciLCJyZXN1bHQiLCJzdGF0dXMiXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLFlBQVksRUFBRUMsU0FBUyxRQUFRLHFCQUFxQjtBQUM3RCxTQUFTQyxTQUFTLFFBQVEsVUFBVTtBQUNwQyxTQUFTQyxPQUFPLFFBQVEsWUFBWTtBQUNwQyxTQUFTQyxjQUFjLFFBQVEsZUFBZTtBQUU5QyxNQUFNQyxnQkFBZ0IsQ0FBQywwQkFBMEIsRUFBRUQsZ0JBQWdCO0FBRW5FOzs7Ozs7Ozs7Q0FTQyxHQUNELE9BQU8sU0FBU0UsYUFBYUMsSUFBb0I7SUFDaEQsTUFBTUMsWUFBWUwsUUFBUUksS0FBS0UsQ0FBQyxJQUFJO0lBQ3BDUCxVQUFVTSxXQUFXO1FBQUVFLFdBQVc7SUFBSztJQUV2Qyw4QkFBOEI7SUFDOUIsSUFBSTtRQUNIVixhQUFhLFVBQVU7WUFBQztTQUFPLEVBQUU7WUFBRVcsT0FBTztRQUFPO0lBQ2xELEVBQUUsT0FBTTtRQUNQQyxRQUFRQyxLQUFLLENBQ1osNkRBQ0M7UUFFRkMsUUFBUUMsSUFBSSxDQUFDO0lBQ2Q7SUFFQSxNQUFNQyxVQUFvQjtRQUFDO1FBQU0sR0FBR1IsVUFBVSxXQUFXLENBQUM7S0FBQztJQUUzREksUUFBUUssR0FBRyxDQUFDO0lBRVosTUFBTUMsU0FBU2pCLFVBQ2QsVUFDQTtRQUNDO1FBQ0E7UUFDQTtXQUNHZTtRQUNIO1FBQ0E7UUFDQTtRQUNBO1FBQ0FYO1FBQ0E7UUFDQTtRQUNBO0tBQ0EsRUFDRDtRQUFFTSxPQUFPO0lBQVU7SUFHcEJHLFFBQVFDLElBQUksQ0FBQ0csT0FBT0MsTUFBTSxJQUFJO0FBQy9CIn0=

package/es6/src/services/scaffold.service.js

@@ -0,0 +1,52 @@
+async function scaffold(workspace, cliOptions, features) {
+    const options = await getAllOptions(workspace, cliOptions, features);
+    // Features mutate workspace models first, then workspace renders to disk.
+    await scaffoldFeatures(workspace, options, features);
+    await scaffoldWorkspace(workspace, options);
+    // Post-write phase: install deps, print final messages, etc.
+    await finalizeFeatures(workspace, options, features);
+}
+async function scaffoldWorkspace(workspace, _options) {
+    await workspace.scaffold();
+}
+/**
+ * Iterate features in order, calling `getOptions` on each.
+ * Each feature receives the running merged options so later features can
+ * branch on decisions made by earlier ones (e.g. database choice affects auth).
+ * Results are shallow-merged, so features only need to return what they own.
+ */ async function getAllOptions(workspace, cliOptions, features) {
+    let options = {
+        ...cliOptions
+    };
+    for (const feature of features){
+        const featureOptions = await feature.getOptions(workspace, options);
+        options = {
+            ...options,
+            ...featureOptions
+        };
+    }
+    return options;
+}
+/**
+ * Iterate features in order, calling `scaffold` with the fully-resolved options.
+ * All option-gathering is complete before any scaffolding begins.
+ */ async function scaffoldFeatures(workspace, options, features) {
+    for (const feature of features){
+        await feature.scaffold(workspace, options);
+    }
+}
+/**
+ * Iterate features in order, calling `finalize` on each (if defined).
+ * All files are on disk by this point.
+ */ async function finalizeFeatures(workspace, options, features) {
+    for (const feature of features){
+        if (feature.finalize) {
+            await feature.finalize(workspace, options);
+        }
+    }
+}
+export const ScaffoldService = {
+    scaffold
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/version.js

@@ -0,0 +1,22 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const _require = createRequire(import.meta.url);
+function resolveCreateVersion() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for(let i = 0; i < 5; i++){
+        try {
+            const pkg = _require(join(dir, "package.json"));
+            if (pkg.name === "@decohere/create") {
+                return pkg.version ?? "0.0.1-dev";
+            }
+        } catch  {}
+        const parent = dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    return "0.0.1-dev";
+}
+/** Version of @decohere/create, used to pin scaffolded @decohere/* dependencies. */ export const CREATE_VERSION = resolveCreateVersion();
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/webapi/create-api.js

@@ -0,0 +1,151 @@
+import { resolve } from "node:path";
+import { DockerCompose } from "../models/compose.model.js";
+import { ConfigYaml } from "../models/config-yaml.model.js";
+import { WELL_KNOWN_FILES } from "../models/const.js";
+import { DockerfileModel } from "../models/container-image.model.js";
+import { DevContainer } from "../models/dev-container.model.js";
+import { EnvFile } from "../models/env-file.model.js";
+import { Gitignore } from "../models/gitignore.model.js";
+import { LaunchJson } from "../models/launch-json.model.js";
+import { PackageJson } from "../models/package-json.model.js";
+import { MonoRepoScaffold, ProjectScaffold } from "../models/project.model.js";
+import { TsConfig } from "../models/tsconfig.model.js";
+import { VSCodeSettings } from "../models/vscode-settings.model.js";
+import { ScaffoldService } from "../services/scaffold.service.js";
+import { AuthFeature } from "./features/auth.feature.js";
+import { DatabaseFeature } from "./features/database.feature.js";
+import { FinalizeFeature } from "./features/finalize.feature.js";
+import { PostmanFeature } from "./features/postman.feature.js";
+import { ApiPackageJson } from "./models/api-package-json.model.js";
+import { ControllerSourceFile } from "./models/controller-source-file.model.js";
+import { MainSourceFile } from "./models/main-source-file.model.js";
+import { SampleConfigModel, SampleServiceModel } from "./models/sample-files.model.js";
+export const WEBAPI_PROJECT_DIR = "projects/api";
+const features = [
+    DatabaseFeature,
+    AuthFeature,
+    PostmanFeature,
+    FinalizeFeature
+];
+export async function scaffoldApi(cliOptions) {
+    const targetDir = resolve(cliOptions.d ?? ".");
+    const workspace = createWorkspace(targetDir);
+    await ScaffoldService.scaffold(workspace, cliOptions, features);
+}
+function createWorkspace(targetDir) {
+    const monoRepo = new MonoRepoScaffold();
+    monoRepo.targetDir = targetDir;
+    const name = monoRepo.name;
+    const compose = new DockerCompose().addService("devcontainer", {
+        build: ".",
+        volumes: [
+            `\${HOME}/.npm/${name}:/home/node/.npm-config`,
+            "webapi-node-modules:/workspace/node_modules"
+        ],
+        environment: {
+            NPM_CONFIG_USERCONFIG: "/home/node/.npm-config/.npmrc"
+        },
+        command: "sleep infinity"
+    }).addVolume("webapi-node-modules");
+    const devContainer = new DevContainer().addExtension("biomejs.biome", "vitest.explorer").setPostStartCommand("npm whoami 2>/dev/null || npm login").useCompose();
+    // Workspace-level models (repo root)
+    monoRepo.addModel(compose);
+    monoRepo.addModel(devContainer);
+    monoRepo.addModel(new DockerfileModel());
+    monoRepo.addModel(new VSCodeSettings(name));
+    monoRepo.addModel(new LaunchJson());
+    monoRepo.addModel(new TsConfig());
+    monoRepo.addModel(new PackageJson(`${name}.api`));
+    monoRepo.addModel(new ConfigYaml(WELL_KNOWN_FILES.CONFIG_YAML, "config/config.yaml", ""));
+    monoRepo.addModel(new ConfigYaml(WELL_KNOWN_FILES.CONFIG_DEV_YAML, "config/config.dev.yaml", ""));
+    monoRepo.addModel(new Gitignore());
+    monoRepo.addModel(new EnvFile());
+    // Biome formatter/linter config
+    monoRepo.addFile({
+        files: ()=>[
+                {
+                    filePath: "biome.json",
+                    content: JSON.stringify({
+                        $schema: "https://biomejs.dev/schemas/2.0.0/schema.json",
+                        files: {
+                            includes: [
+                                "**/*.ts",
+                                "**/*.js",
+                                "**/*.json",
+                                "**/*.yml",
+                                "**/*.yaml"
+                            ]
+                        },
+                        assist: {
+                            actions: {
+                                source: {
+                                    organizeImports: "on"
+                                }
+                            }
+                        },
+                        vcs: {
+                            enabled: true,
+                            clientKind: "git",
+                            useIgnoreFile: true
+                        },
+                        formatter: {
+                            enabled: true,
+                            formatWithErrors: true,
+                            indentStyle: "tab",
+                            lineWidth: 95
+                        },
+                        javascript: {
+                            parser: {
+                                unsafeParameterDecoratorsEnabled: true
+                            }
+                        },
+                        linter: {
+                            rules: {
+                                style: {
+                                    useConsistentMemberAccessibility: {
+                                        level: "error",
+                                        options: {
+                                            accessibility: "explicit"
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        overrides: [
+                            {
+                                includes: [
+                                    "**/*.json"
+                                ],
+                                formatter: {
+                                    indentStyle: "space",
+                                    indentWidth: 2
+                                }
+                            }
+                        ]
+                    }, null, 2)
+                }
+            ]
+    });
+    // NPM token placeholder — gitignored, set manually after scaffold
+    monoRepo.addFile({
+        files: ()=>[
+                {
+                    filePath: ".env.local",
+                    content: "# Set your npm access token here (created with: npm token create)\nNPM_TOKEN=\n"
+                }
+            ]
+    });
+    // Project-level models (paths relative to projects/api)
+    const apiProject = new ProjectScaffold(WEBAPI_PROJECT_DIR);
+    apiProject.addModel(new ApiPackageJson(name));
+    apiProject.addModel(new MainSourceFile(`${name}.api`));
+    apiProject.addModel(new ControllerSourceFile());
+    // SampleService + SampleConfig are part of the core scaffold — HelloController
+    // injects SampleService to demonstrate config-driven behaviour out of the box.
+    apiProject.addFile(new SampleConfigModel());
+    apiProject.addFile(new SampleServiceModel());
+    monoRepo.addProject(apiProject);
+    return monoRepo;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/create-api.ts"],"sourcesContent":["import { resolve } from \"node:path\";\nimport { DockerCompose } from \"../models/compose.model.js\";\nimport { ConfigYaml } from \"../models/config-yaml.model.js\";\nimport { WELL_KNOWN_FILES } from \"../models/const.js\";\nimport { DockerfileModel } from \"../models/container-image.model.js\";\nimport { DevContainer } from \"../models/dev-container.model.js\";\nimport { EnvFile } from \"../models/env-file.model.js\";\nimport { Gitignore } from \"../models/gitignore.model.js\";\nimport { LaunchJson } from \"../models/launch-json.model.js\";\nimport { PackageJson } from \"../models/package-json.model.js\";\nimport { MonoRepoScaffold, ProjectScaffold } from \"../models/project.model.js\";\nimport { TsConfig } from \"../models/tsconfig.model.js\";\nimport { VSCodeSettings } from \"../models/vscode-settings.model.js\";\nimport { ScaffoldService } from \"../services/scaffold.service.js\";\nimport { AuthFeature } from \"./features/auth.feature.js\";\nimport { DatabaseFeature } from \"./features/database.feature.js\";\nimport { FinalizeFeature } from \"./features/finalize.feature.js\";\nimport { PostmanFeature } from \"./features/postman.feature.js\";\nimport { ApiPackageJson } from \"./models/api-package-json.model.js\";\nimport { ControllerSourceFile } from \"./models/controller-source-file.model.js\";\nimport { MainSourceFile } from \"./models/main-source-file.model.js\";\nimport { SampleConfigModel, SampleServiceModel } from \"./models/sample-files.model.js\";\n\nexport const WEBAPI_PROJECT_DIR = \"projects/api\";\n\nexport type ApiOptions = {\n\td?: string;\n\tauthProvider?: string;\n\tdatabaseProvider?: \"none\" | \"postgres/typeorm\";\n};\n\nconst features = [DatabaseFeature, AuthFeature, PostmanFeature, FinalizeFeature];\n\nexport async function scaffoldApi(cliOptions: ApiOptions) {\n\tconst targetDir = resolve(cliOptions.d ?? \".\");\n\tconst workspace = createWorkspace(targetDir);\n\tawait ScaffoldService.scaffold(workspace, cliOptions, features);\n}\n\nfunction createWorkspace(targetDir: string): MonoRepoScaffold {\n\tconst monoRepo = new MonoRepoScaffold();\n\tmonoRepo.targetDir = targetDir;\n\tconst name = monoRepo.name;\n\n\tconst compose = new DockerCompose()\n\t\t.addService(\"devcontainer\", {\n\t\t\tbuild: \".\",\n\t\t\tvolumes: [\n\t\t\t\t`\\${HOME}/.npm/${name}:/home/node/.npm-config`,\n\t\t\t\t\"webapi-node-modules:/workspace/node_modules\",\n\t\t\t],\n\t\t\tenvironment: { NPM_CONFIG_USERCONFIG: \"/home/node/.npm-config/.npmrc\" },\n\t\t\tcommand: \"sleep infinity\",\n\t\t})\n\t\t.addVolume(\"webapi-node-modules\");\n\n\tconst devContainer = new DevContainer()\n\t\t.addExtension(\"biomejs.biome\", \"vitest.explorer\")\n\t\t.setPostStartCommand(\"npm whoami 2>/dev/null || npm login\")\n\t\t.useCompose();\n\n\t// Workspace-level models (repo root)\n\tmonoRepo.addModel(compose);\n\tmonoRepo.addModel(devContainer);\n\tmonoRepo.addModel(new DockerfileModel());\n\tmonoRepo.addModel(new VSCodeSettings(name));\n\tmonoRepo.addModel(new LaunchJson());\n\tmonoRepo.addModel(new TsConfig());\n\tmonoRepo.addModel(new PackageJson(`${name}.api`));\n\tmonoRepo.addModel(new ConfigYaml(WELL_KNOWN_FILES.CONFIG_YAML, \"config/config.yaml\", \"\"));\n\tmonoRepo.addModel(\n\t\tnew ConfigYaml(WELL_KNOWN_FILES.CONFIG_DEV_YAML, \"config/config.dev.yaml\", \"\"),\n\t);\n\tmonoRepo.addModel(new Gitignore());\n\tmonoRepo.addModel(new EnvFile());\n\n\t// Biome formatter/linter config\n\tmonoRepo.addFile({\n\t\tfiles: () => [\n\t\t\t{\n\t\t\t\tfilePath: \"biome.json\",\n\t\t\t\tcontent: JSON.stringify(\n\t\t\t\t\t{\n\t\t\t\t\t\t$schema: \"https://biomejs.dev/schemas/2.0.0/schema.json\",\n\t\t\t\t\t\tfiles: {\n\t\t\t\t\t\t\tincludes: [\"**/*.ts\", \"**/*.js\", \"**/*.json\", \"**/*.yml\", \"**/*.yaml\"],\n\t\t\t\t\t\t},\n\t\t\t\t\t\tassist: { actions: { source: { organizeImports: \"on\" } } },\n\t\t\t\t\t\tvcs: { enabled: true, clientKind: \"git\", useIgnoreFile: true },\n\t\t\t\t\t\tformatter: {\n\t\t\t\t\t\t\tenabled: true,\n\t\t\t\t\t\t\tformatWithErrors: true,\n\t\t\t\t\t\t\tindentStyle: \"tab\",\n\t\t\t\t\t\t\tlineWidth: 95,\n\t\t\t\t\t\t},\n\t\t\t\t\t\tjavascript: { parser: { unsafeParameterDecoratorsEnabled: true } },\n\t\t\t\t\t\tlinter: {\n\t\t\t\t\t\t\trules: {\n\t\t\t\t\t\t\t\tstyle: {\n\t\t\t\t\t\t\t\t\tuseConsistentMemberAccessibility: {\n\t\t\t\t\t\t\t\t\t\tlevel: \"error\",\n\t\t\t\t\t\t\t\t\t\toptions: { accessibility: \"explicit\" },\n\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t\toverrides: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tincludes: [\"**/*.json\"],\n\t\t\t\t\t\t\t\tformatter: { indentStyle: \"space\", indentWidth: 2 },\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t\tnull,\n\t\t\t\t\t2,\n\t\t\t\t),\n\t\t\t},\n\t\t],\n\t});\n\n\t// NPM token placeholder — gitignored, set manually after scaffold\n\tmonoRepo.addFile({\n\t\tfiles: () => [\n\t\t\t{\n\t\t\t\tfilePath: \".env.local\",\n\t\t\t\tcontent:\n\t\t\t\t\t\"# Set your npm access token here (created with: npm token create)\\nNPM_TOKEN=\\n\",\n\t\t\t},\n\t\t],\n\t});\n\n\t// Project-level models (paths relative to projects/api)\n\tconst apiProject = new ProjectScaffold(WEBAPI_PROJECT_DIR);\n\tapiProject.addModel(new ApiPackageJson(name));\n\tapiProject.addModel(new MainSourceFile(`${name}.api`));\n\tapiProject.addModel(new ControllerSourceFile());\n\n\t// SampleService + SampleConfig are part of the core scaffold — HelloController\n\t// injects SampleService to demonstrate config-driven behaviour out of the box.\n\tapiProject.addFile(new SampleConfigModel());\n\tapiProject.addFile(new SampleServiceModel());\n\n\tmonoRepo.addProject(apiProject);\n\n\treturn monoRepo;\n}\n"],"names":["resolve","DockerCompose","ConfigYaml","WELL_KNOWN_FILES","DockerfileModel","DevContainer","EnvFile","Gitignore","LaunchJson","PackageJson","MonoRepoScaffold","ProjectScaffold","TsConfig","VSCodeSettings","ScaffoldService","AuthFeature","DatabaseFeature","FinalizeFeature","PostmanFeature","ApiPackageJson","ControllerSourceFile","MainSourceFile","SampleConfigModel","SampleServiceModel","WEBAPI_PROJECT_DIR","features","scaffoldApi","cliOptions","targetDir","d","workspace","createWorkspace","scaffold","monoRepo","name","compose","addService","build","volumes","environment","NPM_CONFIG_USERCONFIG","command","addVolume","devContainer","addExtension","setPostStartCommand","useCompose","addModel","CONFIG_YAML","CONFIG_DEV_YAML","addFile","files","filePath","content","JSON","stringify","$schema","includes","assist","actions","source","organizeImports","vcs","enabled","clientKind","useIgnoreFile","formatter","formatWithErrors","indentStyle","lineWidth","javascript","parser","unsafeParameterDecoratorsEnabled","linter","rules","style","useConsistentMemberAccessibility","level","options","accessibility","overrides","indentWidth","apiProject","addProject"],"mappings":"AAAA,SAASA,OAAO,QAAQ,YAAY;AACpC,SAASC,aAAa,QAAQ,6BAA6B;AAC3D,SAASC,UAAU,QAAQ,iCAAiC;AAC5D,SAASC,gBAAgB,QAAQ,qBAAqB;AACtD,SAASC,eAAe,QAAQ,qCAAqC;AACrE,SAASC,YAAY,QAAQ,mCAAmC;AAChE,SAASC,OAAO,QAAQ,8BAA8B;AACtD,SAASC,SAAS,QAAQ,+BAA+B;AACzD,SAASC,UAAU,QAAQ,iCAAiC;AAC5D,SAASC,WAAW,QAAQ,kCAAkC;AAC9D,SAASC,gBAAgB,EAAEC,eAAe,QAAQ,6BAA6B;AAC/E,SAASC,QAAQ,QAAQ,8BAA8B;AACvD,SAASC,cAAc,QAAQ,qCAAqC;AACpE,SAASC,eAAe,QAAQ,kCAAkC;AAClE,SAASC,WAAW,QAAQ,6BAA6B;AACzD,SAASC,eAAe,QAAQ,iCAAiC;AACjE,SAASC,eAAe,QAAQ,iCAAiC;AACjE,SAASC,cAAc,QAAQ,gCAAgC;AAC/D,SAASC,cAAc,QAAQ,qCAAqC;AACpE,SAASC,oBAAoB,QAAQ,2CAA2C;AAChF,SAASC,cAAc,QAAQ,qCAAqC;AACpE,SAASC,iBAAiB,EAAEC,kBAAkB,QAAQ,iCAAiC;AAEvF,OAAO,MAAMC,qBAAqB,eAAe;AAQjD,MAAMC,WAAW;IAACT;IAAiBD;IAAaG;IAAgBD;CAAgB;AAEhF,OAAO,eAAeS,YAAYC,UAAsB;IACvD,MAAMC,YAAY5B,QAAQ2B,WAAWE,CAAC,IAAI;IAC1C,MAAMC,YAAYC,gBAAgBH;IAClC,MAAMd,gBAAgBkB,QAAQ,CAACF,WAAWH,YAAYF;AACvD;AAEA,SAASM,gBAAgBH,SAAiB;IACzC,MAAMK,WAAW,IAAIvB;IACrBuB,SAASL,SAAS,GAAGA;IACrB,MAAMM,OAAOD,SAASC,IAAI;IAE1B,MAAMC,UAAU,IAAIlC,gBAClBmC,UAAU,CAAC,gBAAgB;QAC3BC,OAAO;QACPC,SAAS;YACR,CAAC,cAAc,EAAEJ,KAAK,uBAAuB,CAAC;YAC9C;SACA;QACDK,aAAa;YAAEC,uBAAuB;QAAgC;QACtEC,SAAS;IACV,GACCC,SAAS,CAAC;IAEZ,MAAMC,eAAe,IAAItC,eACvBuC,YAAY,CAAC,iBAAiB,mBAC9BC,mBAAmB,CAAC,uCACpBC,UAAU;IAEZ,qCAAqC;IACrCb,SAASc,QAAQ,CAACZ;IAClBF,SAASc,QAAQ,CAACJ;IAClBV,SAASc,QAAQ,CAAC,IAAI3C;IACtB6B,SAASc,QAAQ,CAAC,IAAIlC,eAAeqB;IACrCD,SAASc,QAAQ,CAAC,IAAIvC;IACtByB,SAASc,QAAQ,CAAC,IAAInC;IACtBqB,SAASc,QAAQ,CAAC,IAAItC,YAAY,GAAGyB,KAAK,IAAI,CAAC;IAC/CD,SAASc,QAAQ,CAAC,IAAI7C,WAAWC,iBAAiB6C,WAAW,EAAE,sBAAsB;IACrFf,SAASc,QAAQ,CAChB,IAAI7C,WAAWC,iBAAiB8C,eAAe,EAAE,0BAA0B;IAE5EhB,SAASc,QAAQ,CAAC,IAAIxC;IACtB0B,SAASc,QAAQ,CAAC,IAAIzC;IAEtB,gCAAgC;IAChC2B,SAASiB,OAAO,CAAC;QAChBC,OAAO,IAAM;gBACZ;oBACCC,UAAU;oBACVC,SAASC,KAAKC,SAAS,CACtB;wBACCC,SAAS;wBACTL,OAAO;4BACNM,UAAU;gCAAC;gCAAW;gCAAW;gCAAa;gCAAY;6BAAY;wBACvE;wBACAC,QAAQ;4BAAEC,SAAS;gCAAEC,QAAQ;oCAAEC,iBAAiB;gCAAK;4BAAE;wBAAE;wBACzDC,KAAK;4BAAEC,SAAS;4BAAMC,YAAY;4BAAOC,eAAe;wBAAK;wBAC7DC,WAAW;4BACVH,SAAS;4BACTI,kBAAkB;4BAClBC,aAAa;4BACbC,WAAW;wBACZ;wBACAC,YAAY;4BAAEC,QAAQ;gCAAEC,kCAAkC;4BAAK;wBAAE;wBACjEC,QAAQ;4BACPC,OAAO;gCACNC,OAAO;oCACNC,kCAAkC;wCACjCC,OAAO;wCACPC,SAAS;4CAAEC,eAAe;wCAAW;oCACtC;gCACD;4BACD;wBACD;wBACAC,WAAW;4BACV;gCACCvB,UAAU;oCAAC;iCAAY;gCACvBS,WAAW;oCAAEE,aAAa;oCAASa,aAAa;gCAAE;4BACnD;yBACA;oBACF,GACA,MACA;gBAEF;aACA;IACF;IAEA,kEAAkE;IAClEhD,SAASiB,OAAO,CAAC;QAChBC,OAAO,IAAM;gBACZ;oBACCC,UAAU;oBACVC,SACC;gBACF;aACA;IACF;IAEA,wDAAwD;IACxD,MAAM6B,aAAa,IAAIvE,gBAAgBa;IACvC0D,WAAWnC,QAAQ,CAAC,IAAI5B,eAAee;IACvCgD,WAAWnC,QAAQ,CAAC,IAAI1B,eAAe,GAAGa,KAAK,IAAI,CAAC;IACpDgD,WAAWnC,QAAQ,CAAC,IAAI3B;IAExB,+EAA+E;IAC/E,+EAA+E;IAC/E8D,WAAWhC,OAAO,CAAC,IAAI5B;IACvB4D,WAAWhC,OAAO,CAAC,IAAI3B;IAEvBU,SAASkD,UAAU,CAACD;IAEpB,OAAOjD;AACR"}

package/es6/src/webapi/features/auth.feature.js

@@ -0,0 +1,115 @@
+import { ask, pick } from "../../domain/prompt.js";
+import { WELL_KNOWN_FILES } from "../../models/const.js";
+import { AuthConfigModel } from "../models/auth-config.model.js";
+import { ControllerSourceFile } from "../models/controller-source-file.model.js";
+import * as auth0Cli from "./auth0-cli.js";
+async function getOptions(workspace, cliOptions) {
+    if (cliOptions.authProvider != null) return {};
+    const choices = [
+        {
+            label: "none"
+        },
+        {
+            label: "auth0"
+        }
+    ];
+    const selected = await pick("\n  Auth provider: ", choices, (c)=>c.label);
+    const provider = selected?.label ?? "none";
+    if (provider !== "auth0") return {
+        authProvider: "none"
+    };
+    return getAuth0Options(workspace);
+}
+async function getAuth0Options(workspace) {
+    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);
+    }
+    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();
+        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 projectName = workspace.name;
+    const apiChoices = [
+        {
+            label: `<new> https://api.${projectName}`,
+            existing: null
+        },
+        ...userApis.map((a)=>({
+                label: `${a.name} — ${a.identifier}`,
+                existing: a.identifier
+            }))
+    ];
+    const apiSelected = await pick("\n  Select Auth0 API: ", apiChoices, (c)=>c.label);
+    let audience;
+    if (!apiSelected || apiSelected.existing === null) {
+        const defaultId = `https://api.${projectName}`;
+        audience = await ask(`  API Identifier [${defaultId}]: `, defaultId);
+        console.log("\n  Creating Auth0 API...");
+        audience = auth0Cli.createApi(`${projectName} API`, audience).identifier;
+        console.log(`  \u2713 API created: ${audience}`);
+    } else {
+        audience = apiSelected.existing;
+        console.log(`  \u2713 Selected: ${audience}`);
+    }
+    return {
+        authProvider: "auth0",
+        issuerBaseUrl,
+        audience
+    };
+}
+function scaffold(workspace, options) {
+    if (options.authProvider !== "auth0") return;
+    const resource = "Hello";
+    for (const controller of workspace.getModels(ControllerSourceFile)){
+        controller.addDecorator(`@Authorize("read", "${resource}")`).addCortexImport("AllowAnonymous").addCortexImport("Authorize").addCortexImport("IPrincipalProviderToken").addCortexImport("IPrincipalProvider", true).addImport("inject", "@decohere/crucible/decorators").addConstructorParam(`@inject(IPrincipalProviderToken) private readonly principalProvider: IPrincipalProvider`);
+        controller.getMethod("getAll").addDecorator("@AllowAnonymous()");
+        controller.getMethod("create").addDecorator(`@Authorize("create", "${resource}")`);
+        controller.getMethod("update").addDecorator(`@Authorize("update", "${resource}")`);
+        controller.getMethod("remove").addDecorator(`@Authorize("delete", "${resource}")`);
+    }
+    workspace.getModel(WELL_KNOWN_FILES.MAIN_TS)?.addSideEffectImport("@decohere/cortex/auth").addBuilderCall(".withAuth()");
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: intentional YAML env-var placeholders
+    const issuerPlaceholder = "${AUTH0_ISSUER_BASE_URL}";
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: intentional YAML env-var placeholders
+    const audPlaceholder = "${AUTH0_AUDIENCE}";
+    const configSection = `auth:\n  discoveryUrl: ${issuerPlaceholder}\n  audience: ${audPlaceholder}\n`;
+    workspace.getModel(WELL_KNOWN_FILES.CONFIG_YAML)?.addSection(configSection);
+    workspace.getModel(WELL_KNOWN_FILES.ENV_FILE)?.addEntry("AUTH0_ISSUER_BASE_URL", options.issuerBaseUrl ?? "").addEntry("AUTH0_AUDIENCE", options.audience ?? "");
+    workspace.addModel(new AuthConfigModel({
+        issuerBaseUrl: options.issuerBaseUrl ?? "",
+        audience: options.audience ?? ""
+    }));
+}
+export const AuthFeature = {
+    getOptions,
+    scaffold
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/features/auth.feature.ts"],"sourcesContent":["import { ask, pick } from \"../../domain/prompt.js\";\nimport type { ConfigYaml } from \"../../models/config-yaml.model.js\";\nimport { WELL_KNOWN_FILES } from \"../../models/const.js\";\nimport type { EnvFile } from \"../../models/env-file.model.js\";\nimport type { WorkspaceScaffold } from \"../../models/project.model.js\";\nimport type { Feature } from \"../../services/scaffold.service.js\";\nimport { AuthConfigModel } from \"../models/auth-config.model.js\";\nimport { ControllerSourceFile } from \"../models/controller-source-file.model.js\";\nimport type { MainSourceFile } from \"../models/main-source-file.model.js\";\nimport * as auth0Cli from \"./auth0-cli.js\";\n\nexport type AuthOptions = {\n\tauthProvider?: \"auth0\" | \"none\";\n\tissuerBaseUrl?: string;\n\taudience?: string;\n};\n\nasync function getOptions(\n\tworkspace: WorkspaceScaffold,\n\tcliOptions: Partial<AuthOptions>,\n): Promise<Partial<AuthOptions>> {\n\tif (cliOptions.authProvider != null) return {};\n\n\tconst choices = [{ label: \"none\" as const }, { label: \"auth0\" as const }];\n\tconst selected = await pick(\"\\n  Auth provider: \", choices, (c) => c.label);\n\tconst provider = selected?.label ?? \"none\";\n\n\tif (provider !== \"auth0\") return { authProvider: \"none\" };\n\n\treturn getAuth0Options(workspace);\n}\n\nasync function getAuth0Options(workspace: WorkspaceScaffold): Promise<Partial<AuthOptions>> {\n\tif (!auth0Cli.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\tprocess.stdout.write(\"\\n  Checking Auth0 credentials...\");\n\tlet tenants = auth0Cli.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 (!auth0Cli.login()) {\n\t\t\tconsole.error(\"\\n  Auth0 login failed.\");\n\t\t\tprocess.exit(1);\n\t\t}\n\t\ttenants = auth0Cli.listTenants();\n\t}\n\n\ttry {\n\t\tauth0Cli.listApis();\n\t\tprocess.stdout.write(\" ok.\\n\");\n\t} catch (err) {\n\t\tif (err instanceof auth0Cli.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 (!auth0Cli.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 = auth0Cli.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 projectName = workspace.name;\n\tconst apiChoices: ApiChoice[] = [\n\t\t{ label: `<new> https://api.${projectName}`, existing: null },\n\t\t...userApis.map((a) => ({ label: `${a.name} — ${a.identifier}`, existing: a.identifier })),\n\t];\n\n\tconst apiSelected = await pick(\"\\n  Select Auth0 API: \", apiChoices, (c) => c.label);\n\n\tlet audience: string;\n\tif (!apiSelected || apiSelected.existing === null) {\n\t\tconst defaultId = `https://api.${projectName}`;\n\t\taudience = await ask(`  API Identifier [${defaultId}]: `, defaultId);\n\t\tconsole.log(\"\\n  Creating Auth0 API...\");\n\t\taudience = auth0Cli.createApi(`${projectName} API`, audience).identifier;\n\t\tconsole.log(`  \\u2713 API created: ${audience}`);\n\t} else {\n\t\taudience = apiSelected.existing;\n\t\tconsole.log(`  \\u2713 Selected: ${audience}`);\n\t}\n\n\treturn { authProvider: \"auth0\", issuerBaseUrl, audience };\n}\n\nfunction scaffold(workspace: WorkspaceScaffold, options: AuthOptions): void {\n\tif (options.authProvider !== \"auth0\") return;\n\n\tconst resource = \"Hello\";\n\n\tfor (const controller of workspace.getModels(ControllerSourceFile)) {\n\t\tcontroller\n\t\t\t.addDecorator(`@Authorize(\"read\", \"${resource}\")`)\n\t\t\t.addCortexImport(\"AllowAnonymous\")\n\t\t\t.addCortexImport(\"Authorize\")\n\t\t\t.addCortexImport(\"IPrincipalProviderToken\")\n\t\t\t.addCortexImport(\"IPrincipalProvider\", true)\n\t\t\t.addImport(\"inject\", \"@decohere/crucible/decorators\")\n\t\t\t.addConstructorParam(\n\t\t\t\t`@inject(IPrincipalProviderToken) private readonly principalProvider: IPrincipalProvider`,\n\t\t\t);\n\t\tcontroller.getMethod(\"getAll\").addDecorator(\"@AllowAnonymous()\");\n\t\tcontroller.getMethod(\"create\").addDecorator(`@Authorize(\"create\", \"${resource}\")`);\n\t\tcontroller.getMethod(\"update\").addDecorator(`@Authorize(\"update\", \"${resource}\")`);\n\t\tcontroller.getMethod(\"remove\").addDecorator(`@Authorize(\"delete\", \"${resource}\")`);\n\t}\n\n\tworkspace\n\t\t.getModel<MainSourceFile>(WELL_KNOWN_FILES.MAIN_TS)\n\t\t?.addSideEffectImport(\"@decohere/cortex/auth\")\n\t\t.addBuilderCall(\".withAuth()\");\n\n\t// biome-ignore lint/suspicious/noTemplateCurlyInString: intentional YAML env-var placeholders\n\tconst issuerPlaceholder = \"${AUTH0_ISSUER_BASE_URL}\";\n\t// biome-ignore lint/suspicious/noTemplateCurlyInString: intentional YAML env-var placeholders\n\tconst audPlaceholder = \"${AUTH0_AUDIENCE}\";\n\n\tconst configSection = `auth:\\n  discoveryUrl: ${issuerPlaceholder}\\n  audience: ${audPlaceholder}\\n`;\n\n\tworkspace.getModel<ConfigYaml>(WELL_KNOWN_FILES.CONFIG_YAML)?.addSection(configSection);\n\n\tworkspace\n\t\t.getModel<EnvFile>(WELL_KNOWN_FILES.ENV_FILE)\n\t\t?.addEntry(\"AUTH0_ISSUER_BASE_URL\", options.issuerBaseUrl ?? \"\")\n\t\t.addEntry(\"AUTH0_AUDIENCE\", options.audience ?? \"\");\n\n\tworkspace.addModel(\n\t\tnew AuthConfigModel({\n\t\t\tissuerBaseUrl: options.issuerBaseUrl ?? \"\",\n\t\t\taudience: options.audience ?? \"\",\n\t\t}),\n\t);\n}\n\nexport const AuthFeature: Feature<AuthOptions> = { getOptions, scaffold };\n"],"names":["ask","pick","WELL_KNOWN_FILES","AuthConfigModel","ControllerSourceFile","auth0Cli","getOptions","workspace","cliOptions","authProvider","choices","label","selected","c","provider","getAuth0Options","isInstalled","console","error","process","exit","stdout","write","tenants","listTenants","length","log","login","listApis","err","Auth0AuthError","active","find","t","issuerBaseUrl","name","userApis","filter","a","includes","projectName","apiChoices","existing","map","identifier","apiSelected","audience","defaultId","createApi","scaffold","options","resource","controller","getModels","addDecorator","addCortexImport","addImport","addConstructorParam","getMethod","getModel","MAIN_TS","addSideEffectImport","addBuilderCall","issuerPlaceholder","audPlaceholder","configSection","CONFIG_YAML","addSection","ENV_FILE","addEntry","addModel","AuthFeature"],"mappings":"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"}

package/es6/src/webapi/features/auth0-cli.js

@@ -0,0 +1,116 @@
+import { execFileSync, spawnSync } from "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;
+export 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 = 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;
+}
+export function isInstalled() {
+    try {
+        execFileSync("auth0", [
+            "--version"
+        ], {
+            stdio: "pipe"
+        });
+        return true;
+    } catch  {
+        return false;
+    }
+}
+export function listTenants() {
+    try {
+        const out = execFileSync("auth0", [
+            "tenants",
+            "list",
+            "--json"
+        ], {
+            encoding: "utf8",
+            stdio: "pipe"
+        });
+        return JSON.parse(out);
+    } catch  {
+        return [];
+    }
+}
+export function login() {
+    const result = spawnSync("auth0", [
+        "login",
+        "--scopes",
+        REQUIRED_SCOPES
+    ], {
+        stdio: "inherit"
+    });
+    return result.status === 0;
+}
+export function listApis() {
+    try {
+        const out = runAuth0([
+            "apis",
+            "list",
+            "--json",
+            "--no-input"
+        ]);
+        return JSON.parse(out);
+    } catch (err) {
+        if (err instanceof Auth0AuthError) throw err;
+        return [];
+    }
+}
+export function createApi(name, identifier) {
+    const out = runAuth0([
+        "apis",
+        "create",
+        "--name",
+        name,
+        "--identifier",
+        identifier,
+        "--json",
+        "--no-input"
+    ]);
+    return JSON.parse(out);
+}
+export function createSpaApp(name, callbackUrl) {
+    const out = runAuth0([
+        "apps",
+        "create",
+        "--name",
+        name,
+        "--type",
+        "spa",
+        "--callbacks",
+        callbackUrl,
+        "--json",
+        "--no-input"
+    ]);
+    return JSON.parse(out);
+}
+export { REQUIRED_SCOPES };
+
+//# sourceMappingURL=data:application/json;base64,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