@decohere/create 0.0.1-dev.22 → 0.0.1-dev.24

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

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "AuthFeature", {
 });
 const _prompt = require("../../domain/prompt.js");
 const _const = require("../../models/const.js");
+const _createapi = require("../create-api.js");
 const _authconfigmodel = require("../models/auth-config.model.js");
 const _controllersourcefilemodel = require("../models/controller-source-file.model.js");
 const _auth0cli = /*#__PURE__*/ _interop_require_wildcard(require("./auth0-cli.js"));
@@ -54,7 +55,151 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+const ADMIN_ROLE = "admin";
+const USER_ENTITY_TS = `import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+import type { Entity as IEntity } from "@decohere/codex";
+
+@Entity()
+export class UserEntity implements IEntity {
+\t@PrimaryGeneratedColumn()
+\tpublic id!: number;
+
+\t@Column({ unique: true })
+\tpublic sub!: string;
+
+\t@Column({ type: "varchar", nullable: true })
+\tpublic email!: string | null;
+
+\t@Column()
+\tpublic displayName!: string;
+
+\t/** App-owned roles. The \`admin\` role grants CASL \`manage\`/\`all\` (wildcard). */
+\t@Column({ type: "simple-json", default: "[]" })
+\tpublic roles!: string[];
+}
+`;
+const USER_REPOSITORY_TS = `import { injectable } from "@decohere/crucible/decorators";
+import { injectUnitOfWork } from "@decohere/codex";
+import { TypeOrmRepository, TypeOrmUnitOfWork } from "@decohere/codex-typeorm";
+import { UserEntity } from "../entities/user.entity.js";
+
+@injectable()
+export class UserEntityRepository extends TypeOrmRepository<UserEntity> {
+\tpublic constructor(@injectUnitOfWork() unitOfWork: TypeOrmUnitOfWork) {
+\t\tsuper(unitOfWork, UserEntity);
+\t}
+
+\tpublic findBySub(sub: string): Promise<UserEntity | null> {
+\t\treturn this.firstOrDefault({ where: { sub } });
+\t}
+}
+`;
+const USER_SERVICE_TS = `import { injectable } from "@decohere/crucible/decorators";
+import type { Principal } from "@decohere/cortex";
+import { UserEntity } from "../entities/user.entity.js";
+import { UserEntityRepository } from "../repositories/user.repository.js";
+
+function claimString(principal: Principal | undefined, key: string): string | undefined {
+\tconst value = principal?.[key];
+\treturn typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+@injectable()
+export class UserService {
+\tpublic constructor(private readonly users: UserEntityRepository) {}
+
+\t/**
+\t * Upsert a local profile keyed by JWT \`sub\`.
+\t * Profile fields from the token fill gaps; seeded rows keep displayName/email/roles.
+\t */
+\tpublic async ensureFromPrincipal(principal: Principal | undefined): Promise<UserEntity> {
+\t\tconst sub = principal?.sub;
+\t\tif (!sub) {
+\t\t\tthrow new Error("Authenticated request is missing principal.sub");
+\t\t}
+
+\t\tconst email =
+\t\t\tclaimString(principal, "email") ?? claimString(principal, "preferred_username");
+\t\tconst displayFromToken =
+\t\t\tclaimString(principal, "name") ??
+\t\t\tclaimString(principal, "nickname") ??
+\t\t\temail;
+
+\t\tconst existing = await this.users.findBySub(sub);
+\t\tif (existing) {
+\t\t\tlet dirty = false;
+\t\t\tif (!existing.email && email) {
+\t\t\t\texisting.email = email;
+\t\t\t\tdirty = true;
+\t\t\t}
+\t\t\tif (existing.displayName === existing.sub && displayFromToken) {
+\t\t\t\texisting.displayName = displayFromToken;
+\t\t\t\tdirty = true;
+\t\t\t}
+\t\t\treturn dirty ? this.users.save(existing) : existing;
+\t\t}
+
+\t\tconst created = new UserEntity();
+\t\tcreated.sub = sub;
+\t\tcreated.email = email ?? null;
+\t\tcreated.displayName = displayFromToken ?? sub;
+\t\tcreated.roles = Array.isArray(principal.roles)
+\t\t\t? principal.roles.filter((r): r is string => typeof r === "string")
+\t\t\t: [];
+\t\treturn this.users.save(created);
+\t}
+}
+`;
+const ABILITY_FACTORY_TS = `import { AbilityBuilder, createMongoAbility } from "@casl/ability";
+import type { Principal } from "@decohere/cortex";
+
+/** Root role — expands to CASL \`manage\`/\`all\` (covers every future ability). */
+export const ADMIN_ROLE = "admin";
+
+/**
+ * Roles are collections of abilities. Admin is a wildcard, not an enumerated list.
+ * Non-admin principals keep the default Auth0 scope → ability mapping.
+ */
+export function createAbilityFactory(principal: Principal) {
+\tconst { can, build } = new AbilityBuilder(createMongoAbility);
+\tif (principal.roles?.includes(ADMIN_ROLE)) {
+\t\tcan("manage", "all");
+\t\treturn build();
+\t}
+\tfor (const scope of principal.scopes ?? []) {
+\t\tconst [action, subject] = scope.split(":");
+\t\tif (action && subject) can(action, subject);
+\t}
+\treturn build();
+}
+
+/**
+ * Map JWT payload → Principal. Bootstraps the seeded Auth0 admin \`sub\` with
+ * the admin role so authorization works before/without roles in the access token.
+ */
+export function mapPrincipal(payload: Record<string, unknown>): Principal {
+\tconst sub = typeof payload.sub === "string" ? payload.sub : "";
+\tconst scopes = Array.isArray(payload.scopes)
+\t\t? (payload.scopes as string[])
+\t\t: typeof payload.scope === "string"
+\t\t\t? payload.scope.split(" ")
+\t\t\t: undefined;
+\tconst fromToken = Array.isArray(payload.roles)
+\t\t? (payload.roles as unknown[]).filter((r): r is string => typeof r === "string")
+\t\t: [];
+\tconst roles =
+\t\tsub && sub === process.env.AUTH0_ADMIN_USER_SUB
+\t\t\t? [...new Set([ADMIN_ROLE, ...fromToken])]
+\t\t\t: fromToken.length > 0
+\t\t\t\t? fromToken
+\t\t\t\t: undefined;
+\treturn { ...payload, sub, roles, scopes };
+}
+`;
 async function getOptions(workspace, cliOptions) {
+    if (cliOptions.authProvider === "auth0" && !cliOptions.issuerBaseUrl) {
+        return getAuth0Options(workspace, cliOptions);
+    }
     if (cliOptions.authProvider != null) return {};
     const choices = [
         {
@@ -69,9 +214,9 @@ async function getOptions(workspace, cliOptions) {
     if (provider !== "auth0") return {
         authProvider: "none"
     };
-    return getAuth0Options(workspace);
+    return getAuth0Options(workspace, cliOptions);
 }
-async function getAuth0Options(workspace) {
+async function getAuth0Options(workspace, cliOptions) {
     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);
@@ -128,24 +273,155 @@ async function getAuth0Options(workspace) {
     } else {
         audience = apiSelected.existing;
         console.log(`  \u2713 Selected: ${audience}`);
+        try {
+            _auth0cli.updateApiScopes(audience);
+            console.log(`  \u2713 API scopes ensured (${_auth0cli.HELLO_API_SCOPES.join(", ")})`);
+        } catch  {
+            console.error("  ✗ Failed to update API scopes — add Hello scopes in the Auth0 dashboard.");
+        }
+    }
+    const withLocalUsers = cliOptions.databaseProvider === "postgres/typeorm";
+    let adminUsername;
+    let adminPassword;
+    if (withLocalUsers) {
+        adminUsername = cliOptions.adminUsername ?? await (0, _prompt.ask)("\n  Admin username [admin]: ", "admin");
+        adminPassword = cliOptions.adminPassword;
+        if (adminPassword == null) {
+            adminPassword = await (0, _prompt.ask)("  Admin password (leave blank to generate): ");
+            if (!adminPassword) {
+                adminPassword = _auth0cli.generateAdminPassword();
+                console.log(`  ✓ Generated admin password (written to .env): ${adminPassword}`);
+            }
+        }
     }
     return {
         authProvider: "auth0",
         issuerBaseUrl,
-        audience
+        audience,
+        ...withLocalUsers ? {
+            adminUsername,
+            adminPassword
+        } : {}
     };
 }
+function adminEmail(workspaceName, username) {
+    if (username.includes("@")) return username;
+    const slug = workspaceName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    return `${username}@${slug}.example.com`;
+}
+function createAuth0AdminUser(workspace, options, authConfig) {
+    const username = options.adminUsername ?? "admin";
+    const password = options.adminPassword;
+    if (!password) return;
+    try {
+        const admin = _auth0cli.createAdminDatabaseUser({
+            email: adminEmail(workspace.name, username),
+            password,
+            username
+        });
+        authConfig.setAdminUser({
+            sub: admin.user_id,
+            email: admin.email,
+            password: admin.password,
+            username: admin.username
+        });
+        workspace.getModel(_const.WELL_KNOWN_FILES.ENV_FILE)?.addEntry("AUTH0_ADMIN_USER_SUB", admin.user_id).addEntry("AUTH0_ADMIN_USER_EMAIL", admin.email).addEntry("AUTH0_ADMIN_USER_PASSWORD", admin.password).addEntry("AUTH0_ADMIN_USERNAME", admin.username);
+        console.log(`  ✓ Auth0 admin user created: ${admin.email} (role: ${ADMIN_ROLE})`);
+        console.log(`    Login with EMAIL (not username): ${admin.email}`);
+        console.log(`    Password: see AUTH0_ADMIN_USER_PASSWORD in .env`);
+    } catch (err) {
+        console.error(`  ✗ Failed to create Auth0 admin user: ${err instanceof Error ? err.message : err}`);
+    }
+}
+function scaffoldLocalUserProfile(workspace) {
+    workspace.getModel(_const.WELL_KNOWN_FILES.PACKAGE_JSON)?.addDependency("@casl/ability", "^6.8.1");
+    workspace.getModel(_const.WELL_KNOWN_FILES.API_PACKAGE_JSON)?.addDependency("@casl/ability", "^6.8.1");
+    const main = workspace.getModel(_const.WELL_KNOWN_FILES.MAIN_TS);
+    main?.addEntity({
+        className: "UserEntity",
+        importPath: "./entities/user.entity.js"
+    }).addRepository({
+        className: "UserEntityRepository",
+        importPath: "./repositories/user.repository.js"
+    }).addService({
+        className: "UserService",
+        importPath: "./services/user.service.js",
+        scope: "request"
+    }).addImport("createAbilityFactory", "./auth/ability.factory.js").addImport("mapPrincipal", "./auth/ability.factory.js").setTypeOrmSeed([
+        "const sub = process.env.AUTH0_ADMIN_USER_SUB;",
+        "if (!sub) return;",
+        "const repo = dataSource.getRepository(UserEntity);",
+        "const existing = await repo.findOne({ where: { sub } });",
+        "if (existing) return;",
+        "await repo.save(repo.create({",
+        "  sub,",
+        "  email: process.env.AUTH0_ADMIN_USER_EMAIL ?? null,",
+        '  displayName: process.env.AUTH0_ADMIN_USERNAME ?? "admin",',
+        '  roles: ["admin"],',
+        "}));"
+    ].join(" "));
+    workspace.getProject(_createapi.WEBAPI_PROJECT_DIR)?.addFile({
+        files: ()=>[
+                {
+                    filePath: "src/entities/user.entity.ts",
+                    content: USER_ENTITY_TS
+                },
+                {
+                    filePath: "src/repositories/user.repository.ts",
+                    content: USER_REPOSITORY_TS
+                },
+                {
+                    filePath: "src/services/user.service.ts",
+                    content: USER_SERVICE_TS
+                },
+                {
+                    filePath: "src/auth/ability.factory.ts",
+                    content: ABILITY_FACTORY_TS
+                }
+            ]
+    });
+    for (const controller of workspace.getModels(_controllersourcefilemodel.ControllerSourceFile)){
+        controller.addImport("UserService", "../services/user.service.js").addConstructorParam("private readonly users: UserService");
+        controller.getMethod("getOne").setAsync(true).setBody([
+            "const user = await this.users.ensureFromPrincipal(this.principalProvider.currentPrincipal);",
+            // biome-ignore lint/suspicious/noTemplateCurlyInString: template literal in generated code
+            "return { id, message: `Hello ${user.displayName}!`, username: user.displayName };"
+        ]);
+    }
+}
 function scaffold(workspace, options) {
     if (options.authProvider !== "auth0") return;
     const resource = "Hello";
+    const withLocalUsers = options.databaseProvider === "postgres/typeorm";
     for (const controller of workspace.getModels(_controllersourcefilemodel.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()");
+        if (!withLocalUsers) {
+            controller.getMethod("getOne").setBody([
+                "const principal = this.principalProvider.currentPrincipal;",
+                "const username =",
+                '\t(typeof principal?.name === "string" && principal.name) ||',
+                '\t(typeof principal?.nickname === "string" && principal.nickname) ||',
+                '\t(typeof principal?.email === "string" && principal.email) ||',
+                '\t(typeof principal?.preferred_username === "string" && principal.preferred_username) ||',
+                "\tprincipal?.sub ||",
+                '\t"unknown";',
+                // biome-ignore lint/suspicious/noTemplateCurlyInString: template literal in generated code
+                "return { id, message: `Hello ${username}!`, username };"
+            ]);
+        }
         controller.getMethod("create").addDecorator(`@Authorize("create", "${resource}")`);
         controller.getMethod("update").addDecorator(`@Authorize("update", "${resource}")`);
         controller.getMethod("remove").addDecorator(`@Authorize("delete", "${resource}")`);
     }
-    workspace.getModel(_const.WELL_KNOWN_FILES.MAIN_TS)?.addSideEffectImport("@decohere/cortex/auth").addBuilderCall(".withAuth()");
+    const main = workspace.getModel(_const.WELL_KNOWN_FILES.MAIN_TS);
+    main?.addSideEffectImport("@decohere/cortex/auth");
+    if (withLocalUsers) {
+        scaffoldLocalUserProfile(workspace);
+        main?.addBuilderCall(".withAuth(createAbilityFactory, { principalMapper: mapPrincipal })");
+    } else {
+        main?.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
@@ -153,14 +429,18 @@ function scaffold(workspace, options) {
     const configSection = `auth:\n  discoveryUrl: ${issuerPlaceholder}\n  audience: ${audPlaceholder}\n`;
     workspace.getModel(_const.WELL_KNOWN_FILES.CONFIG_YAML)?.addSection(configSection);
     workspace.getModel(_const.WELL_KNOWN_FILES.ENV_FILE)?.addEntry("AUTH0_ISSUER_BASE_URL", options.issuerBaseUrl ?? "").addEntry("AUTH0_AUDIENCE", options.audience ?? "");
-    workspace.addModel(new _authconfigmodel.AuthConfigModel({
+    const authConfig = new _authconfigmodel.AuthConfigModel({
         issuerBaseUrl: options.issuerBaseUrl ?? "",
         audience: options.audience ?? ""
-    }));
+    });
+    workspace.addModel(authConfig);
+    if (withLocalUsers && options.adminPassword) {
+        createAuth0AdminUser(workspace, options, authConfig);
+    }
 }
 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":["AuthFeature","getOptions","workspace","cliOptions","authProvider","choices","label","selected","pick","c","provider","getAuth0Options","auth0Cli","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","ask","createApi","scaffold","options","resource","controller","getModels","ControllerSourceFile","addDecorator","addCortexImport","addImport","addConstructorParam","getMethod","getModel","WELL_KNOWN_FILES","MAIN_TS","addSideEffectImport","addBuilderCall","issuerPlaceholder","audPlaceholder","configSection","CONFIG_YAML","addSection","ENV_FILE","addEntry","addModel","AuthConfigModel"],"mappings":"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"}
+//# 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 { PackageJson } from \"../../models/package-json.model.js\";\nimport type { WorkspaceScaffold } from \"../../models/project.model.js\";\nimport type { Feature } from \"../../services/scaffold.service.js\";\nimport { WEBAPI_PROJECT_DIR } from \"../create-api.js\";\nimport type { ApiPackageJson } from \"../models/api-package-json.model.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\tdatabaseProvider?: \"none\" | \"postgres/typeorm\";\n\tadminUsername?: string;\n\tadminPassword?: string;\n};\n\nconst ADMIN_ROLE = \"admin\";\n\nconst USER_ENTITY_TS = `import { Column, Entity, PrimaryGeneratedColumn } from \"typeorm\";\nimport type { Entity as IEntity } from \"@decohere/codex\";\n\n@Entity()\nexport class UserEntity implements IEntity {\n\\t@PrimaryGeneratedColumn()\n\\tpublic id!: number;\n\n\\t@Column({ unique: true })\n\\tpublic sub!: string;\n\n\\t@Column({ type: \"varchar\", nullable: true })\n\\tpublic email!: string | null;\n\n\\t@Column()\n\\tpublic displayName!: string;\n\n\\t/** App-owned roles. The \\`admin\\` role grants CASL \\`manage\\`/\\`all\\` (wildcard). */\n\\t@Column({ type: \"simple-json\", default: \"[]\" })\n\\tpublic roles!: string[];\n}\n`;\n\nconst USER_REPOSITORY_TS = `import { injectable } from \"@decohere/crucible/decorators\";\nimport { injectUnitOfWork } from \"@decohere/codex\";\nimport { TypeOrmRepository, TypeOrmUnitOfWork } from \"@decohere/codex-typeorm\";\nimport { UserEntity } from \"../entities/user.entity.js\";\n\n@injectable()\nexport class UserEntityRepository extends TypeOrmRepository<UserEntity> {\n\\tpublic constructor(@injectUnitOfWork() unitOfWork: TypeOrmUnitOfWork) {\n\\t\\tsuper(unitOfWork, UserEntity);\n\\t}\n\n\\tpublic findBySub(sub: string): Promise<UserEntity | null> {\n\\t\\treturn this.firstOrDefault({ where: { sub } });\n\\t}\n}\n`;\n\nconst USER_SERVICE_TS = `import { injectable } from \"@decohere/crucible/decorators\";\nimport type { Principal } from \"@decohere/cortex\";\nimport { UserEntity } from \"../entities/user.entity.js\";\nimport { UserEntityRepository } from \"../repositories/user.repository.js\";\n\nfunction claimString(principal: Principal | undefined, key: string): string | undefined {\n\\tconst value = principal?.[key];\n\\treturn typeof value === \"string\" && value.length > 0 ? value : undefined;\n}\n\n@injectable()\nexport class UserService {\n\\tpublic constructor(private readonly users: UserEntityRepository) {}\n\n\\t/**\n\\t * Upsert a local profile keyed by JWT \\`sub\\`.\n\\t * Profile fields from the token fill gaps; seeded rows keep displayName/email/roles.\n\\t */\n\\tpublic async ensureFromPrincipal(principal: Principal | undefined): Promise<UserEntity> {\n\\t\\tconst sub = principal?.sub;\n\\t\\tif (!sub) {\n\\t\\t\\tthrow new Error(\"Authenticated request is missing principal.sub\");\n\\t\\t}\n\n\\t\\tconst email =\n\\t\\t\\tclaimString(principal, \"email\") ?? claimString(principal, \"preferred_username\");\n\\t\\tconst displayFromToken =\n\\t\\t\\tclaimString(principal, \"name\") ??\n\\t\\t\\tclaimString(principal, \"nickname\") ??\n\\t\\t\\temail;\n\n\\t\\tconst existing = await this.users.findBySub(sub);\n\\t\\tif (existing) {\n\\t\\t\\tlet dirty = false;\n\\t\\t\\tif (!existing.email && email) {\n\\t\\t\\t\\texisting.email = email;\n\\t\\t\\t\\tdirty = true;\n\\t\\t\\t}\n\\t\\t\\tif (existing.displayName === existing.sub && displayFromToken) {\n\\t\\t\\t\\texisting.displayName = displayFromToken;\n\\t\\t\\t\\tdirty = true;\n\\t\\t\\t}\n\\t\\t\\treturn dirty ? this.users.save(existing) : existing;\n\\t\\t}\n\n\\t\\tconst created = new UserEntity();\n\\t\\tcreated.sub = sub;\n\\t\\tcreated.email = email ?? null;\n\\t\\tcreated.displayName = displayFromToken ?? sub;\n\\t\\tcreated.roles = Array.isArray(principal.roles)\n\\t\\t\\t? principal.roles.filter((r): r is string => typeof r === \"string\")\n\\t\\t\\t: [];\n\\t\\treturn this.users.save(created);\n\\t}\n}\n`;\n\nconst ABILITY_FACTORY_TS = `import { AbilityBuilder, createMongoAbility } from \"@casl/ability\";\nimport type { Principal } from \"@decohere/cortex\";\n\n/** Root role — expands to CASL \\`manage\\`/\\`all\\` (covers every future ability). */\nexport const ADMIN_ROLE = \"admin\";\n\n/**\n * Roles are collections of abilities. Admin is a wildcard, not an enumerated list.\n * Non-admin principals keep the default Auth0 scope → ability mapping.\n */\nexport function createAbilityFactory(principal: Principal) {\n\\tconst { can, build } = new AbilityBuilder(createMongoAbility);\n\\tif (principal.roles?.includes(ADMIN_ROLE)) {\n\\t\\tcan(\"manage\", \"all\");\n\\t\\treturn build();\n\\t}\n\\tfor (const scope of principal.scopes ?? []) {\n\\t\\tconst [action, subject] = scope.split(\":\");\n\\t\\tif (action && subject) can(action, subject);\n\\t}\n\\treturn build();\n}\n\n/**\n * Map JWT payload → Principal. Bootstraps the seeded Auth0 admin \\`sub\\` with\n * the admin role so authorization works before/without roles in the access token.\n */\nexport function mapPrincipal(payload: Record<string, unknown>): Principal {\n\\tconst sub = typeof payload.sub === \"string\" ? payload.sub : \"\";\n\\tconst scopes = Array.isArray(payload.scopes)\n\\t\\t? (payload.scopes as string[])\n\\t\\t: typeof payload.scope === \"string\"\n\\t\\t\\t? payload.scope.split(\" \")\n\\t\\t\\t: undefined;\n\\tconst fromToken = Array.isArray(payload.roles)\n\\t\\t? (payload.roles as unknown[]).filter((r): r is string => typeof r === \"string\")\n\\t\\t: [];\n\\tconst roles =\n\\t\\tsub && sub === process.env.AUTH0_ADMIN_USER_SUB\n\\t\\t\\t? [...new Set([ADMIN_ROLE, ...fromToken])]\n\\t\\t\\t: fromToken.length > 0\n\\t\\t\\t\\t? fromToken\n\\t\\t\\t\\t: undefined;\n\\treturn { ...payload, sub, roles, scopes };\n}\n`;\n\nasync function getOptions(\n\tworkspace: WorkspaceScaffold,\n\tcliOptions: Partial<AuthOptions>,\n): Promise<Partial<AuthOptions>> {\n\tif (cliOptions.authProvider === \"auth0\" && !cliOptions.issuerBaseUrl) {\n\t\treturn getAuth0Options(workspace, cliOptions);\n\t}\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, cliOptions);\n}\n\nasync function getAuth0Options(\n\tworkspace: WorkspaceScaffold,\n\tcliOptions: Partial<AuthOptions>,\n): 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\ttry {\n\t\t\tauth0Cli.updateApiScopes(audience);\n\t\t\tconsole.log(`  \\u2713 API scopes ensured (${auth0Cli.HELLO_API_SCOPES.join(\", \")})`);\n\t\t} catch {\n\t\t\tconsole.error(\n\t\t\t\t\"  ✗ Failed to update API scopes — add Hello scopes in the Auth0 dashboard.\",\n\t\t\t);\n\t\t}\n\t}\n\n\tconst withLocalUsers = cliOptions.databaseProvider === \"postgres/typeorm\";\n\tlet adminUsername: string | undefined;\n\tlet adminPassword: string | undefined;\n\tif (withLocalUsers) {\n\t\tadminUsername =\n\t\t\tcliOptions.adminUsername ?? (await ask(\"\\n  Admin username [admin]: \", \"admin\"));\n\t\tadminPassword = cliOptions.adminPassword;\n\t\tif (adminPassword == null) {\n\t\t\tadminPassword = await ask(\"  Admin password (leave blank to generate): \");\n\t\t\tif (!adminPassword) {\n\t\t\t\tadminPassword = auth0Cli.generateAdminPassword();\n\t\t\t\tconsole.log(`  ✓ Generated admin password (written to .env): ${adminPassword}`);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn {\n\t\tauthProvider: \"auth0\",\n\t\tissuerBaseUrl,\n\t\taudience,\n\t\t...(withLocalUsers ? { adminUsername, adminPassword } : {}),\n\t};\n}\n\nfunction adminEmail(workspaceName: string, username: string): string {\n\tif (username.includes(\"@\")) return username;\n\tconst slug = workspaceName.toLowerCase().replace(/[^a-z0-9-]/g, \"-\");\n\treturn `${username}@${slug}.example.com`;\n}\n\nfunction createAuth0AdminUser(\n\tworkspace: WorkspaceScaffold,\n\toptions: AuthOptions,\n\tauthConfig: AuthConfigModel,\n): void {\n\tconst username = options.adminUsername ?? \"admin\";\n\tconst password = options.adminPassword;\n\tif (!password) return;\n\n\ttry {\n\t\tconst admin = auth0Cli.createAdminDatabaseUser({\n\t\t\temail: adminEmail(workspace.name, username),\n\t\t\tpassword,\n\t\t\tusername,\n\t\t});\n\t\tauthConfig.setAdminUser({\n\t\t\tsub: admin.user_id,\n\t\t\temail: admin.email,\n\t\t\tpassword: admin.password,\n\t\t\tusername: admin.username,\n\t\t});\n\t\tworkspace\n\t\t\t.getModel<EnvFile>(WELL_KNOWN_FILES.ENV_FILE)\n\t\t\t?.addEntry(\"AUTH0_ADMIN_USER_SUB\", admin.user_id)\n\t\t\t.addEntry(\"AUTH0_ADMIN_USER_EMAIL\", admin.email)\n\t\t\t.addEntry(\"AUTH0_ADMIN_USER_PASSWORD\", admin.password)\n\t\t\t.addEntry(\"AUTH0_ADMIN_USERNAME\", admin.username);\n\t\tconsole.log(`  ✓ Auth0 admin user created: ${admin.email} (role: ${ADMIN_ROLE})`);\n\t\tconsole.log(`    Login with EMAIL (not username): ${admin.email}`);\n\t\tconsole.log(`    Password: see AUTH0_ADMIN_USER_PASSWORD in .env`);\n\t} catch (err) {\n\t\tconsole.error(\n\t\t\t`  ✗ Failed to create Auth0 admin user: ${err instanceof Error ? err.message : err}`,\n\t\t);\n\t}\n}\n\nfunction scaffoldLocalUserProfile(workspace: WorkspaceScaffold): void {\n\tworkspace\n\t\t.getModel<PackageJson>(WELL_KNOWN_FILES.PACKAGE_JSON)\n\t\t?.addDependency(\"@casl/ability\", \"^6.8.1\");\n\tworkspace\n\t\t.getModel<ApiPackageJson>(WELL_KNOWN_FILES.API_PACKAGE_JSON)\n\t\t?.addDependency(\"@casl/ability\", \"^6.8.1\");\n\n\tconst main = workspace.getModel<MainSourceFile>(WELL_KNOWN_FILES.MAIN_TS);\n\tmain\n\t\t?.addEntity({ className: \"UserEntity\", importPath: \"./entities/user.entity.js\" })\n\t\t.addRepository({\n\t\t\tclassName: \"UserEntityRepository\",\n\t\t\timportPath: \"./repositories/user.repository.js\",\n\t\t})\n\t\t.addService({\n\t\t\tclassName: \"UserService\",\n\t\t\timportPath: \"./services/user.service.js\",\n\t\t\tscope: \"request\",\n\t\t})\n\t\t.addImport(\"createAbilityFactory\", \"./auth/ability.factory.js\")\n\t\t.addImport(\"mapPrincipal\", \"./auth/ability.factory.js\")\n\t\t.setTypeOrmSeed(\n\t\t\t[\n\t\t\t\t\"const sub = process.env.AUTH0_ADMIN_USER_SUB;\",\n\t\t\t\t\"if (!sub) return;\",\n\t\t\t\t\"const repo = dataSource.getRepository(UserEntity);\",\n\t\t\t\t\"const existing = await repo.findOne({ where: { sub } });\",\n\t\t\t\t\"if (existing) return;\",\n\t\t\t\t\"await repo.save(repo.create({\",\n\t\t\t\t\"  sub,\",\n\t\t\t\t\"  email: process.env.AUTH0_ADMIN_USER_EMAIL ?? null,\",\n\t\t\t\t'  displayName: process.env.AUTH0_ADMIN_USERNAME ?? \"admin\",',\n\t\t\t\t'  roles: [\"admin\"],',\n\t\t\t\t\"}));\",\n\t\t\t].join(\" \"),\n\t\t);\n\n\tworkspace.getProject(WEBAPI_PROJECT_DIR)?.addFile({\n\t\tfiles: () => [\n\t\t\t{ filePath: \"src/entities/user.entity.ts\", content: USER_ENTITY_TS },\n\t\t\t{ filePath: \"src/repositories/user.repository.ts\", content: USER_REPOSITORY_TS },\n\t\t\t{ filePath: \"src/services/user.service.ts\", content: USER_SERVICE_TS },\n\t\t\t{ filePath: \"src/auth/ability.factory.ts\", content: ABILITY_FACTORY_TS },\n\t\t],\n\t});\n\n\tfor (const controller of workspace.getModels(ControllerSourceFile)) {\n\t\tcontroller\n\t\t\t.addImport(\"UserService\", \"../services/user.service.js\")\n\t\t\t.addConstructorParam(\"private readonly users: UserService\");\n\t\tcontroller.getMethod(\"getOne\").setAsync(true).setBody([\n\t\t\t\"const user = await this.users.ensureFromPrincipal(this.principalProvider.currentPrincipal);\",\n\t\t\t// biome-ignore lint/suspicious/noTemplateCurlyInString: template literal in generated code\n\t\t\t\"return { id, message: `Hello ${user.displayName}!`, username: user.displayName };\",\n\t\t]);\n\t}\n}\n\nfunction scaffold(workspace: WorkspaceScaffold, options: AuthOptions): void {\n\tif (options.authProvider !== \"auth0\") return;\n\n\tconst resource = \"Hello\";\n\tconst withLocalUsers = options.databaseProvider === \"postgres/typeorm\";\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\tif (!withLocalUsers) {\n\t\t\tcontroller.getMethod(\"getOne\").setBody([\n\t\t\t\t\"const principal = this.principalProvider.currentPrincipal;\",\n\t\t\t\t\"const username =\",\n\t\t\t\t'\\t(typeof principal?.name === \"string\" && principal.name) ||',\n\t\t\t\t'\\t(typeof principal?.nickname === \"string\" && principal.nickname) ||',\n\t\t\t\t'\\t(typeof principal?.email === \"string\" && principal.email) ||',\n\t\t\t\t'\\t(typeof principal?.preferred_username === \"string\" && principal.preferred_username) ||',\n\t\t\t\t\"\\tprincipal?.sub ||\",\n\t\t\t\t'\\t\"unknown\";',\n\t\t\t\t// biome-ignore lint/suspicious/noTemplateCurlyInString: template literal in generated code\n\t\t\t\t\"return { id, message: `Hello ${username}!`, username };\",\n\t\t\t]);\n\t\t}\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\tconst main = workspace.getModel<MainSourceFile>(WELL_KNOWN_FILES.MAIN_TS);\n\tmain?.addSideEffectImport(\"@decohere/cortex/auth\");\n\n\tif (withLocalUsers) {\n\t\tscaffoldLocalUserProfile(workspace);\n\t\tmain?.addBuilderCall(\".withAuth(createAbilityFactory, { principalMapper: mapPrincipal })\");\n\t} else {\n\t\tmain?.addBuilderCall(\".withAuth()\");\n\t}\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\tconst authConfig = new AuthConfigModel({\n\t\tissuerBaseUrl: options.issuerBaseUrl ?? \"\",\n\t\taudience: options.audience ?? \"\",\n\t});\n\tworkspace.addModel(authConfig);\n\n\tif (withLocalUsers && options.adminPassword) {\n\t\tcreateAuth0AdminUser(workspace, options, authConfig);\n\t}\n}\n\nexport const AuthFeature: Feature<AuthOptions> = { getOptions, scaffold };\n"],"names":["AuthFeature","ADMIN_ROLE","USER_ENTITY_TS","USER_REPOSITORY_TS","USER_SERVICE_TS","ABILITY_FACTORY_TS","getOptions","workspace","cliOptions","authProvider","issuerBaseUrl","getAuth0Options","choices","label","selected","pick","c","provider","auth0Cli","isInstalled","console","error","process","exit","stdout","write","tenants","listTenants","length","log","login","listApis","err","Auth0AuthError","active","find","t","name","userApis","filter","a","includes","projectName","apiChoices","existing","map","identifier","apiSelected","audience","defaultId","ask","createApi","updateApiScopes","HELLO_API_SCOPES","join","withLocalUsers","databaseProvider","adminUsername","adminPassword","generateAdminPassword","adminEmail","workspaceName","username","slug","toLowerCase","replace","createAuth0AdminUser","options","authConfig","password","admin","createAdminDatabaseUser","email","setAdminUser","sub","user_id","getModel","WELL_KNOWN_FILES","ENV_FILE","addEntry","Error","message","scaffoldLocalUserProfile","PACKAGE_JSON","addDependency","API_PACKAGE_JSON","main","MAIN_TS","addEntity","className","importPath","addRepository","addService","scope","addImport","setTypeOrmSeed","getProject","WEBAPI_PROJECT_DIR","addFile","files","filePath","content","controller","getModels","ControllerSourceFile","addConstructorParam","getMethod","setAsync","setBody","scaffold","resource","addDecorator","addCortexImport","addSideEffectImport","addBuilderCall","issuerPlaceholder","audPlaceholder","configSection","CONFIG_YAML","addSection","AuthConfigModel","addModel"],"mappings":"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"}