@decohere/scaffold 0.0.1-dev.18 → 0.0.1-dev.81

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

@@ -0,0 +1,433 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DatabaseFeature", {
+    enumerable: true,
+    get: function() {
+        return DatabaseFeature;
+    }
+});
+const _nodecrypto = require("node:crypto");
+const _nodefs = require("node:fs");
+const _nodepath = require("node:path");
+const _prompt = require("../../domain/prompt.js");
+const _const = require("../../models/const.js");
+const _dockerimagemodel = require("../../models/docker-image.model.js");
+const _version = require("../../version.js");
+const _apiname = require("../api-name.js");
+/** Bind path relative to `.devcontainer/docker-compose.yml` (dies with the working tree). */ const POSTGRES_DATA_BIND = "./postgres-data:/var/lib/postgresql/data";
+const POSTGRES_DATA_GITIGNORE = ".devcontainer/postgres-data";
+const DB_RESET_SCRIPT = "rm -rf .devcontainer/postgres-data && docker compose -f .devcontainer/docker-compose.yml down && docker compose -f .devcontainer/docker-compose.yml up -d postgres";
+/** Read a single KEY= from an existing target `.env` (if any). */ function readExistingEnvValue(workspace, key) {
+    try {
+        const raw = (0, _nodefs.readFileSync)((0, _nodepath.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;
+    }
+}
+function randomPassword() {
+    return (0, _nodecrypto.randomBytes)(16).toString("hex");
+}
+/** Safe Postgres identifier fragment from the project name. */ function toSqlIdentFragment(name) {
+    const cleaned = name.replace(/[^A-Za-z0-9_]/g, "_").replace(/^([^A-Za-z_])/, "p_$1");
+    return cleaned.length > 0 ? cleaned.slice(0, 40) : "app";
+}
+function passwordOrExisting(workspace, key, fallbackExistingKeys = []) {
+    const existing = readExistingEnvValue(workspace, key);
+    if (existing) return existing;
+    for (const alt of fallbackExistingKeys){
+        const v = readExistingEnvValue(workspace, alt);
+        if (v) return v;
+    }
+    return randomPassword();
+}
+// Production: runtime app role only — no bootstrap, no admin/migrate secrets required.
+function renderBaseDataSource(apiName) {
+    const p = (0, _apiname.apiEnvPrefix)(apiName);
+    return [
+        `    - name: ${apiName}`,
+        `      provider: postgres`,
+        `      host: \${${p}_DB_HOST}`,
+        `      port: \${${p}_DB_PORT}`,
+        `      database: \${${p}_DB_NAME}`,
+        `      username: \${${p}_DB_USER}`,
+        `      password: \${${p}_DB_PASSWORD}`,
+        `      synchronize: false`,
+        `      seed: false`,
+        `      bootstrap: false`
+    ].join("\n");
+}
+// Dev overlay (merged by list index onto config.yaml). Enable bootstrap + migrate role.
+function renderDevDataSource(apiName) {
+    const p = (0, _apiname.apiEnvPrefix)(apiName);
+    return [
+        `    - name: ${apiName}`,
+        `      synchronize: true`,
+        `      seed: true`,
+        `      bootstrap: true`,
+        `      adminUser: \${DB_ADMIN_USER}`,
+        `      adminPassword: \${DB_ADMIN_PASSWORD}`,
+        `      migrateUsername: \${${p}_DB_MIGRATE_USER}`,
+        `      migratePassword: \${${p}_DB_MIGRATE_PASSWORD}`
+    ].join("\n");
+}
+function renderDatabaseSection(apiNames, items) {
+    return `database:\n  dataSources:\n${apiNames.map(items).join("\n")}\n`;
+}
+/** Create-or-sync bootstrap role; runs on every Postgres container start (not only empty volume). */ const POSTGRES_ENSURE_BOOTSTRAP_SH = `#!/bin/bash
+set -euo pipefail
+# Superuser aligns decohere_bootstrap with DB_ADMIN_* from env_file on every start.
+# Initdb.d alone is insufficient: passwords in .env can change while the volume persists.
+: "\${POSTGRES_USER:?POSTGRES_USER is required}"
+: "\${DB_ADMIN_USER:?DB_ADMIN_USER is required}"
+: "\${DB_ADMIN_PASSWORD:?DB_ADMIN_PASSWORD is required}"
+
+psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname postgres \\
+\t--set=bootstrap_user="$DB_ADMIN_USER" \\
+\t--set=bootstrap_password="$DB_ADMIN_PASSWORD" <<'EOSQL'
+SELECT format(
+\t'CREATE ROLE %I LOGIN PASSWORD %L CREATEDB CREATEROLE NOSUPERUSER NOBYPASSRLS',
+\t:'bootstrap_user',
+\t:'bootstrap_password'
+)
+WHERE NOT EXISTS (
+\tSELECT 1 FROM pg_catalog.pg_roles WHERE rolname = :'bootstrap_user'
+)\\gexec
+
+SELECT format(
+\t'ALTER ROLE %I WITH LOGIN PASSWORD %L CREATEDB CREATEROLE NOSUPERUSER NOBYPASSRLS',
+\t:'bootstrap_user',
+\t:'bootstrap_password'
+)\\gexec
+
+GRANT CONNECT ON DATABASE postgres TO :"bootstrap_user";
+EOSQL
+`;
+const POSTGRES_ENTRYPOINT_SH = `#!/bin/bash
+set -euo pipefail
+(
+\tfor _ in $(seq 1 60); do
+\t\tif pg_isready -U "\${POSTGRES_USER:-postgres}" >/dev/null 2>&1; then
+\t\t\t/usr/local/bin/decohere-ensure-bootstrap.sh
+\t\t\texit 0
+\t\tfi
+\t\tsleep 0.5
+\tdone
+\techo "decohere: timed out waiting for Postgres before ensuring bootstrap role" >&2
+\texit 1
+) &
+exec docker-entrypoint.sh "$@"
+`;
+const POSTGRES_IMAGE_DOCKERFILE = `FROM postgres:16
+COPY ensure-bootstrap-role.sh /usr/local/bin/decohere-ensure-bootstrap.sh
+COPY entrypoint.sh /usr/local/bin/decohere-postgres-entrypoint.sh
+RUN chmod +x /usr/local/bin/decohere-ensure-bootstrap.sh /usr/local/bin/decohere-postgres-entrypoint.sh
+ENTRYPOINT ["/usr/local/bin/decohere-postgres-entrypoint.sh"]
+CMD ["postgres"]
+`;
+const SAMPLE_ENTITY_TS = `import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+import type { Entity as IEntity } from "@decohere/codex";
+
+@Entity()
+export class SampleEntity implements IEntity {
+\t@PrimaryGeneratedColumn()
+\tpublic id!: number;
+
+\t@Column()
+\tpublic name!: string;
+}
+`;
+const SAMPLE_REPOSITORY_TS = `import { injectable } from "@decohere/crucible/decorators";
+import { injectUnitOfWork } from "@decohere/codex";
+import { TypeOrmRepository, TypeOrmUnitOfWork } from "@decohere/codex-typeorm";
+import { SampleEntity } from "../entities/sample.entity.js";
+
+@injectable()
+export class SampleEntityRepository extends TypeOrmRepository<SampleEntity> {
+\tpublic constructor(@injectUnitOfWork() unitOfWork: TypeOrmUnitOfWork) {
+\t\tsuper(unitOfWork, SampleEntity);
+\t}
+}
+`;
+/** TypeORM CLI DataSource — connects as the migrate role; never enables synchronize. */ function renderTypeOrmDataSource(apiName) {
+    const p = (0, _apiname.apiEnvPrefix)(apiName);
+    return `import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { DataSource } from "typeorm";
+
+const root = dirname(fileURLToPath(import.meta.url));
+const required = (key: string): string => {
+\tconst value = process.env[key];
+\tif (value == null || value === "") {
+\t\tthrow new Error(\`Missing env \${key} (load .env via --env-file or export it)\`);
+\t}
+\treturn value;
+};
+
+/**
+ * CLI-only DataSource for \`pnpm db:migrate\` / \`pnpm db:migrate:generate\`.
+ * Uses the migrate role (DDL). Runtime API pods use the app role with synchronize: false.
+ */
+export default new DataSource({
+\ttype: "postgres",
+\thost: required("${p}_DB_HOST"),
+\tport: Number(required("${p}_DB_PORT")),
+\tdatabase: required("${p}_DB_NAME"),
+\tusername: required("${p}_DB_MIGRATE_USER"),
+\tpassword: required("${p}_DB_MIGRATE_PASSWORD"),
+\tsynchronize: false,
+\tentities: [join(root, "entities", "*.{ts,js}")],
+\tmigrations: [join(root, "migrations", "*.{ts,js}")],
+});
+`;
+}
+const DATABASE_DOCS_MD = `# Database (Postgres / TypeORM)
+
+## Roles
+
+| Role | Env | Purpose |
+|---|---|---|
+| App | \`{PREFIX}_DB_USER\` | Runtime API (DML only in production) |
+| Migrate | \`{PREFIX}_DB_MIGRATE_USER\` | Schema changes / TypeORM migrations (CI/deploy) |
+| Bootstrap | \`DB_ADMIN_USER\` | Create DB + roles when \`bootstrap: true\` (dev) |
+
+\`{PREFIX}\` is the API slug in SCREAMING_SNAKE (\`api\` → \`API\`, \`billing\` → \`BILLING\`).
+
+## Development (fast iteration)
+
+\`config/config.dev.yaml\` sets \`synchronize: true\` and \`seed: true\` so the API can create tables on startup. You can keep using sync while prototyping.
+
+Alternatively, turn sync off in the overlay and use migrations the same way as production:
+
+\`\`\`bash
+pnpm db:up
+pnpm db:migrate
+pnpm db:migrate:generate -- ./projects/api/src/migrations/AddSomething
+\`\`\`
+
+Do **not** mix sync and migrations for the same schema change (pick one path per change).
+
+## Production (migrations only)
+
+\`config/config.yaml\` keeps \`synchronize: false\` / \`seed: false\` / \`bootstrap: false\`. Deploy steps:
+
+1. Ensure the app database and roles already exist (provisioner / ops — not the API pod).
+2. Run migrations with the migrate role: \`pnpm db:migrate\` (or \`pnpm db:migrate:<api>\` for multi-API).
+3. Start the API with the app role only — no migrate/admin secrets on the pod.
+
+## Scripts
+
+| Script | What it does |
+|---|---|
+| \`db:up\` / \`db:down\` / \`db:reset\` | Local Compose Postgres |
+| \`db:migrate\` | Run pending migrations (\`projects/api\` by default) |
+| \`db:migrate:generate\` | Generate a migration from entity drift (pass path after \`--\`) |
+| \`db:migrate:<api>\` | Same for a named API under \`projects/<api>\` |
+
+CLI entry: \`projects/<api>/src/typeorm.data-source.ts\` (migrate credentials, \`synchronize: false\`).
+
+## Browse the database
+
+Prefer the Dev Container **SQLTools** extension (Postgres driver) or any desktop client against \`127.0.0.1:5433\` (see \`.env\` for credentials).
+
+Adminer is **not** scaffolded. If you want a browser UI in Compose, add this under \`services:\` in \`.devcontainer/docker-compose.yml\` (profile \`tools\` so it stays off by default):
+
+\`\`\`yaml
+  adminer:
+    image: adminer
+    profiles:
+      - tools
+    ports:
+      - "127.0.0.1:8081:8080"
+    networks:
+      - <compose-network-key> # same key as postgres / devcontainer
+\`\`\`
+
+Then: \`docker compose -f .devcontainer/docker-compose.yml --profile tools up -d adminer\`
+`;
+function typeormCli(args) {
+    return `node --import tsx --env-file=.env ./node_modules/typeorm/cli.js ${args}`;
+}
+function migrateRunScript(apiName) {
+    return typeormCli(`migration:run -d ./projects/${apiName}/src/typeorm.data-source.ts`);
+}
+function migrateGenerateScript(apiName) {
+    return typeormCli(`migration:generate --esm -d ./projects/${apiName}/src/typeorm.data-source.ts`);
+}
+async function getOptions(_workspace, cliOptions) {
+    if (cliOptions.databaseProvider != null) return {};
+    const choices = [
+        {
+            label: "none"
+        },
+        {
+            label: "postgres/typeorm"
+        }
+    ];
+    const selected = await (0, _prompt.pick)("\n  Database: ", choices, (c)=>c.label);
+    return {
+        databaseProvider: selected?.label ?? "none"
+    };
+}
+function scaffold(workspace, options) {
+    if (options.databaseProvider !== "postgres/typeorm") return;
+    const name = workspace.name;
+    const ident = toSqlIdentFragment(name);
+    const apiProjects = workspace.getProjects();
+    const apiNames = apiProjects.map((project)=>(0, _apiname.apiNameFromProjectDir)(project.dir));
+    // Container init superuser — never reused as an API runtime role.
+    const postgresSuperuser = "postgres";
+    const postgresPassword = passwordOrExisting(workspace, "POSTGRES_PASSWORD");
+    const bootstrapUser = "decohere_bootstrap";
+    const bootstrapPassword = passwordOrExisting(workspace, "DB_ADMIN_PASSWORD", [
+        "POSTGRES_PASSWORD"
+    ]);
+    const devContainer = workspace.getModel(_const.WELL_KNOWN_FILES.DEVCONTAINER_JSON);
+    const compose = workspace.getModel(_const.WELL_KNOWN_FILES.DOCKER_COMPOSE);
+    const networkKey = name;
+    if (compose) {
+        // One shared instance. Each API owns a database on it (created at bootstrap).
+        // Point `{PREFIX}_DB_HOST` / `{PREFIX}_DB_PORT` at another server to split later.
+        // Custom image: sync bootstrap role password on every start (initdb.d is once-only).
+        // Default data is a bind mount under the project so `rm -rf` the tree removes it.
+        compose.addHeaderComment("Postgres data defaults to ./postgres-data under this folder (bind mount; dies with the working tree).", `For data that outlives the checkout, replace the postgres volumes entry with a named volume`, `e.g. "${name}-postgres-data:/var/lib/postgresql/data" and declare it under top-level volumes:.`).addService("postgres", {
+            build: "./postgres",
+            container_name: `samples-${name}-postgres`,
+            restart: "unless-stopped",
+            ports: [
+                "127.0.0.1:5433:5432"
+            ],
+            volumes: [
+                POSTGRES_DATA_BIND
+            ],
+            networks: [
+                {
+                    [networkKey]: {
+                        aliases: [
+                            "postgres"
+                        ]
+                    }
+                }
+            ],
+            healthcheck: {
+                // Ensure role/password match .env before reporting healthy.
+                test: [
+                    "CMD-SHELL",
+                    `pg_isready -U ${postgresSuperuser} && /usr/local/bin/decohere-ensure-bootstrap.sh`
+                ],
+                interval: "2s",
+                timeout: "5s",
+                retries: 15
+            }
+        }).addEnvFile("postgres", "../.env");
+        workspace.getModel(_const.WELL_KNOWN_FILES.GITIGNORE)?.add(POSTGRES_DATA_GITIGNORE);
+        workspace.addFile({
+            files: ()=>[
+                    {
+                        filePath: ".devcontainer/postgres/Dockerfile",
+                        content: POSTGRES_IMAGE_DOCKERFILE
+                    },
+                    {
+                        filePath: ".devcontainer/postgres/entrypoint.sh",
+                        content: POSTGRES_ENTRYPOINT_SH
+                    },
+                    {
+                        filePath: ".devcontainer/postgres/ensure-bootstrap-role.sh",
+                        content: POSTGRES_ENSURE_BOOTSTRAP_SH
+                    }
+                ]
+        });
+        compose.addEnvFile("devcontainer", "../.env");
+    }
+    devContainer?.addExtension("mtxr.sqltools", "mtxr.sqltools-driver-pg");
+    workspace.getModel(_const.WELL_KNOWN_FILES.DOCKERFILE)?.addLayer((0, _dockerimagemodel.withPostgresqlClient)());
+    const pkg = workspace.getModel(_const.WELL_KNOWN_FILES.PACKAGE_JSON)?.addDependency("@decohere/codex", _version.CREATE_VERSION).addDependency("typeorm", "^0.3.28").addDependency("@decohere/codex-typeorm", _version.CREATE_VERSION).addDependency("tsx", "^4.20.5").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", DB_RESET_SCRIPT);
+    const primaryApi = apiNames[0];
+    if (pkg != null) {
+        for (const apiName of apiNames){
+            pkg.addScript(`db:migrate:${apiName}`, migrateRunScript(apiName)).addScript(`db:migrate:generate:${apiName}`, migrateGenerateScript(apiName));
+        }
+        // Default aliases target the first API of a new workspace only — never overwrite on `webapi add`.
+        if (!options.add && primaryApi != null) {
+            pkg.addScript("db:migrate", migrateRunScript(primaryApi)).addScript("db:migrate:generate", migrateGenerateScript(primaryApi));
+        }
+    }
+    workspace.addFile({
+        files: ()=>[
+                {
+                    filePath: "docs/database.md",
+                    content: DATABASE_DOCS_MD
+                }
+            ]
+    });
+    writeDatabaseConfig(workspace, apiNames);
+    for (const project of apiProjects){
+        wireApiDatabase(project);
+    }
+    const env = workspace.getModel(_const.WELL_KNOWN_FILES.ENV_FILE);
+    env?.addEntry("POSTGRES_DB", ident).addEntry("POSTGRES_USER", postgresSuperuser).addEntry("POSTGRES_PASSWORD", postgresPassword).addEntry("DB_ADMIN_USER", bootstrapUser).addEntry("DB_ADMIN_PASSWORD", bootstrapPassword);
+    for (const apiName of apiNames){
+        writeApiDatabaseEnv(workspace, ident, apiName);
+    }
+}
+function writeDatabaseConfig(workspace, apiNames) {
+    const config = workspace.getModel(_const.WELL_KNOWN_FILES.CONFIG_YAML);
+    const devConfig = workspace.getModel(_const.WELL_KNOWN_FILES.CONFIG_DEV_YAML);
+    const pending = apiNames.filter((apiName)=>!config?.hasDataSource(apiName));
+    if (pending.length === 0) return;
+    if (config?.hasDataSources()) {
+        for (const apiName of pending){
+            config.appendDataSource(renderBaseDataSource(apiName));
+            devConfig?.appendDataSource(renderDevDataSource(apiName));
+        }
+        return;
+    }
+    config?.addSection(renderDatabaseSection(pending, renderBaseDataSource));
+    devConfig?.addSection(renderDatabaseSection(pending, renderDevDataSource));
+}
+function writeApiDatabaseEnv(workspace, ident, apiName) {
+    const prefix = (0, _apiname.apiEnvPrefix)(apiName);
+    const sqlApi = toSqlIdentFragment(apiName);
+    workspace.getModel(_const.WELL_KNOWN_FILES.ENV_FILE)?.addEntry(`${prefix}_DB_HOST`, "postgres").addEntry(`${prefix}_DB_PORT`, "5432").addEntry(`${prefix}_DB_NAME`, `${ident}_${sqlApi}_dev`).addEntry(`${prefix}_DB_USER`, `${ident}_${sqlApi}_app`).addEntry(`${prefix}_DB_PASSWORD`, passwordOrExisting(workspace, `${prefix}_DB_PASSWORD`)).addEntry(`${prefix}_DB_MIGRATE_USER`, `${ident}_${sqlApi}_migrate`).addEntry(`${prefix}_DB_MIGRATE_PASSWORD`, passwordOrExisting(workspace, `${prefix}_DB_MIGRATE_PASSWORD`));
+}
+function wireApiDatabase(project) {
+    const apiName = (0, _apiname.apiNameFromProjectDir)(project.dir);
+    project.getModel(_const.WELL_KNOWN_FILES.MAIN_TS)?.setDataSourceName(apiName).addSideEffectImport("@decohere/codex-typeorm").addEntity({
+        className: "SampleEntity",
+        importPath: "./entities/sample.entity.js"
+    }).addRepository({
+        className: "SampleEntityRepository",
+        importPath: "./repositories/sample.repository.js"
+    });
+    project.getModel(_const.WELL_KNOWN_FILES.API_PACKAGE_JSON)?.addDependency("@decohere/codex", _version.CREATE_VERSION).addDependency("@decohere/codex-typeorm", _version.CREATE_VERSION);
+    project.addFile({
+        files: ()=>[
+                {
+                    filePath: "src/entities/sample.entity.ts",
+                    content: SAMPLE_ENTITY_TS
+                },
+                {
+                    filePath: "src/repositories/sample.repository.ts",
+                    content: SAMPLE_REPOSITORY_TS
+                },
+                {
+                    filePath: "src/typeorm.data-source.ts",
+                    content: renderTypeOrmDataSource(apiName)
+                },
+                {
+                    filePath: "src/migrations/.gitkeep",
+                    content: ""
+                }
+            ]
+    });
+}
+const DatabaseFeature = {
+    getOptions,
+    scaffold
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/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 {\n\ttype DockerfileModel,\n\twithPostgresqlClient,\n} from \"../../models/docker-image.model.js\";\nimport type { EnvFile } from \"../../models/env-file.model.js\";\nimport type { Gitignore } from \"../../models/gitignore.model.js\";\nimport type { PackageJson } from \"../../models/package-json.model.js\";\nimport type { ProjectScaffold, WorkspaceScaffold } from \"../../models/project.model.js\";\nimport type { Feature } from \"../../services/scaffold.service.js\";\nimport { CREATE_VERSION } from \"../../version.js\";\nimport { apiEnvPrefix, apiNameFromProjectDir } from \"../api-name.js\";\nimport type { ApiPackageJson } from \"../models/api-package-json.model.js\";\nimport type { MainSourceFile } from \"../models/main-source-file.model.js\";\n\n/** Bind path relative to `.devcontainer/docker-compose.yml` (dies with the working tree). */\nconst POSTGRES_DATA_BIND = \"./postgres-data:/var/lib/postgresql/data\";\nconst POSTGRES_DATA_GITIGNORE = \".devcontainer/postgres-data\";\nconst DB_RESET_SCRIPT =\n\t\"rm -rf .devcontainer/postgres-data && docker compose -f .devcontainer/docker-compose.yml down && docker compose -f .devcontainer/docker-compose.yml up -d postgres\";\n\nexport type DatabaseOptions = {\n\tdatabaseProvider?: \"none\" | \"postgres/typeorm\";\n\t/** When true, merge into an existing workspace (\\`webapi add\\`). */\n\tadd?: boolean;\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\nfunction randomPassword(): string {\n\treturn randomBytes(16).toString(\"hex\");\n}\n\n/** Safe Postgres identifier fragment from the project name. */\nfunction toSqlIdentFragment(name: string): string {\n\tconst cleaned = name.replace(/[^A-Za-z0-9_]/g, \"_\").replace(/^([^A-Za-z_])/, \"p_$1\");\n\treturn cleaned.length > 0 ? cleaned.slice(0, 40) : \"app\";\n}\n\nfunction passwordOrExisting(\n\tworkspace: WorkspaceScaffold,\n\tkey: string,\n\tfallbackExistingKeys: string[] = [],\n): string {\n\tconst existing = readExistingEnvValue(workspace, key);\n\tif (existing) return existing;\n\tfor (const alt of fallbackExistingKeys) {\n\t\tconst v = readExistingEnvValue(workspace, alt);\n\t\tif (v) return v;\n\t}\n\treturn randomPassword();\n}\n\n// Production: runtime app role only — no bootstrap, no admin/migrate secrets required.\nfunction renderBaseDataSource(apiName: string): string {\n\tconst p = apiEnvPrefix(apiName);\n\treturn [\n\t\t`    - name: ${apiName}`,\n\t\t`      provider: postgres`,\n\t\t`      host: \\${${p}_DB_HOST}`,\n\t\t`      port: \\${${p}_DB_PORT}`,\n\t\t`      database: \\${${p}_DB_NAME}`,\n\t\t`      username: \\${${p}_DB_USER}`,\n\t\t`      password: \\${${p}_DB_PASSWORD}`,\n\t\t`      synchronize: false`,\n\t\t`      seed: false`,\n\t\t`      bootstrap: false`,\n\t].join(\"\\n\");\n}\n\n// Dev overlay (merged by list index onto config.yaml). Enable bootstrap + migrate role.\nfunction renderDevDataSource(apiName: string): string {\n\tconst p = apiEnvPrefix(apiName);\n\treturn [\n\t\t`    - name: ${apiName}`,\n\t\t`      synchronize: true`,\n\t\t`      seed: true`,\n\t\t`      bootstrap: true`,\n\t\t`      adminUser: \\${DB_ADMIN_USER}`,\n\t\t`      adminPassword: \\${DB_ADMIN_PASSWORD}`,\n\t\t`      migrateUsername: \\${${p}_DB_MIGRATE_USER}`,\n\t\t`      migratePassword: \\${${p}_DB_MIGRATE_PASSWORD}`,\n\t].join(\"\\n\");\n}\n\nfunction renderDatabaseSection(\n\tapiNames: readonly string[],\n\titems: (name: string) => string,\n): string {\n\treturn `database:\\n  dataSources:\\n${apiNames.map(items).join(\"\\n\")}\\n`;\n}\n\n/** Create-or-sync bootstrap role; runs on every Postgres container start (not only empty volume). */\nconst POSTGRES_ENSURE_BOOTSTRAP_SH = `#!/bin/bash\nset -euo pipefail\n# Superuser aligns decohere_bootstrap with DB_ADMIN_* from env_file on every start.\n# Initdb.d alone is insufficient: passwords in .env can change while the volume persists.\n: \"\\${POSTGRES_USER:?POSTGRES_USER is required}\"\n: \"\\${DB_ADMIN_USER:?DB_ADMIN_USER is required}\"\n: \"\\${DB_ADMIN_PASSWORD:?DB_ADMIN_PASSWORD is required}\"\n\npsql -v ON_ERROR_STOP=1 --username \"$POSTGRES_USER\" --dbname postgres \\\\\n\\t--set=bootstrap_user=\"$DB_ADMIN_USER\" \\\\\n\\t--set=bootstrap_password=\"$DB_ADMIN_PASSWORD\" <<'EOSQL'\nSELECT format(\n\\t'CREATE ROLE %I LOGIN PASSWORD %L CREATEDB CREATEROLE NOSUPERUSER NOBYPASSRLS',\n\\t:'bootstrap_user',\n\\t:'bootstrap_password'\n)\nWHERE NOT EXISTS (\n\\tSELECT 1 FROM pg_catalog.pg_roles WHERE rolname = :'bootstrap_user'\n)\\\\gexec\n\nSELECT format(\n\\t'ALTER ROLE %I WITH LOGIN PASSWORD %L CREATEDB CREATEROLE NOSUPERUSER NOBYPASSRLS',\n\\t:'bootstrap_user',\n\\t:'bootstrap_password'\n)\\\\gexec\n\nGRANT CONNECT ON DATABASE postgres TO :\"bootstrap_user\";\nEOSQL\n`;\n\nconst POSTGRES_ENTRYPOINT_SH = `#!/bin/bash\nset -euo pipefail\n(\n\\tfor _ in $(seq 1 60); do\n\\t\\tif pg_isready -U \"\\${POSTGRES_USER:-postgres}\" >/dev/null 2>&1; then\n\\t\\t\\t/usr/local/bin/decohere-ensure-bootstrap.sh\n\\t\\t\\texit 0\n\\t\\tfi\n\\t\\tsleep 0.5\n\\tdone\n\\techo \"decohere: timed out waiting for Postgres before ensuring bootstrap role\" >&2\n\\texit 1\n) &\nexec docker-entrypoint.sh \"$@\"\n`;\n\nconst POSTGRES_IMAGE_DOCKERFILE = `FROM postgres:16\nCOPY ensure-bootstrap-role.sh /usr/local/bin/decohere-ensure-bootstrap.sh\nCOPY entrypoint.sh /usr/local/bin/decohere-postgres-entrypoint.sh\nRUN chmod +x /usr/local/bin/decohere-ensure-bootstrap.sh /usr/local/bin/decohere-postgres-entrypoint.sh\nENTRYPOINT [\"/usr/local/bin/decohere-postgres-entrypoint.sh\"]\nCMD [\"postgres\"]\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\n/** TypeORM CLI DataSource — connects as the migrate role; never enables synchronize. */\nfunction renderTypeOrmDataSource(apiName: string): string {\n\tconst p = apiEnvPrefix(apiName);\n\treturn `import { dirname, join } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { DataSource } from \"typeorm\";\n\nconst root = dirname(fileURLToPath(import.meta.url));\nconst required = (key: string): string => {\n\\tconst value = process.env[key];\n\\tif (value == null || value === \"\") {\n\\t\\tthrow new Error(\\`Missing env \\${key} (load .env via --env-file or export it)\\`);\n\\t}\n\\treturn value;\n};\n\n/**\n * CLI-only DataSource for \\`pnpm db:migrate\\` / \\`pnpm db:migrate:generate\\`.\n * Uses the migrate role (DDL). Runtime API pods use the app role with synchronize: false.\n */\nexport default new DataSource({\n\\ttype: \"postgres\",\n\\thost: required(\"${p}_DB_HOST\"),\n\\tport: Number(required(\"${p}_DB_PORT\")),\n\\tdatabase: required(\"${p}_DB_NAME\"),\n\\tusername: required(\"${p}_DB_MIGRATE_USER\"),\n\\tpassword: required(\"${p}_DB_MIGRATE_PASSWORD\"),\n\\tsynchronize: false,\n\\tentities: [join(root, \"entities\", \"*.{ts,js}\")],\n\\tmigrations: [join(root, \"migrations\", \"*.{ts,js}\")],\n});\n`;\n}\n\nconst DATABASE_DOCS_MD = `# Database (Postgres / TypeORM)\n\n## Roles\n\n| Role | Env | Purpose |\n|---|---|---|\n| App | \\`{PREFIX}_DB_USER\\` | Runtime API (DML only in production) |\n| Migrate | \\`{PREFIX}_DB_MIGRATE_USER\\` | Schema changes / TypeORM migrations (CI/deploy) |\n| Bootstrap | \\`DB_ADMIN_USER\\` | Create DB + roles when \\`bootstrap: true\\` (dev) |\n\n\\`{PREFIX}\\` is the API slug in SCREAMING_SNAKE (\\`api\\` → \\`API\\`, \\`billing\\` → \\`BILLING\\`).\n\n## Development (fast iteration)\n\n\\`config/config.dev.yaml\\` sets \\`synchronize: true\\` and \\`seed: true\\` so the API can create tables on startup. You can keep using sync while prototyping.\n\nAlternatively, turn sync off in the overlay and use migrations the same way as production:\n\n\\`\\`\\`bash\npnpm db:up\npnpm db:migrate\npnpm db:migrate:generate -- ./projects/api/src/migrations/AddSomething\n\\`\\`\\`\n\nDo **not** mix sync and migrations for the same schema change (pick one path per change).\n\n## Production (migrations only)\n\n\\`config/config.yaml\\` keeps \\`synchronize: false\\` / \\`seed: false\\` / \\`bootstrap: false\\`. Deploy steps:\n\n1. Ensure the app database and roles already exist (provisioner / ops — not the API pod).\n2. Run migrations with the migrate role: \\`pnpm db:migrate\\` (or \\`pnpm db:migrate:<api>\\` for multi-API).\n3. Start the API with the app role only — no migrate/admin secrets on the pod.\n\n## Scripts\n\n| Script | What it does |\n|---|---|\n| \\`db:up\\` / \\`db:down\\` / \\`db:reset\\` | Local Compose Postgres |\n| \\`db:migrate\\` | Run pending migrations (\\`projects/api\\` by default) |\n| \\`db:migrate:generate\\` | Generate a migration from entity drift (pass path after \\`--\\`) |\n| \\`db:migrate:<api>\\` | Same for a named API under \\`projects/<api>\\` |\n\nCLI entry: \\`projects/<api>/src/typeorm.data-source.ts\\` (migrate credentials, \\`synchronize: false\\`).\n\n## Browse the database\n\nPrefer the Dev Container **SQLTools** extension (Postgres driver) or any desktop client against \\`127.0.0.1:5433\\` (see \\`.env\\` for credentials).\n\nAdminer is **not** scaffolded. If you want a browser UI in Compose, add this under \\`services:\\` in \\`.devcontainer/docker-compose.yml\\` (profile \\`tools\\` so it stays off by default):\n\n\\`\\`\\`yaml\n  adminer:\n    image: adminer\n    profiles:\n      - tools\n    ports:\n      - \"127.0.0.1:8081:8080\"\n    networks:\n      - <compose-network-key> # same key as postgres / devcontainer\n\\`\\`\\`\n\nThen: \\`docker compose -f .devcontainer/docker-compose.yml --profile tools up -d adminer\\`\n`;\n\nfunction typeormCli(args: string): string {\n\treturn `node --import tsx --env-file=.env ./node_modules/typeorm/cli.js ${args}`;\n}\n\nfunction migrateRunScript(apiName: string): string {\n\treturn typeormCli(`migration:run -d ./projects/${apiName}/src/typeorm.data-source.ts`);\n}\n\nfunction migrateGenerateScript(apiName: string): string {\n\treturn typeormCli(\n\t\t`migration:generate --esm -d ./projects/${apiName}/src/typeorm.data-source.ts`,\n\t);\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 ident = toSqlIdentFragment(name);\n\tconst apiProjects = workspace.getProjects();\n\tconst apiNames = apiProjects.map((project) => apiNameFromProjectDir(project.dir));\n\t// Container init superuser — never reused as an API runtime role.\n\tconst postgresSuperuser = \"postgres\";\n\tconst postgresPassword = passwordOrExisting(workspace, \"POSTGRES_PASSWORD\");\n\tconst bootstrapUser = \"decohere_bootstrap\";\n\tconst bootstrapPassword = passwordOrExisting(workspace, \"DB_ADMIN_PASSWORD\", [\n\t\t\"POSTGRES_PASSWORD\",\n\t]);\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\n\tif (compose) {\n\t\t// One shared instance. Each API owns a database on it (created at bootstrap).\n\t\t// Point `{PREFIX}_DB_HOST` / `{PREFIX}_DB_PORT` at another server to split later.\n\t\t// Custom image: sync bootstrap role password on every start (initdb.d is once-only).\n\t\t// Default data is a bind mount under the project so `rm -rf` the tree removes it.\n\t\tcompose\n\t\t\t.addHeaderComment(\n\t\t\t\t\"Postgres data defaults to ./postgres-data under this folder (bind mount; dies with the working tree).\",\n\t\t\t\t`For data that outlives the checkout, replace the postgres volumes entry with a named volume`,\n\t\t\t\t`e.g. \"${name}-postgres-data:/var/lib/postgresql/data\" and declare it under top-level volumes:.`,\n\t\t\t)\n\t\t\t.addService(\"postgres\", {\n\t\t\t\tbuild: \"./postgres\",\n\t\t\t\tcontainer_name: `samples-${name}-postgres`,\n\t\t\t\trestart: \"unless-stopped\",\n\t\t\t\tports: [\"127.0.0.1:5433:5432\"],\n\t\t\t\tvolumes: [POSTGRES_DATA_BIND],\n\t\t\t\tnetworks: [{ [networkKey]: { aliases: [\"postgres\"] } }],\n\t\t\t\thealthcheck: {\n\t\t\t\t\t// Ensure role/password match .env before reporting healthy.\n\t\t\t\t\ttest: [\n\t\t\t\t\t\t\"CMD-SHELL\",\n\t\t\t\t\t\t`pg_isready -U ${postgresSuperuser} && /usr/local/bin/decohere-ensure-bootstrap.sh`,\n\t\t\t\t\t],\n\t\t\t\t\tinterval: \"2s\",\n\t\t\t\t\ttimeout: \"5s\",\n\t\t\t\t\tretries: 15,\n\t\t\t\t},\n\t\t\t})\n\t\t\t.addEnvFile(\"postgres\", \"../.env\");\n\n\t\tworkspace.getModel<Gitignore>(WELL_KNOWN_FILES.GITIGNORE)?.add(POSTGRES_DATA_GITIGNORE);\n\n\t\tworkspace.addFile({\n\t\t\tfiles: () => [\n\t\t\t\t{\n\t\t\t\t\tfilePath: \".devcontainer/postgres/Dockerfile\",\n\t\t\t\t\tcontent: POSTGRES_IMAGE_DOCKERFILE,\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\tfilePath: \".devcontainer/postgres/entrypoint.sh\",\n\t\t\t\t\tcontent: POSTGRES_ENTRYPOINT_SH,\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\tfilePath: \".devcontainer/postgres/ensure-bootstrap-role.sh\",\n\t\t\t\t\tcontent: POSTGRES_ENSURE_BOOTSTRAP_SH,\n\t\t\t\t},\n\t\t\t],\n\t\t});\n\n\t\tcompose.addEnvFile(\"devcontainer\", \"../.env\");\n\t}\n\n\tdevContainer?.addExtension(\"mtxr.sqltools\", \"mtxr.sqltools-driver-pg\");\n\tworkspace\n\t\t.getModel<DockerfileModel>(WELL_KNOWN_FILES.DOCKERFILE)\n\t\t?.addLayer(withPostgresqlClient());\n\n\tconst pkg = workspace\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.addDependency(\"tsx\", \"^4.20.5\")\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(\"db:reset\", DB_RESET_SCRIPT);\n\n\tconst primaryApi = apiNames[0];\n\tif (pkg != null) {\n\t\tfor (const apiName of apiNames) {\n\t\t\tpkg\n\t\t\t\t.addScript(`db:migrate:${apiName}`, migrateRunScript(apiName))\n\t\t\t\t.addScript(`db:migrate:generate:${apiName}`, migrateGenerateScript(apiName));\n\t\t}\n\t\t// Default aliases target the first API of a new workspace only — never overwrite on `webapi add`.\n\t\tif (!options.add && primaryApi != null) {\n\t\t\tpkg\n\t\t\t\t.addScript(\"db:migrate\", migrateRunScript(primaryApi))\n\t\t\t\t.addScript(\"db:migrate:generate\", migrateGenerateScript(primaryApi));\n\t\t}\n\t}\n\n\tworkspace.addFile({\n\t\tfiles: () => [\n\t\t\t{\n\t\t\t\tfilePath: \"docs/database.md\",\n\t\t\t\tcontent: DATABASE_DOCS_MD,\n\t\t\t},\n\t\t],\n\t});\n\n\twriteDatabaseConfig(workspace, apiNames);\n\n\tfor (const project of apiProjects) {\n\t\twireApiDatabase(project);\n\t}\n\n\tconst env = workspace.getModel<EnvFile>(WELL_KNOWN_FILES.ENV_FILE);\n\tenv\n\t\t?.addEntry(\"POSTGRES_DB\", ident)\n\t\t.addEntry(\"POSTGRES_USER\", postgresSuperuser)\n\t\t.addEntry(\"POSTGRES_PASSWORD\", postgresPassword)\n\t\t.addEntry(\"DB_ADMIN_USER\", bootstrapUser)\n\t\t.addEntry(\"DB_ADMIN_PASSWORD\", bootstrapPassword);\n\n\tfor (const apiName of apiNames) {\n\t\twriteApiDatabaseEnv(workspace, ident, apiName);\n\t}\n}\n\nfunction writeDatabaseConfig(workspace: WorkspaceScaffold, apiNames: readonly string[]): void {\n\tconst config = workspace.getModel<ConfigYaml>(WELL_KNOWN_FILES.CONFIG_YAML);\n\tconst devConfig = workspace.getModel<ConfigYaml>(WELL_KNOWN_FILES.CONFIG_DEV_YAML);\n\tconst pending = apiNames.filter((apiName) => !config?.hasDataSource(apiName));\n\tif (pending.length === 0) return;\n\n\tif (config?.hasDataSources()) {\n\t\tfor (const apiName of pending) {\n\t\t\tconfig.appendDataSource(renderBaseDataSource(apiName));\n\t\t\tdevConfig?.appendDataSource(renderDevDataSource(apiName));\n\t\t}\n\t\treturn;\n\t}\n\n\tconfig?.addSection(renderDatabaseSection(pending, renderBaseDataSource));\n\tdevConfig?.addSection(renderDatabaseSection(pending, renderDevDataSource));\n}\n\nfunction writeApiDatabaseEnv(\n\tworkspace: WorkspaceScaffold,\n\tident: string,\n\tapiName: string,\n): void {\n\tconst prefix = apiEnvPrefix(apiName);\n\tconst sqlApi = toSqlIdentFragment(apiName);\n\tworkspace\n\t\t.getModel<EnvFile>(WELL_KNOWN_FILES.ENV_FILE)\n\t\t?.addEntry(`${prefix}_DB_HOST`, \"postgres\")\n\t\t.addEntry(`${prefix}_DB_PORT`, \"5432\")\n\t\t.addEntry(`${prefix}_DB_NAME`, `${ident}_${sqlApi}_dev`)\n\t\t.addEntry(`${prefix}_DB_USER`, `${ident}_${sqlApi}_app`)\n\t\t.addEntry(`${prefix}_DB_PASSWORD`, passwordOrExisting(workspace, `${prefix}_DB_PASSWORD`))\n\t\t.addEntry(`${prefix}_DB_MIGRATE_USER`, `${ident}_${sqlApi}_migrate`)\n\t\t.addEntry(\n\t\t\t`${prefix}_DB_MIGRATE_PASSWORD`,\n\t\t\tpasswordOrExisting(workspace, `${prefix}_DB_MIGRATE_PASSWORD`),\n\t\t);\n}\n\nfunction wireApiDatabase(project: ProjectScaffold): void {\n\tconst apiName = apiNameFromProjectDir(project.dir);\n\tproject\n\t\t.getModel<MainSourceFile>(WELL_KNOWN_FILES.MAIN_TS)\n\t\t?.setDataSourceName(apiName)\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\tproject\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\tproject.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\t{\n\t\t\t\tfilePath: \"src/typeorm.data-source.ts\",\n\t\t\t\tcontent: renderTypeOrmDataSource(apiName),\n\t\t\t},\n\t\t\t{\n\t\t\t\tfilePath: \"src/migrations/.gitkeep\",\n\t\t\t\tcontent: \"\",\n\t\t\t},\n\t\t],\n\t});\n}\n\nexport const DatabaseFeature: Feature<DatabaseOptions> = { getOptions, scaffold };\n"],"names":["DatabaseFeature","POSTGRES_DATA_BIND","POSTGRES_DATA_GITIGNORE","DB_RESET_SCRIPT","readExistingEnvValue","workspace","key","raw","readFileSync","join","targetDir","line","split","find","l","startsWith","value","slice","length","trim","undefined","randomPassword","randomBytes","toString","toSqlIdentFragment","name","cleaned","replace","passwordOrExisting","fallbackExistingKeys","existing","alt","v","renderBaseDataSource","apiName","p","apiEnvPrefix","renderDevDataSource","renderDatabaseSection","apiNames","items","map","POSTGRES_ENSURE_BOOTSTRAP_SH","POSTGRES_ENTRYPOINT_SH","POSTGRES_IMAGE_DOCKERFILE","SAMPLE_ENTITY_TS","SAMPLE_REPOSITORY_TS","renderTypeOrmDataSource","DATABASE_DOCS_MD","typeormCli","args","migrateRunScript","migrateGenerateScript","getOptions","_workspace","cliOptions","databaseProvider","choices","label","selected","pick","c","scaffold","options","ident","apiProjects","getProjects","project","apiNameFromProjectDir","dir","postgresSuperuser","postgresPassword","bootstrapUser","bootstrapPassword","devContainer","getModel","WELL_KNOWN_FILES","DEVCONTAINER_JSON","compose","DOCKER_COMPOSE","networkKey","addHeaderComment","addService","build","container_name","restart","ports","volumes","networks","aliases","healthcheck","test","interval","timeout","retries","addEnvFile","GITIGNORE","add","addFile","files","filePath","content","addExtension","DOCKERFILE","addLayer","withPostgresqlClient","pkg","PACKAGE_JSON","addDependency","CREATE_VERSION","addScript","primaryApi","writeDatabaseConfig","wireApiDatabase","env","ENV_FILE","addEntry","writeApiDatabaseEnv","config","CONFIG_YAML","devConfig","CONFIG_DEV_YAML","pending","filter","hasDataSource","hasDataSources","appendDataSource","addSection","prefix","sqlApi","MAIN_TS","setDataSourceName","addSideEffectImport","addEntity","className","importPath","addRepository","API_PACKAGE_JSON"],"mappings":"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"}

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FinalizeFeature", {
+    enumerable: true,
+    get: function() {
+        return FinalizeFeature;
+    }
+});
+const _nodefs = require("node:fs");
+const _nodepath = require("node:path");
+const _interop = require("@decohere/nexus/interop");
+const _prompt = require("../../domain/prompt.js");
+const _const = require("../../models/const.js");
+const _workspacereadme = require("../workspace-readme.js");
+const _biomeformat = require("./biome-format.js");
+function readExistingEnvValue(workspace, key) {
+    try {
+        const raw = (0, _nodefs.readFileSync)((0, _nodepath.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;
+    }
+}
+// State resolved during scaffold(), consumed by finalize().
+let _pm = null;
+let _shouldInstall = true;
+async function getOptions(_workspace, cliOptions) {
+    if (cliOptions.installDependencies != null) {
+        _shouldInstall = cliOptions.installDependencies === "yes";
+    }
+    return {};
+}
+async function scaffold(workspace, options) {
+    // Local scaffold default — production deploys must set NODE_ENV explicitly.
+    const nodeEnv = readExistingEnvValue(workspace, "NODE_ENV") ?? "dev";
+    workspace.getModel(_const.WELL_KNOWN_FILES.ENV_FILE)?.addEntry("NODE_ENV", nodeEnv);
+    // Durable day-2 CLI examples (also refreshed on `webapi add`).
+    (0, _workspacereadme.writeWorkspaceReadme)(workspace, options);
+    if (process.env.DECOHERE_BUILDER === "1") {
+        _shouldInstall = false;
+        return;
+    }
+    _pm = (0, _interop.detectPackageManager)(workspace.targetDir) ?? await (0, _interop.promptForPackageManager)();
+    if (options.installDependencies != null) {
+        _shouldInstall = options.installDependencies === "yes";
+        return;
+    }
+    const answer = await (0, _prompt.ask)("\nInstall dependencies now? [yes/no] (yes): ", "yes");
+    _shouldInstall = answer.toLowerCase() !== "no";
+}
+async function finalize(workspace, options) {
+    const formatPaths = options.add ? workspace.getProjects().map((project)=>project.dir) : [
+        "."
+    ];
+    (0, _biomeformat.formatScaffoldedFiles)(workspace.targetDir, formatPaths.length > 0 ? formatPaths : [
+        "."
+    ]);
+    if (_shouldInstall) {
+        const pm = _pm;
+        console.log(`\nScaffolded ${workspace.name}. Installing dependencies...\n`);
+        await pm.install({
+            cwd: workspace.targetDir
+        });
+    }
+    const apiNames = workspace.getProjects().map((project)=>project.dir.replace(/^projects\//, ""));
+    console.log(`\nDone! ${_shouldInstall ? "Next" : "To get started:"} steps:\n`);
+    if (!options.add) {
+        console.log(`  cd ${workspace.name}`);
+    }
+    if (!_shouldInstall && options.add) {
+        const pmName = _pm?.name ?? "pnpm";
+        console.log(`  ${pmName} install`);
+    }
+    if (options.add && apiNames[0] != null) {
+        console.log(`  pnpm run start:${apiNames[0]}`);
+        console.log(`  docker build -f Dockerfile.${apiNames[0]} .`);
+    } else {
+        console.log("  code .         # open in VS Code");
+        console.log("                 # then: Reopen in Container (first create runs pnpm install)\n");
+    }
+    console.log("  See README.md for CLI examples.\n");
+    // Drop readline's stdin hold so the CLI / container can exit.
+    (0, _prompt.closePrompt)();
+}
+const FinalizeFeature = {
+    getOptions,
+    scaffold,
+    finalize
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/webapi/features/finalize.feature.ts"],"sourcesContent":["import { readFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport type { PackageManager } from \"@decohere/nexus/interop\";\nimport { detectPackageManager, promptForPackageManager } from \"@decohere/nexus/interop\";\nimport { ask, closePrompt } from \"../../domain/prompt.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 { writeWorkspaceReadme } from \"../workspace-readme.js\";\nimport { formatScaffoldedFiles } from \"./biome-format.js\";\n\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// State resolved during scaffold(), consumed by finalize().\nlet _pm: PackageManager | null = null;\nlet _shouldInstall = true;\n\ntype FinalizeOptions = {\n\tinstallDependencies?: \"yes\" | \"no\";\n\tadd?: boolean;\n\tdatabaseProvider?: \"none\" | \"postgres/typeorm\";\n\tauthProvider?: \"auth0\" | \"none\";\n\tpostmanProvider?: \"api\" | \"local\" | \"none\";\n};\n\nasync function getOptions(\n\t_workspace: WorkspaceScaffold,\n\tcliOptions: Partial<FinalizeOptions>,\n): Promise<object> {\n\tif (cliOptions.installDependencies != null) {\n\t\t_shouldInstall = cliOptions.installDependencies === \"yes\";\n\t}\n\treturn {};\n}\n\nasync function scaffold(\n\tworkspace: WorkspaceScaffold,\n\toptions: FinalizeOptions,\n): Promise<void> {\n\t// Local scaffold default — production deploys must set NODE_ENV explicitly.\n\tconst nodeEnv = readExistingEnvValue(workspace, \"NODE_ENV\") ?? \"dev\";\n\tworkspace.getModel<EnvFile>(WELL_KNOWN_FILES.ENV_FILE)?.addEntry(\"NODE_ENV\", nodeEnv);\n\n\t// Durable day-2 CLI examples (also refreshed on `webapi add`).\n\twriteWorkspaceReadme(workspace, options);\n\n\tif (process.env.DECOHERE_BUILDER === \"1\") {\n\t\t_shouldInstall = false;\n\t\treturn;\n\t}\n\t_pm = detectPackageManager(workspace.targetDir) ?? (await promptForPackageManager());\n\tif (options.installDependencies != null) {\n\t\t_shouldInstall = options.installDependencies === \"yes\";\n\t\treturn;\n\t}\n\n\tconst answer = await ask(\"\\nInstall dependencies now? [yes/no] (yes): \", \"yes\");\n\t_shouldInstall = answer.toLowerCase() !== \"no\";\n}\n\nasync function finalize(\n\tworkspace: WorkspaceScaffold,\n\toptions: FinalizeOptions,\n): Promise<void> {\n\tconst formatPaths = options.add\n\t\t? workspace.getProjects().map((project) => project.dir)\n\t\t: [\".\"];\n\tformatScaffoldedFiles(workspace.targetDir, formatPaths.length > 0 ? formatPaths : [\".\"]);\n\n\tif (_shouldInstall) {\n\t\tconst pm = _pm!;\n\t\tconsole.log(`\\nScaffolded ${workspace.name}. Installing dependencies...\\n`);\n\t\tawait pm.install({ cwd: workspace.targetDir });\n\t}\n\n\tconst apiNames = workspace\n\t\t.getProjects()\n\t\t.map((project) => project.dir.replace(/^projects\\//, \"\"));\n\tconsole.log(`\\nDone! ${_shouldInstall ? \"Next\" : \"To get started:\"} steps:\\n`);\n\tif (!options.add) {\n\t\tconsole.log(`  cd ${workspace.name}`);\n\t}\n\tif (!_shouldInstall && options.add) {\n\t\tconst pmName = _pm?.name ?? \"pnpm\";\n\t\tconsole.log(`  ${pmName} install`);\n\t}\n\tif (options.add && apiNames[0] != null) {\n\t\tconsole.log(`  pnpm run start:${apiNames[0]}`);\n\t\tconsole.log(`  docker build -f Dockerfile.${apiNames[0]} .`);\n\t} else {\n\t\tconsole.log(\"  code .         # open in VS Code\");\n\t\tconsole.log(\n\t\t\t\"                 # then: Reopen in Container (first create runs pnpm install)\\n\",\n\t\t);\n\t}\n\tconsole.log(\"  See README.md for CLI examples.\\n\");\n\n\t// Drop readline's stdin hold so the CLI / container can exit.\n\tclosePrompt();\n}\n\nexport const FinalizeFeature: Feature = { getOptions, scaffold, finalize };\n"],"names":["FinalizeFeature","readExistingEnvValue","workspace","key","raw","readFileSync","join","targetDir","line","split","find","l","startsWith","value","slice","length","trim","undefined","_pm","_shouldInstall","getOptions","_workspace","cliOptions","installDependencies","scaffold","options","nodeEnv","getModel","WELL_KNOWN_FILES","ENV_FILE","addEntry","writeWorkspaceReadme","process","env","DECOHERE_BUILDER","detectPackageManager","promptForPackageManager","answer","ask","toLowerCase","finalize","formatPaths","add","getProjects","map","project","dir","formatScaffoldedFiles","pm","console","log","name","install","cwd","apiNames","replace","pmName","closePrompt"],"mappings":"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"}