@decohere/create 0.0.1-dev.23 → 0.0.1-dev.25

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

@@ -1,6 +1,26 @@
 import { execFileSync, spawnSync } from "node:child_process";
-const REQUIRED_SCOPES = "create:clients";
+import { randomBytes } from "node:crypto";
+/** Management API scopes needed for API, SPA, connections, and admin users. */ const REQUIRED_SCOPES = [
+    "create:clients",
+    "read:clients",
+    "update:clients",
+    "create:resource_servers",
+    "read:resource_servers",
+    "update:resource_servers",
+    "read:connections",
+    "update:connections",
+    "create:users",
+    "read:users",
+    "update:users"
+].join(",");
 /** Hard timeout for any Management API call. Prevents indefinite hangs on token re-auth. */ const API_TIMEOUT_MS = 8_000;
+/** Default API scopes matching Hello CASL Authorize decorators. */ export const HELLO_API_SCOPES = [
+    "read:Hello",
+    "create:Hello",
+    "update:Hello",
+    "delete:Hello"
+];
+export const DB_CONNECTION_NAME = "Username-Password-Authentication";
 export class Auth0AuthError extends Error {
     constructor(message){
         super(message);
@@ -10,6 +30,16 @@ export class Auth0AuthError extends Error {
 /** 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");
 }
+/** Strip Auth0 CLI banner lines before JSON. */ function parseJsonOutput(stdout) {
+    const start = stdout.indexOf("{");
+    const arrayStart = stdout.indexOf("[");
+    let idx = -1;
+    if (start === -1) idx = arrayStart;
+    else if (arrayStart === -1) idx = start;
+    else idx = Math.min(start, arrayStart);
+    if (idx < 0) throw new Error(`Expected JSON from auth0 CLI, got: ${stdout.slice(0, 200)}`);
+    return JSON.parse(stdout.slice(idx));
+}
 /** 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",
@@ -18,7 +48,6 @@ export class Auth0AuthError extends Error {
         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);
@@ -77,13 +106,13 @@ export function listApis() {
             "--json",
             "--no-input"
         ]);
-        return JSON.parse(out);
+        return parseJsonOutput(out);
     } catch (err) {
         if (err instanceof Auth0AuthError) throw err;
         return [];
     }
 }
-export function createApi(name, identifier) {
+export function createApi(name, identifier, scopes = HELLO_API_SCOPES) {
     const out = runAuth0([
         "apis",
         "create",
@@ -91,12 +120,25 @@ export function createApi(name, identifier) {
         name,
         "--identifier",
         identifier,
+        "--scopes",
+        scopes.join(","),
         "--json",
         "--no-input"
     ]);
-    return JSON.parse(out);
+    return parseJsonOutput(out);
+}
+/** Replace an API's scopes (Auth0 CLI update --scopes replaces the full set). */ export function updateApiScopes(identifier, scopes = HELLO_API_SCOPES) {
+    runAuth0([
+        "apis",
+        "update",
+        identifier,
+        "--scopes",
+        scopes.join(","),
+        "--no-input"
+    ]);
 }
-export function createSpaApp(name, callbackUrl) {
+export function createSpaApp(name, callbackUrls) {
+    const callbacks = typeof callbackUrls === "string" ? callbackUrls : callbackUrls.join(",");
     const out = runAuth0([
         "apps",
         "create",
@@ -105,12 +147,191 @@ export function createSpaApp(name, callbackUrl) {
         "--type",
         "spa",
         "--callbacks",
-        callbackUrl,
+        callbacks,
         "--json",
         "--no-input"
     ]);
-    return JSON.parse(out);
+    const app = parseJsonOutput(out);
+    const clientId = app.client_id ?? app.clientId;
+    if (!clientId) {
+        throw new Error(`Auth0 create SPA response missing client_id. stdout: ${out.slice(0, 300)}`);
+    }
+    return {
+        client_id: clientId
+    };
+}
+export function listApps() {
+    try {
+        const out = runAuth0([
+            "apps",
+            "list",
+            "--json",
+            "--no-input"
+        ]);
+        const apps = parseJsonOutput(out);
+        return apps.map((a)=>({
+                client_id: a.client_id ?? a.clientId ?? "",
+                name: a.name ?? ""
+            })).filter((a)=>a.client_id && a.name);
+    } catch (err) {
+        if (err instanceof Auth0AuthError) throw err;
+        return [];
+    }
+}
+export function updateSpaCallbacks(clientId, callbackUrls) {
+    const callbacks = typeof callbackUrls === "string" ? callbackUrls : callbackUrls.join(",");
+    runAuth0([
+        "apps",
+        "update",
+        clientId,
+        "--callbacks",
+        callbacks,
+        "--no-input"
+    ]);
+}
+/**
+ * Create a Postman SPA, or reuse an existing app with the same name (re-scaffold).
+ * Always returns a client_id suitable for Postman auth0ClientId.
+ */ export function ensureSpaApp(name, callbackUrls) {
+    const existing = listApps().find((a)=>a.name === name);
+    if (existing) {
+        try {
+            updateSpaCallbacks(existing.client_id, callbackUrls);
+        } catch  {
+        // Callbacks may already match; still usable for Postman.
+        }
+        return {
+            client_id: existing.client_id,
+            reused: true
+        };
+    }
+    return {
+        ...createSpaApp(name, callbackUrls),
+        reused: false
+    };
+}
+/** Enable a database connection for an application (required for username/password login). */ export function enableConnectionForClient(connectionName, clientId) {
+    const listOut = runAuth0([
+        "api",
+        "get",
+        "connections",
+        "--no-input"
+    ]);
+    const connections = parseJsonOutput(listOut);
+    const connection = connections.find((c)=>c.name === connectionName);
+    if (!connection) {
+        throw new Error(`Auth0 connection not found: ${connectionName}`);
+    }
+    const clientsOut = runAuth0([
+        "api",
+        "get",
+        `connections/${connection.id}/clients`,
+        "--no-input"
+    ]);
+    const { clients } = parseJsonOutput(clientsOut);
+    if (clients.some((c)=>c.client_id === clientId)) return;
+    // Dedicated enabled-clients endpoint (enabled_clients on connection PATCH is deprecated).
+    runAuth0([
+        "api",
+        "patch",
+        `connections/${connection.id}/clients`,
+        "--data",
+        JSON.stringify([
+            {
+                client_id: clientId,
+                status: true
+            }
+        ]),
+        "--no-input"
+    ]);
+}
+/** Strong default password when the scaffolder caller leaves password blank. */ export function generateAdminPassword() {
+    return `${randomBytes(12).toString("base64url")}aA1!`;
+}
+function isUserAlreadyExistsError(err) {
+    const text = err instanceof Error ? err.message : String(err);
+    return /already exists|user exists|Conflict|409/i.test(text);
+}
+/** Look up a user by email (Management API users-by-email). */ export function findUserByEmail(email) {
+    const out = runAuth0([
+        "api",
+        "get",
+        `users-by-email?email=${encodeURIComponent(email)}`,
+        "--no-input"
+    ]);
+    const users = parseJsonOutput(out);
+    const user = users.find((u)=>u.user_id && u.email);
+    if (!user?.user_id || !user.email) return null;
+    return {
+        user_id: user.user_id,
+        email: user.email
+    };
+}
+/** Reset password so a re-scaffold can write a known password to .env. */ export function updateUserPassword(userId, password) {
+    runAuth0([
+        "api",
+        "patch",
+        `users/${encodeURIComponent(userId)}`,
+        "--data",
+        JSON.stringify({
+            password,
+            connection: DB_CONNECTION_NAME
+        }),
+        "--no-input"
+    ]);
+}
+/**
+ * Create a DB connection root-admin user for local / Postman login.
+ * If the user already exists, look them up, reset password to `input.password`,
+ * and return that identity so callers can still write .env credentials.
+ */ export function createAdminDatabaseUser(input) {
+    const body = {
+        email: input.email,
+        connection: DB_CONNECTION_NAME,
+        password: input.password,
+        name: input.username,
+        email_verified: true,
+        verify_email: false,
+        app_metadata: {
+            roles: [
+                "admin"
+            ]
+        }
+    };
+    try {
+        const out = runAuth0([
+            "api",
+            "post",
+            "users",
+            "--data",
+            JSON.stringify(body),
+            "--no-input"
+        ]);
+        const user = parseJsonOutput(out);
+        if (!user.user_id || !user.email) {
+            throw new Error(`Auth0 create user response missing user_id/email. stdout: ${out.slice(0, 300)}`);
+        }
+        return {
+            user_id: user.user_id,
+            email: user.email,
+            password: input.password,
+            username: input.username
+        };
+    } catch (err) {
+        if (!isUserAlreadyExistsError(err)) throw err;
+        const existing = findUserByEmail(input.email);
+        if (!existing) {
+            throw new Error(`Auth0 user already exists for ${input.email}, but lookup by email returned no user.`);
+        }
+        updateUserPassword(existing.user_id, input.password);
+        return {
+            user_id: existing.user_id,
+            email: existing.email,
+            password: input.password,
+            username: input.username
+        };
+    }
 }
 export { REQUIRED_SCOPES };
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/features/auth0-cli.ts"],"sourcesContent":["import { execFileSync, spawnSync } from \"node:child_process\";\nimport { randomBytes } from \"node:crypto\";\n\n/** Management API scopes needed for API, SPA, connections, and admin users. */\nconst REQUIRED_SCOPES = [\n\t\"create:clients\",\n\t\"read:clients\",\n\t\"update:clients\",\n\t\"create:resource_servers\",\n\t\"read:resource_servers\",\n\t\"update:resource_servers\",\n\t\"read:connections\",\n\t\"update:connections\",\n\t\"create:users\",\n\t\"read:users\",\n\t\"update:users\",\n].join(\",\");\n\n/** Hard timeout for any Management API call. Prevents indefinite hangs on token re-auth. */\nconst API_TIMEOUT_MS = 8_000;\n\n/** Default API scopes matching Hello CASL Authorize decorators. */\nexport const HELLO_API_SCOPES = [\n\t\"read:Hello\",\n\t\"create:Hello\",\n\t\"update:Hello\",\n\t\"delete:Hello\",\n] as const;\n\nexport const DB_CONNECTION_NAME = \"Username-Password-Authentication\";\n\nexport class Auth0AuthError extends Error {\n\tpublic constructor(message: string) {\n\t\tsuper(message);\n\t\tthis.name = \"Auth0AuthError\";\n\t}\n}\n\n/** Returns true if an error or stderr output looks like an expired/missing token. */\nfunction isAuthError(text: string): boolean {\n\treturn (\n\t\ttext.includes(\"renew access token\") ||\n\t\ttext.includes(\"log in\") ||\n\t\ttext.includes(\"Unauthorized\")\n\t);\n}\n\n/** Strip Auth0 CLI banner lines before JSON. */\nfunction parseJsonOutput<T>(stdout: string): T {\n\tconst start = stdout.indexOf(\"{\");\n\tconst arrayStart = stdout.indexOf(\"[\");\n\tlet idx = -1;\n\tif (start === -1) idx = arrayStart;\n\telse if (arrayStart === -1) idx = start;\n\telse idx = Math.min(start, arrayStart);\n\tif (idx < 0) throw new Error(`Expected JSON from auth0 CLI, got: ${stdout.slice(0, 200)}`);\n\treturn JSON.parse(stdout.slice(idx)) as T;\n}\n\n/** Run an auth0 CLI command with a hard timeout. Returns stdout on success, throws on failure. */\nfunction runAuth0(args: string[]): string {\n\tconst result = spawnSync(\"auth0\", args, {\n\t\tencoding: \"utf8\",\n\t\ttimeout: API_TIMEOUT_MS,\n\t\tinput: \"\",\n\t\tstdio: \"pipe\",\n\t});\n\n\tif (result.error) {\n\t\tconst msg = result.error.message;\n\t\tif (isAuthError(msg) || (result.error as NodeJS.ErrnoException).code === \"ETIMEDOUT\") {\n\t\t\tthrow new Auth0AuthError(msg);\n\t\t}\n\t\tthrow result.error;\n\t}\n\n\tif (result.status !== 0) {\n\t\tconst stderr = result.stderr ?? \"\";\n\t\tif (isAuthError(stderr)) throw new Auth0AuthError(stderr);\n\t\tthrow new Error(stderr || `auth0 exited with code ${result.status}`);\n\t}\n\n\treturn result.stdout;\n}\n\nexport interface Auth0Tenant {\n\tname: string;\n\tactive?: boolean;\n}\n\nexport function isInstalled(): boolean {\n\ttry {\n\t\texecFileSync(\"auth0\", [\"--version\"], { stdio: \"pipe\" });\n\t\treturn true;\n\t} catch {\n\t\treturn false;\n\t}\n}\n\nexport function listTenants(): Auth0Tenant[] {\n\ttry {\n\t\tconst out = execFileSync(\"auth0\", [\"tenants\", \"list\", \"--json\"], {\n\t\t\tencoding: \"utf8\",\n\t\t\tstdio: \"pipe\",\n\t\t});\n\t\treturn JSON.parse(out) as Auth0Tenant[];\n\t} catch {\n\t\treturn [];\n\t}\n}\n\nexport function login(): boolean {\n\tconst result = spawnSync(\"auth0\", [\"login\", \"--scopes\", REQUIRED_SCOPES], {\n\t\tstdio: \"inherit\",\n\t});\n\treturn result.status === 0;\n}\n\nexport function listApis(): Array<{ identifier: string; name: string }> {\n\ttry {\n\t\tconst out = runAuth0([\"apis\", \"list\", \"--json\", \"--no-input\"]);\n\t\treturn parseJsonOutput(out);\n\t} catch (err) {\n\t\tif (err instanceof Auth0AuthError) throw err;\n\t\treturn [];\n\t}\n}\n\nexport function createApi(\n\tname: string,\n\tidentifier: string,\n\tscopes: readonly string[] = HELLO_API_SCOPES,\n): { identifier: string } {\n\tconst out = runAuth0([\n\t\t\"apis\",\n\t\t\"create\",\n\t\t\"--name\",\n\t\tname,\n\t\t\"--identifier\",\n\t\tidentifier,\n\t\t\"--scopes\",\n\t\tscopes.join(\",\"),\n\t\t\"--json\",\n\t\t\"--no-input\",\n\t]);\n\treturn parseJsonOutput(out);\n}\n\n/** Replace an API's scopes (Auth0 CLI update --scopes replaces the full set). */\nexport function updateApiScopes(\n\tidentifier: string,\n\tscopes: readonly string[] = HELLO_API_SCOPES,\n): void {\n\trunAuth0([\"apis\", \"update\", identifier, \"--scopes\", scopes.join(\",\"), \"--no-input\"]);\n}\n\nexport function createSpaApp(\n\tname: string,\n\tcallbackUrls: string | readonly string[],\n): { client_id: string } {\n\tconst callbacks = typeof callbackUrls === \"string\" ? callbackUrls : callbackUrls.join(\",\");\n\tconst out = runAuth0([\n\t\t\"apps\",\n\t\t\"create\",\n\t\t\"--name\",\n\t\tname,\n\t\t\"--type\",\n\t\t\"spa\",\n\t\t\"--callbacks\",\n\t\tcallbacks,\n\t\t\"--json\",\n\t\t\"--no-input\",\n\t]);\n\tconst app = parseJsonOutput<{ client_id?: string; clientId?: string }>(out);\n\tconst clientId = app.client_id ?? app.clientId;\n\tif (!clientId) {\n\t\tthrow new Error(\n\t\t\t`Auth0 create SPA response missing client_id. stdout: ${out.slice(0, 300)}`,\n\t\t);\n\t}\n\treturn { client_id: clientId };\n}\n\nexport type Auth0App = { client_id: string; name: string };\n\nexport function listApps(): Auth0App[] {\n\ttry {\n\t\tconst out = runAuth0([\"apps\", \"list\", \"--json\", \"--no-input\"]);\n\t\tconst apps =\n\t\t\tparseJsonOutput<Array<{ client_id?: string; clientId?: string; name?: string }>>(out);\n\t\treturn apps\n\t\t\t.map((a) => ({\n\t\t\t\tclient_id: a.client_id ?? a.clientId ?? \"\",\n\t\t\t\tname: a.name ?? \"\",\n\t\t\t}))\n\t\t\t.filter((a) => a.client_id && a.name);\n\t} catch (err) {\n\t\tif (err instanceof Auth0AuthError) throw err;\n\t\treturn [];\n\t}\n}\n\nexport function updateSpaCallbacks(\n\tclientId: string,\n\tcallbackUrls: string | readonly string[],\n): void {\n\tconst callbacks = typeof callbackUrls === \"string\" ? callbackUrls : callbackUrls.join(\",\");\n\trunAuth0([\"apps\", \"update\", clientId, \"--callbacks\", callbacks, \"--no-input\"]);\n}\n\n/**\n * Create a Postman SPA, or reuse an existing app with the same name (re-scaffold).\n * Always returns a client_id suitable for Postman auth0ClientId.\n */\nexport function ensureSpaApp(\n\tname: string,\n\tcallbackUrls: string | readonly string[],\n): { client_id: string; reused: boolean } {\n\tconst existing = listApps().find((a) => a.name === name);\n\tif (existing) {\n\t\ttry {\n\t\t\tupdateSpaCallbacks(existing.client_id, callbackUrls);\n\t\t} catch {\n\t\t\t// Callbacks may already match; still usable for Postman.\n\t\t}\n\t\treturn { client_id: existing.client_id, reused: true };\n\t}\n\treturn { ...createSpaApp(name, callbackUrls), reused: false };\n}\n\ntype Auth0Connection = { id: string; name: string; strategy: string };\n\n/** Enable a database connection for an application (required for username/password login). */\nexport function enableConnectionForClient(connectionName: string, clientId: string): void {\n\tconst listOut = runAuth0([\"api\", \"get\", \"connections\", \"--no-input\"]);\n\tconst connections = parseJsonOutput<Auth0Connection[]>(listOut);\n\tconst connection = connections.find((c) => c.name === connectionName);\n\tif (!connection) {\n\t\tthrow new Error(`Auth0 connection not found: ${connectionName}`);\n\t}\n\n\tconst clientsOut = runAuth0([\n\t\t\"api\",\n\t\t\"get\",\n\t\t`connections/${connection.id}/clients`,\n\t\t\"--no-input\",\n\t]);\n\tconst { clients } = parseJsonOutput<{ clients: Array<{ client_id: string }> }>(clientsOut);\n\tif (clients.some((c) => c.client_id === clientId)) return;\n\n\t// Dedicated enabled-clients endpoint (enabled_clients on connection PATCH is deprecated).\n\trunAuth0([\n\t\t\"api\",\n\t\t\"patch\",\n\t\t`connections/${connection.id}/clients`,\n\t\t\"--data\",\n\t\tJSON.stringify([{ client_id: clientId, status: true }]),\n\t\t\"--no-input\",\n\t]);\n}\n\nexport type AdminDatabaseUser = {\n\tuser_id: string;\n\temail: string;\n\tpassword: string;\n\tusername: string;\n};\n\n/** Strong default password when the scaffolder caller leaves password blank. */\nexport function generateAdminPassword(): string {\n\treturn `${randomBytes(12).toString(\"base64url\")}aA1!`;\n}\n\nfunction isUserAlreadyExistsError(err: unknown): boolean {\n\tconst text = err instanceof Error ? err.message : String(err);\n\treturn /already exists|user exists|Conflict|409/i.test(text);\n}\n\n/** Look up a user by email (Management API users-by-email). */\nexport function findUserByEmail(email: string): { user_id: string; email: string } | null {\n\tconst out = runAuth0([\n\t\t\"api\",\n\t\t\"get\",\n\t\t`users-by-email?email=${encodeURIComponent(email)}`,\n\t\t\"--no-input\",\n\t]);\n\tconst users = parseJsonOutput<Array<{ user_id?: string; email?: string }>>(out);\n\tconst user = users.find((u) => u.user_id && u.email);\n\tif (!user?.user_id || !user.email) return null;\n\treturn { user_id: user.user_id, email: user.email };\n}\n\n/** Reset password so a re-scaffold can write a known password to .env. */\nexport function updateUserPassword(userId: string, password: string): void {\n\trunAuth0([\n\t\t\"api\",\n\t\t\"patch\",\n\t\t`users/${encodeURIComponent(userId)}`,\n\t\t\"--data\",\n\t\tJSON.stringify({ password, connection: DB_CONNECTION_NAME }),\n\t\t\"--no-input\",\n\t]);\n}\n\n/**\n * Create a DB connection root-admin user for local / Postman login.\n * If the user already exists, look them up, reset password to `input.password`,\n * and return that identity so callers can still write .env credentials.\n */\nexport function createAdminDatabaseUser(input: {\n\temail: string;\n\tpassword: string;\n\tusername: string;\n}): AdminDatabaseUser {\n\tconst body = {\n\t\temail: input.email,\n\t\tconnection: DB_CONNECTION_NAME,\n\t\tpassword: input.password,\n\t\tname: input.username,\n\t\temail_verified: true,\n\t\tverify_email: false,\n\t\tapp_metadata: { roles: [\"admin\"] },\n\t};\n\n\ttry {\n\t\tconst out = runAuth0([\n\t\t\t\"api\",\n\t\t\t\"post\",\n\t\t\t\"users\",\n\t\t\t\"--data\",\n\t\t\tJSON.stringify(body),\n\t\t\t\"--no-input\",\n\t\t]);\n\t\tconst user = parseJsonOutput<{ user_id?: string; email?: string }>(out);\n\t\tif (!user.user_id || !user.email) {\n\t\t\tthrow new Error(\n\t\t\t\t`Auth0 create user response missing user_id/email. stdout: ${out.slice(0, 300)}`,\n\t\t\t);\n\t\t}\n\t\treturn {\n\t\t\tuser_id: user.user_id,\n\t\t\temail: user.email,\n\t\t\tpassword: input.password,\n\t\t\tusername: input.username,\n\t\t};\n\t} catch (err) {\n\t\tif (!isUserAlreadyExistsError(err)) throw err;\n\n\t\tconst existing = findUserByEmail(input.email);\n\t\tif (!existing) {\n\t\t\tthrow new Error(\n\t\t\t\t`Auth0 user already exists for ${input.email}, but lookup by email returned no user.`,\n\t\t\t);\n\t\t}\n\n\t\tupdateUserPassword(existing.user_id, input.password);\n\t\treturn {\n\t\t\tuser_id: existing.user_id,\n\t\t\temail: existing.email,\n\t\t\tpassword: input.password,\n\t\t\tusername: input.username,\n\t\t};\n\t}\n}\n\nexport { REQUIRED_SCOPES };\n"],"names":["execFileSync","spawnSync","randomBytes","REQUIRED_SCOPES","join","API_TIMEOUT_MS","HELLO_API_SCOPES","DB_CONNECTION_NAME","Auth0AuthError","Error","message","name","isAuthError","text","includes","parseJsonOutput","stdout","start","indexOf","arrayStart","idx","Math","min","slice","JSON","parse","runAuth0","args","result","encoding","timeout","input","stdio","error","msg","code","status","stderr","isInstalled","listTenants","out","login","listApis","err","createApi","identifier","scopes","updateApiScopes","createSpaApp","callbackUrls","callbacks","app","clientId","client_id","listApps","apps","map","a","filter","updateSpaCallbacks","ensureSpaApp","existing","find","reused","enableConnectionForClient","connectionName","listOut","connections","connection","c","clientsOut","id","clients","some","stringify","generateAdminPassword","toString","isUserAlreadyExistsError","String","test","findUserByEmail","email","encodeURIComponent","users","user","u","user_id","updateUserPassword","userId","password","createAdminDatabaseUser","body","username","email_verified","verify_email","app_metadata","roles"],"mappings":"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"}

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

@@ -1,8 +1,20 @@
 import { randomBytes } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { pick } from "../../domain/prompt.js";
 import { WELL_KNOWN_FILES } from "../../models/const.js";
 import { CREATE_VERSION } from "../../version.js";
 import { WEBAPI_PROJECT_DIR } from "../create-api.js";
+/** Read a single KEY= from an existing target `.env` (if any). */ function readExistingEnvValue(workspace, key) {
+    try {
+        const raw = readFileSync(join(workspace.targetDir, ".env"), "utf8");
+        const line = raw.split("\n").find((l)=>l.startsWith(`${key}=`));
+        const value = line?.slice(key.length + 1).trim();
+        return value || undefined;
+    } catch  {
+        return undefined;
+    }
+}
 // Base config uses env-var references for production; the dev config section
 // written below overrides only the concrete values needed locally.
 const DATABASE_BASE_CONFIG_YAML = `database:
@@ -20,10 +32,10 @@ const DATABASE_BASE_CONFIG_YAML = `database:
       adminPassword: \${DB_ADMIN_PASSWORD}
 `;
 // Dev config only overrides what differs from base — credentials come from .env via env-var references.
+// Host comes from DB_HOST in .env (postgres on the compose network; 127.0.0.1 from the host).
 const DATABASE_DEV_CONFIG_YAML = `database:
   dataSources:
-    - host: postgres
-      synchronize: true
+    - synchronize: true
       seed: true
 `;
 const SAMPLE_ENTITY_TS = `import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
@@ -68,34 +80,56 @@ async function getOptions(_workspace, cliOptions) {
 function scaffold(workspace, options) {
     if (options.databaseProvider !== "postgres/typeorm") return;
     const name = workspace.name;
-    const password = randomBytes(16).toString("hex");
+    // Prefer an existing POSTGRES_PASSWORD so re-scaffold does not rotate credentials
+    // out from under an already-initialized Docker volume (Postgres only applies
+    // POSTGRES_PASSWORD on first data-dir init).
+    const existingPassword = readExistingEnvValue(workspace, "POSTGRES_PASSWORD");
+    const password = existingPassword || randomBytes(16).toString("hex");
     const db = `${name}_dev`;
     const user = "postgres";
     const devContainer = workspace.getModel(WELL_KNOWN_FILES.DEVCONTAINER_JSON);
     const compose = workspace.getModel(WELL_KNOWN_FILES.DOCKER_COMPOSE);
-    // Add postgres service to compose
+    const networkKey = name;
+    const volumeName = `${name}-postgres-data`;
+    // Isolated compose project network + volume (not ark's shared Postgres).
+    // Alias `postgres` so other stacks on the same named network can use DB_HOST=postgres.
     compose?.addService("postgres", {
         image: "postgres:16",
+        container_name: `samples-${name}-postgres`,
         restart: "unless-stopped",
-        environment: {
-            // biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose reads these from .env
-            POSTGRES_DB: "${POSTGRES_DB}",
-            // biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose reads these from .env
-            POSTGRES_USER: "${POSTGRES_USER}",
-            // biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose reads these from .env
-            POSTGRES_PASSWORD: "${POSTGRES_PASSWORD}"
-        },
+        // Host 5433 avoids clashing with a local/other Postgres on 5432.
         ports: [
-            "5432:5432"
+            "5433:5432"
         ],
         volumes: [
-            "postgres-data:/var/lib/postgresql/data"
-        ]
-    }).addVolume("postgres-data");
+            `${volumeName}:/var/lib/postgresql/data`
+        ],
+        networks: [
+            {
+                [networkKey]: {
+                    aliases: [
+                        "postgres"
+                    ]
+                }
+            }
+        ],
+        healthcheck: {
+            test: [
+                "CMD-SHELL",
+                `pg_isready -U ${user} -d ${db}`
+            ],
+            interval: "2s",
+            timeout: "5s",
+            retries: 15
+        }
+    }).addEnvFile("postgres", "../.env").addVolume(volumeName);
     compose?.addService("adminer", {
         image: "adminer",
         ports: [
-            "8080:8080"
+            "8081:8080"
+        ],
+        networks: [
+            networkKey
         ]
     });
     // Add SQLTools extension for DB browsing in VS Code
@@ -108,8 +142,7 @@ function scaffold(workspace, options) {
         className: "SampleEntityRepository",
         importPath: "./repositories/sample.repository.js"
     });
-    // Add codex + typeorm deps to root package.json
-    workspace.getModel(WELL_KNOWN_FILES.PACKAGE_JSON)?.addDependency("@decohere/codex", CREATE_VERSION).addDependency("typeorm", "^0.3.28").addDependency("@decohere/codex-typeorm", CREATE_VERSION);
+    workspace.getModel(WELL_KNOWN_FILES.PACKAGE_JSON)?.addDependency("@decohere/codex", CREATE_VERSION).addDependency("typeorm", "^0.3.28").addDependency("@decohere/codex-typeorm", CREATE_VERSION).addScript("db:up", "docker compose -f .devcontainer/docker-compose.yml up -d postgres").addScript("db:down", "docker compose -f .devcontainer/docker-compose.yml down").addScript("db:reset", "docker compose -f .devcontainer/docker-compose.yml down -v && docker compose -f .devcontainer/docker-compose.yml up -d postgres");
     // Add codex deps to api package.json
     workspace.getModel(WELL_KNOWN_FILES.API_PACKAGE_JSON)?.addDependency("@decohere/codex", CREATE_VERSION).addDependency("@decohere/codex-typeorm", CREATE_VERSION);
     // Append database config sections
@@ -128,14 +161,13 @@ function scaffold(workspace, options) {
                 }
             ]
     });
-    // .env at workspace root — mounted by compose via ../.env so both postgres
-    // and the devcontainer service can read credentials
-    compose?.addEnvFile("postgres", "../.env").addEnvFile("devcontainer", "../.env");
-    workspace.getModel(WELL_KNOWN_FILES.ENV_FILE)?.addEntry("POSTGRES_DB", db).addEntry("POSTGRES_USER", user).addEntry("POSTGRES_PASSWORD", password).addEntry("DB_HOST", "localhost").addEntry("DB_PORT", "5432").addEntry("DB_NAME", db).addEntry("DB_USER", user).addEntry("DB_PASSWORD", password).addEntry("DB_ADMIN_USER", user).addEntry("DB_ADMIN_PASSWORD", password);
+    // .env at workspace root — postgres reads it via env_file above; devcontainer gets it here
+    compose?.addEnvFile("devcontainer", "../.env");
+    workspace.getModel(WELL_KNOWN_FILES.ENV_FILE)?.addEntry("POSTGRES_DB", db).addEntry("POSTGRES_USER", user).addEntry("POSTGRES_PASSWORD", password).addEntry("DB_HOST", "postgres").addEntry("DB_PORT", "5432").addEntry("DB_NAME", db).addEntry("DB_USER", user).addEntry("DB_PASSWORD", password).addEntry("DB_ADMIN_USER", user).addEntry("DB_ADMIN_PASSWORD", password);
 }
 export const DatabaseFeature = {
     getOptions,
     scaffold
 };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/features/database.feature.ts"],"sourcesContent":["import { randomBytes } from \"node:crypto\";\nimport { pick } from \"../../domain/prompt.js\";\nimport type { DockerCompose } from \"../../models/compose.model.js\";\nimport type { ConfigYaml } from \"../../models/config-yaml.model.js\";\nimport { WELL_KNOWN_FILES } from \"../../models/const.js\";\nimport type { DevContainer } from \"../../models/dev-container.model.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 { CREATE_VERSION } from \"../../version.js\";\nimport { WEBAPI_PROJECT_DIR } from \"../create-api.js\";\nimport type { ApiPackageJson } from \"../models/api-package-json.model.js\";\nimport type { MainSourceFile } from \"../models/main-source-file.model.js\";\n\nexport type DatabaseOptions = {\n\tdatabaseProvider?: \"none\" | \"postgres/typeorm\";\n};\n\n// Base config uses env-var references for production; the dev config section\n// written below overrides only the concrete values needed locally.\nconst DATABASE_BASE_CONFIG_YAML = `database:\n  dataSources:\n    - name: default\n      provider: postgres\n      host: \\${DB_HOST}\n      port: \\${DB_PORT}\n      database: \\${DB_NAME}\n      username: \\${DB_USER}\n      password: \\${DB_PASSWORD}\n      synchronize: false\n      seed: false\n      adminUser: \\${DB_ADMIN_USER}\n      adminPassword: \\${DB_ADMIN_PASSWORD}\n`;\n\n// Dev config only overrides what differs from base — credentials come from .env via env-var references.\nconst DATABASE_DEV_CONFIG_YAML = `database:\n  dataSources:\n    - host: postgres\n      synchronize: true\n      seed: true\n`;\n\nconst SAMPLE_ENTITY_TS = `import { Column, Entity, PrimaryGeneratedColumn } from \"typeorm\";\nimport type { Entity as IEntity } from \"@decohere/codex\";\n\n@Entity()\nexport class SampleEntity implements IEntity {\n\\t@PrimaryGeneratedColumn()\n\\tpublic id!: number;\n\n\\t@Column()\n\\tpublic name!: string;\n}\n`;\n\nconst SAMPLE_REPOSITORY_TS = `import { injectable } from \"@decohere/crucible/decorators\";\nimport { injectUnitOfWork } from \"@decohere/codex\";\nimport { TypeOrmRepository, TypeOrmUnitOfWork } from \"@decohere/codex-typeorm\";\nimport { SampleEntity } from \"../entities/sample.entity.js\";\n\n@injectable()\nexport class SampleEntityRepository extends TypeOrmRepository<SampleEntity> {\n\\tpublic constructor(@injectUnitOfWork() unitOfWork: TypeOrmUnitOfWork) {\n\\t\\tsuper(unitOfWork, SampleEntity);\n\\t}\n}\n`;\n\nasync function getOptions(\n\t_workspace: WorkspaceScaffold,\n\tcliOptions: Partial<DatabaseOptions>,\n): Promise<Partial<DatabaseOptions>> {\n\tif (cliOptions.databaseProvider != null) return {};\n\n\tconst choices = [{ label: \"none\" as const }, { label: \"postgres/typeorm\" as const }];\n\tconst selected = await pick(\"\\n  Database: \", choices, (c) => c.label);\n\treturn { databaseProvider: selected?.label ?? \"none\" };\n}\n\nfunction scaffold(workspace: WorkspaceScaffold, options: DatabaseOptions): void {\n\tif (options.databaseProvider !== \"postgres/typeorm\") return;\n\n\tconst name = workspace.name;\n\tconst password = randomBytes(16).toString(\"hex\");\n\tconst db = `${name}_dev`;\n\tconst user = \"postgres\";\n\n\tconst devContainer = workspace.getModel<DevContainer>(WELL_KNOWN_FILES.DEVCONTAINER_JSON);\n\tconst compose = workspace.getModel<DockerCompose>(WELL_KNOWN_FILES.DOCKER_COMPOSE);\n\n\t// Add postgres service to compose\n\tcompose\n\t\t?.addService(\"postgres\", {\n\t\t\timage: \"postgres:16\",\n\t\t\trestart: \"unless-stopped\",\n\t\t\tenvironment: {\n\t\t\t\t// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose reads these from .env\n\t\t\t\tPOSTGRES_DB: \"${POSTGRES_DB}\",\n\t\t\t\t// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose reads these from .env\n\t\t\t\tPOSTGRES_USER: \"${POSTGRES_USER}\",\n\t\t\t\t// biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose reads these from .env\n\t\t\t\tPOSTGRES_PASSWORD: \"${POSTGRES_PASSWORD}\",\n\t\t\t},\n\t\t\tports: [\"5432:5432\"],\n\t\t\tvolumes: [\"postgres-data:/var/lib/postgresql/data\"],\n\t\t})\n\t\t.addVolume(\"postgres-data\");\n\n\tcompose?.addService(\"adminer\", {\n\t\timage: \"adminer\",\n\t\tports: [\"8080:8080\"],\n\t});\n\n\t// Add SQLTools extension for DB browsing in VS Code\n\tdevContainer?.addExtension(\"mtxr.sqltools\");\n\n\t// Wire up main.ts\n\tworkspace\n\t\t.getModel<MainSourceFile>(WELL_KNOWN_FILES.MAIN_TS)\n\t\t?.addSideEffectImport(\"@decohere/codex-typeorm\")\n\t\t.addEntity({ className: \"SampleEntity\", importPath: \"./entities/sample.entity.js\" })\n\t\t.addRepository({\n\t\t\tclassName: \"SampleEntityRepository\",\n\t\t\timportPath: \"./repositories/sample.repository.js\",\n\t\t});\n\n\t// Add codex + typeorm deps to root package.json\n\tworkspace\n\t\t.getModel<PackageJson>(WELL_KNOWN_FILES.PACKAGE_JSON)\n\t\t?.addDependency(\"@decohere/codex\", CREATE_VERSION)\n\t\t.addDependency(\"typeorm\", \"^0.3.28\")\n\t\t.addDependency(\"@decohere/codex-typeorm\", CREATE_VERSION);\n\n\t// Add codex deps to api package.json\n\tworkspace\n\t\t.getModel<ApiPackageJson>(WELL_KNOWN_FILES.API_PACKAGE_JSON)\n\t\t?.addDependency(\"@decohere/codex\", CREATE_VERSION)\n\t\t.addDependency(\"@decohere/codex-typeorm\", CREATE_VERSION);\n\n\t// Append database config sections\n\tworkspace\n\t\t.getModel<ConfigYaml>(WELL_KNOWN_FILES.CONFIG_YAML)\n\t\t?.addSection(DATABASE_BASE_CONFIG_YAML);\n\tworkspace\n\t\t.getModel<ConfigYaml>(WELL_KNOWN_FILES.CONFIG_DEV_YAML)\n\t\t?.addSection(DATABASE_DEV_CONFIG_YAML);\n\n\t// Register entity and repository source files in the api project\n\tworkspace.getProject(WEBAPI_PROJECT_DIR)?.addFile({\n\t\tfiles: () => [\n\t\t\t{\n\t\t\t\tfilePath: \"src/entities/sample.entity.ts\",\n\t\t\t\tcontent: SAMPLE_ENTITY_TS,\n\t\t\t},\n\t\t\t{\n\t\t\t\tfilePath: \"src/repositories/sample.repository.ts\",\n\t\t\t\tcontent: SAMPLE_REPOSITORY_TS,\n\t\t\t},\n\t\t],\n\t});\n\n\t// .env at workspace root — mounted by compose via ../.env so both postgres\n\t// and the devcontainer service can read credentials\n\tcompose?.addEnvFile(\"postgres\", \"../.env\").addEnvFile(\"devcontainer\", \"../.env\");\n\n\tworkspace\n\t\t.getModel<EnvFile>(WELL_KNOWN_FILES.ENV_FILE)\n\t\t?.addEntry(\"POSTGRES_DB\", db)\n\t\t.addEntry(\"POSTGRES_USER\", user)\n\t\t.addEntry(\"POSTGRES_PASSWORD\", password)\n\t\t.addEntry(\"DB_HOST\", \"localhost\")\n\t\t.addEntry(\"DB_PORT\", \"5432\")\n\t\t.addEntry(\"DB_NAME\", db)\n\t\t.addEntry(\"DB_USER\", user)\n\t\t.addEntry(\"DB_PASSWORD\", password)\n\t\t.addEntry(\"DB_ADMIN_USER\", user)\n\t\t.addEntry(\"DB_ADMIN_PASSWORD\", password);\n}\n\nexport const DatabaseFeature: Feature<DatabaseOptions> = { getOptions, scaffold };\n"],"names":["randomBytes","pick","WELL_KNOWN_FILES","CREATE_VERSION","WEBAPI_PROJECT_DIR","DATABASE_BASE_CONFIG_YAML","DATABASE_DEV_CONFIG_YAML","SAMPLE_ENTITY_TS","SAMPLE_REPOSITORY_TS","getOptions","_workspace","cliOptions","databaseProvider","choices","label","selected","c","scaffold","workspace","options","name","password","toString","db","user","devContainer","getModel","DEVCONTAINER_JSON","compose","DOCKER_COMPOSE","addService","image","restart","environment","POSTGRES_DB","POSTGRES_USER","POSTGRES_PASSWORD","ports","volumes","addVolume","addExtension","MAIN_TS","addSideEffectImport","addEntity","className","importPath","addRepository","PACKAGE_JSON","addDependency","API_PACKAGE_JSON","CONFIG_YAML","addSection","CONFIG_DEV_YAML","getProject","addFile","files","filePath","content","addEnvFile","ENV_FILE","addEntry","DatabaseFeature"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/src/webapi/features/database.feature.ts"],"sourcesContent":["import { randomBytes } from \"node:crypto\";\nimport { readFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { pick } from \"../../domain/prompt.js\";\nimport type { DockerCompose } from \"../../models/compose.model.js\";\nimport type { ConfigYaml } from \"../../models/config-yaml.model.js\";\nimport { WELL_KNOWN_FILES } from \"../../models/const.js\";\nimport type { DevContainer } from \"../../models/dev-container.model.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 { CREATE_VERSION } from \"../../version.js\";\nimport { WEBAPI_PROJECT_DIR } from \"../create-api.js\";\nimport type { ApiPackageJson } from \"../models/api-package-json.model.js\";\nimport type { MainSourceFile } from \"../models/main-source-file.model.js\";\n\nexport type DatabaseOptions = {\n\tdatabaseProvider?: \"none\" | \"postgres/typeorm\";\n};\n\n/** Read a single KEY= from an existing target `.env` (if any). */\nfunction readExistingEnvValue(workspace: WorkspaceScaffold, key: string): string | undefined {\n\ttry {\n\t\tconst raw = readFileSync(join(workspace.targetDir, \".env\"), \"utf8\");\n\t\tconst line = raw.split(\"\\n\").find((l) => l.startsWith(`${key}=`));\n\t\tconst value = line?.slice(key.length + 1).trim();\n\t\treturn value || undefined;\n\t} catch {\n\t\treturn undefined;\n\t}\n}\n\n// Base config uses env-var references for production; the dev config section\n// written below overrides only the concrete values needed locally.\nconst DATABASE_BASE_CONFIG_YAML = `database:\n  dataSources:\n    - name: default\n      provider: postgres\n      host: \\${DB_HOST}\n      port: \\${DB_PORT}\n      database: \\${DB_NAME}\n      username: \\${DB_USER}\n      password: \\${DB_PASSWORD}\n      synchronize: false\n      seed: false\n      adminUser: \\${DB_ADMIN_USER}\n      adminPassword: \\${DB_ADMIN_PASSWORD}\n`;\n\n// Dev config only overrides what differs from base — credentials come from .env via env-var references.\n// Host comes from DB_HOST in .env (postgres on the compose network; 127.0.0.1 from the host).\nconst DATABASE_DEV_CONFIG_YAML = `database:\n  dataSources:\n    - synchronize: true\n      seed: true\n`;\n\nconst SAMPLE_ENTITY_TS = `import { Column, Entity, PrimaryGeneratedColumn } from \"typeorm\";\nimport type { Entity as IEntity } from \"@decohere/codex\";\n\n@Entity()\nexport class SampleEntity implements IEntity {\n\\t@PrimaryGeneratedColumn()\n\\tpublic id!: number;\n\n\\t@Column()\n\\tpublic name!: string;\n}\n`;\n\nconst SAMPLE_REPOSITORY_TS = `import { injectable } from \"@decohere/crucible/decorators\";\nimport { injectUnitOfWork } from \"@decohere/codex\";\nimport { TypeOrmRepository, TypeOrmUnitOfWork } from \"@decohere/codex-typeorm\";\nimport { SampleEntity } from \"../entities/sample.entity.js\";\n\n@injectable()\nexport class SampleEntityRepository extends TypeOrmRepository<SampleEntity> {\n\\tpublic constructor(@injectUnitOfWork() unitOfWork: TypeOrmUnitOfWork) {\n\\t\\tsuper(unitOfWork, SampleEntity);\n\\t}\n}\n`;\n\nasync function getOptions(\n\t_workspace: WorkspaceScaffold,\n\tcliOptions: Partial<DatabaseOptions>,\n): Promise<Partial<DatabaseOptions>> {\n\tif (cliOptions.databaseProvider != null) return {};\n\n\tconst choices = [{ label: \"none\" as const }, { label: \"postgres/typeorm\" as const }];\n\tconst selected = await pick(\"\\n  Database: \", choices, (c) => c.label);\n\treturn { databaseProvider: selected?.label ?? \"none\" };\n}\n\nfunction scaffold(workspace: WorkspaceScaffold, options: DatabaseOptions): void {\n\tif (options.databaseProvider !== \"postgres/typeorm\") return;\n\n\tconst name = workspace.name;\n\t// Prefer an existing POSTGRES_PASSWORD so re-scaffold does not rotate credentials\n\t// out from under an already-initialized Docker volume (Postgres only applies\n\t// POSTGRES_PASSWORD on first data-dir init).\n\tconst existingPassword = readExistingEnvValue(workspace, \"POSTGRES_PASSWORD\");\n\tconst password = existingPassword || randomBytes(16).toString(\"hex\");\n\tconst db = `${name}_dev`;\n\tconst user = \"postgres\";\n\n\tconst devContainer = workspace.getModel<DevContainer>(WELL_KNOWN_FILES.DEVCONTAINER_JSON);\n\tconst compose = workspace.getModel<DockerCompose>(WELL_KNOWN_FILES.DOCKER_COMPOSE);\n\n\tconst networkKey = name;\n\tconst volumeName = `${name}-postgres-data`;\n\n\t// Isolated compose project network + volume (not ark's shared Postgres).\n\t// Alias `postgres` so other stacks on the same named network can use DB_HOST=postgres.\n\tcompose\n\t\t?.addService(\"postgres\", {\n\t\t\timage: \"postgres:16\",\n\t\t\tcontainer_name: `samples-${name}-postgres`,\n\t\t\trestart: \"unless-stopped\",\n\t\t\t// Host 5433 avoids clashing with a local/other Postgres on 5432.\n\t\t\tports: [\"5433:5432\"],\n\t\t\tvolumes: [`${volumeName}:/var/lib/postgresql/data`],\n\t\t\tnetworks: [{ [networkKey]: { aliases: [\"postgres\"] } }],\n\t\t\thealthcheck: {\n\t\t\t\ttest: [\"CMD-SHELL\", `pg_isready -U ${user} -d ${db}`],\n\t\t\t\tinterval: \"2s\",\n\t\t\t\ttimeout: \"5s\",\n\t\t\t\tretries: 15,\n\t\t\t},\n\t\t})\n\t\t.addEnvFile(\"postgres\", \"../.env\")\n\t\t.addVolume(volumeName);\n\n\tcompose?.addService(\"adminer\", {\n\t\timage: \"adminer\",\n\t\tports: [\"8081:8080\"],\n\t\tnetworks: [networkKey],\n\t});\n\n\t// Add SQLTools extension for DB browsing in VS Code\n\tdevContainer?.addExtension(\"mtxr.sqltools\");\n\n\t// Wire up main.ts\n\tworkspace\n\t\t.getModel<MainSourceFile>(WELL_KNOWN_FILES.MAIN_TS)\n\t\t?.addSideEffectImport(\"@decohere/codex-typeorm\")\n\t\t.addEntity({ className: \"SampleEntity\", importPath: \"./entities/sample.entity.js\" })\n\t\t.addRepository({\n\t\t\tclassName: \"SampleEntityRepository\",\n\t\t\timportPath: \"./repositories/sample.repository.js\",\n\t\t});\n\n\tworkspace\n\t\t.getModel<PackageJson>(WELL_KNOWN_FILES.PACKAGE_JSON)\n\t\t?.addDependency(\"@decohere/codex\", CREATE_VERSION)\n\t\t.addDependency(\"typeorm\", \"^0.3.28\")\n\t\t.addDependency(\"@decohere/codex-typeorm\", CREATE_VERSION)\n\t\t.addScript(\"db:up\", \"docker compose -f .devcontainer/docker-compose.yml up -d postgres\")\n\t\t.addScript(\"db:down\", \"docker compose -f .devcontainer/docker-compose.yml down\")\n\t\t.addScript(\n\t\t\t\"db:reset\",\n\t\t\t\"docker compose -f .devcontainer/docker-compose.yml down -v && docker compose -f .devcontainer/docker-compose.yml up -d postgres\",\n\t\t);\n\n\t// Add codex deps to api package.json\n\tworkspace\n\t\t.getModel<ApiPackageJson>(WELL_KNOWN_FILES.API_PACKAGE_JSON)\n\t\t?.addDependency(\"@decohere/codex\", CREATE_VERSION)\n\t\t.addDependency(\"@decohere/codex-typeorm\", CREATE_VERSION);\n\n\t// Append database config sections\n\tworkspace\n\t\t.getModel<ConfigYaml>(WELL_KNOWN_FILES.CONFIG_YAML)\n\t\t?.addSection(DATABASE_BASE_CONFIG_YAML);\n\tworkspace\n\t\t.getModel<ConfigYaml>(WELL_KNOWN_FILES.CONFIG_DEV_YAML)\n\t\t?.addSection(DATABASE_DEV_CONFIG_YAML);\n\n\t// Register entity and repository source files in the api project\n\tworkspace.getProject(WEBAPI_PROJECT_DIR)?.addFile({\n\t\tfiles: () => [\n\t\t\t{\n\t\t\t\tfilePath: \"src/entities/sample.entity.ts\",\n\t\t\t\tcontent: SAMPLE_ENTITY_TS,\n\t\t\t},\n\t\t\t{\n\t\t\t\tfilePath: \"src/repositories/sample.repository.ts\",\n\t\t\t\tcontent: SAMPLE_REPOSITORY_TS,\n\t\t\t},\n\t\t],\n\t});\n\n\t// .env at workspace root — postgres reads it via env_file above; devcontainer gets it here\n\tcompose?.addEnvFile(\"devcontainer\", \"../.env\");\n\n\tworkspace\n\t\t.getModel<EnvFile>(WELL_KNOWN_FILES.ENV_FILE)\n\t\t?.addEntry(\"POSTGRES_DB\", db)\n\t\t.addEntry(\"POSTGRES_USER\", user)\n\t\t.addEntry(\"POSTGRES_PASSWORD\", password)\n\t\t.addEntry(\"DB_HOST\", \"postgres\")\n\t\t.addEntry(\"DB_PORT\", \"5432\")\n\t\t.addEntry(\"DB_NAME\", db)\n\t\t.addEntry(\"DB_USER\", user)\n\t\t.addEntry(\"DB_PASSWORD\", password)\n\t\t.addEntry(\"DB_ADMIN_USER\", user)\n\t\t.addEntry(\"DB_ADMIN_PASSWORD\", password);\n}\n\nexport const DatabaseFeature: Feature<DatabaseOptions> = { getOptions, scaffold };\n"],"names":["randomBytes","readFileSync","join","pick","WELL_KNOWN_FILES","CREATE_VERSION","WEBAPI_PROJECT_DIR","readExistingEnvValue","workspace","key","raw","targetDir","line","split","find","l","startsWith","value","slice","length","trim","undefined","DATABASE_BASE_CONFIG_YAML","DATABASE_DEV_CONFIG_YAML","SAMPLE_ENTITY_TS","SAMPLE_REPOSITORY_TS","getOptions","_workspace","cliOptions","databaseProvider","choices","label","selected","c","scaffold","options","name","existingPassword","password","toString","db","user","devContainer","getModel","DEVCONTAINER_JSON","compose","DOCKER_COMPOSE","networkKey","volumeName","addService","image","container_name","restart","ports","volumes","networks","aliases","healthcheck","test","interval","timeout","retries","addEnvFile","addVolume","addExtension","MAIN_TS","addSideEffectImport","addEntity","className","importPath","addRepository","PACKAGE_JSON","addDependency","addScript","API_PACKAGE_JSON","CONFIG_YAML","addSection","CONFIG_DEV_YAML","getProject","addFile","files","filePath","content","ENV_FILE","addEntry","DatabaseFeature"],"mappings":"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"}