@stardeck-customer-apps/data-store-sdk 0.5.0 → 0.6.0

package/dist/cli/bin.js

@@ -0,0 +1,729 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/generate-types.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_util = require("util");
+var import_serverless = require("@neondatabase/serverless");
+
+// src/server/manifest.ts
+var STARDECK_DATA_STORES_ENV = "STARDECK_DATA_STORES";
+function readEnv(key) {
+  if (typeof process !== "undefined" && process.env?.[key]) {
+    return process.env[key];
+  }
+  return void 0;
+}
+function dataStoreSlug(name) {
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return slug || "store";
+}
+function readDataStoreManifest() {
+  const raw = readEnv(STARDECK_DATA_STORES_ENV);
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((e) => {
+      if (typeof e !== "object" || e === null) return false;
+      const entry = e;
+      if (typeof entry.id !== "string" || typeof entry.name !== "string" || typeof entry.slug !== "string") {
+        return false;
+      }
+      return entry.storeType === "storage" || typeof entry.url === "string";
+    });
+  } catch {
+    return [];
+  }
+}
+function resolveDataStore(ref) {
+  return resolveManifestEntry(readDataStoreManifest(), ref);
+}
+function resolveManifestEntry(entries, ref) {
+  if (ref.storeId) {
+    const byId = entries.find((e) => e.id === ref.storeId);
+    if (byId) return byId;
+  }
+  if (ref.storeName) {
+    const target = ref.storeName;
+    const byBindingKey = entries.find((e) => e.bindingKey === target);
+    if (byBindingKey) return byBindingKey;
+    const exact = entries.find((e) => e.slug === target || e.id === target || e.name === target);
+    if (exact) return exact;
+    const norm = dataStoreSlug(target);
+    const byBindingKeyNorm = entries.find((e) => e.bindingKey === norm);
+    if (byBindingKeyNorm) return byBindingKeyNorm;
+    return entries.find(
+      (e) => e.slug === norm || typeof e.name === "string" && dataStoreSlug(e.name) === norm
+    );
+  }
+  return void 0;
+}
+
+// src/cli/module-type-slices.ts
+var import_fs = require("fs");
+var import_path = require("path");
+function toPascalCase(name) {
+  return name.split(/[_-]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function parseModuleManifestSlice(content, sourceLabel, warn) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    warn(`Skipping malformed module manifest at ${sourceLabel}`);
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    warn(`Skipping malformed module manifest at ${sourceLabel}`);
+    return null;
+  }
+  const record = parsed;
+  const name = record.name;
+  const tables = record.tables;
+  if (typeof name !== "string" || name.length === 0) {
+    warn(`Skipping module manifest at ${sourceLabel}: missing or invalid "name"`);
+    return null;
+  }
+  if (!Array.isArray(tables) || tables.length === 0) {
+    return null;
+  }
+  const tableNames = [];
+  for (const entry of tables) {
+    if (typeof entry !== "string" || entry.length === 0) {
+      warn(`Skipping module manifest at ${sourceLabel}: invalid "tables" entry`);
+      return null;
+    }
+    tableNames.push(entry);
+  }
+  return { name, tables: tableNames };
+}
+function discoverModuleManifests(modulesDir, warn) {
+  if (!(0, import_fs.existsSync)(modulesDir)) {
+    return [];
+  }
+  let entries;
+  try {
+    entries = (0, import_fs.readdirSync)(modulesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    warn(`Could not read modules directory: ${modulesDir}`);
+    return [];
+  }
+  const manifests = [];
+  for (const dirName of entries) {
+    const manifestPath = (0, import_path.join)(modulesDir, dirName, "module.json");
+    if (!(0, import_fs.existsSync)(manifestPath)) {
+      continue;
+    }
+    let content;
+    try {
+      content = (0, import_fs.readFileSync)(manifestPath, "utf-8");
+    } catch {
+      warn(`Skipping unreadable module manifest at ${manifestPath}`);
+      continue;
+    }
+    const slice = parseModuleManifestSlice(content, manifestPath, warn);
+    if (slice) {
+      manifests.push(slice);
+    }
+  }
+  return manifests.sort((a, b) => a.name.localeCompare(b.name));
+}
+function shouldLoadModuleManifests(noModules) {
+  return !noModules;
+}
+function emitModuleDbSlices(schemaTableNames, manifests, warn) {
+  const lines = [];
+  const moduleMapEntries = [];
+  for (const manifest of manifests) {
+    const presentTables = manifest.tables.filter((t) => schemaTableNames.has(t));
+    const absentTables = manifest.tables.filter((t) => !schemaTableNames.has(t));
+    if (absentTables.length > 0) {
+      warn(`Module "${manifest.name}": table(s) not in database: ${absentTables.join(", ")}`);
+    }
+    if (presentTables.length === 0) {
+      continue;
+    }
+    const interfaceName = `${toPascalCase(manifest.name)}ModuleDB`;
+    lines.push(`export interface ${interfaceName} {`);
+    for (const tableName of presentTables) {
+      const tableTypeName = `${toPascalCase(tableName)}Table`;
+      lines.push(`  ${tableName}: ${tableTypeName};`);
+    }
+    lines.push("}");
+    lines.push("");
+    moduleMapEntries.push({ name: manifest.name, interfaceName });
+  }
+  if (moduleMapEntries.length === 0) {
+    return "";
+  }
+  lines.push("export interface ModuleDBs {");
+  for (const { name, interfaceName } of moduleMapEntries) {
+    lines.push(`  "${name}": ${interfaceName};`);
+  }
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/cli/schema-ddl.ts
+function quoteIdent(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+var TRACKED_EXTENSIONS = /* @__PURE__ */ new Set(["pgcrypto", "pg_trgm", "uuid-ossp", "citext"]);
+function resolveSqlType(row) {
+  const dataType = row.data_type;
+  if (dataType === "ARRAY") {
+    return `${row.udt_name.replace(/^_/, "")}[]`;
+  }
+  if (dataType === "USER-DEFINED") {
+    return quoteIdent(row.udt_name);
+  }
+  if (dataType === "character varying") {
+    return row.character_maximum_length ? `varchar(${row.character_maximum_length})` : "varchar";
+  }
+  if (dataType === "character") {
+    return row.character_maximum_length ? `char(${row.character_maximum_length})` : "char";
+  }
+  if (dataType === "numeric") {
+    return row.numeric_precision !== null && row.numeric_scale !== null ? `numeric(${row.numeric_precision},${row.numeric_scale})` : "numeric";
+  }
+  if (dataType === "timestamp with time zone") return "timestamptz";
+  if (dataType === "timestamp without time zone") return "timestamp";
+  if (dataType === "time with time zone") return "timetz";
+  if (dataType === "time without time zone") return "time";
+  return dataType;
+}
+async function introspectSchemaSnapshot(executor) {
+  const [extensions, enums, columns, constraints, fks, checks, indexes] = await Promise.all([
+    executor.query(`SELECT extname FROM pg_extension ORDER BY extname`),
+    executor.query(
+      `SELECT t.typname AS name, e.enumlabel AS value
+       FROM pg_type t
+       JOIN pg_enum e ON e.enumtypid = t.oid
+       JOIN pg_namespace n ON n.oid = t.typnamespace
+       WHERE n.nspname = 'public'
+       ORDER BY t.typname, e.enumsortorder`
+    ),
+    executor.query(
+      `SELECT c.table_name, c.column_name, c.data_type, c.udt_name, c.is_nullable,
+              c.column_default, c.character_maximum_length, c.numeric_precision, c.numeric_scale,
+              c.is_generated, c.generation_expression
+       FROM information_schema.columns c
+       JOIN information_schema.tables t
+         ON c.table_name = t.table_name AND c.table_schema = t.table_schema
+       WHERE c.table_schema = 'public'
+         AND t.table_type = 'BASE TABLE'
+         AND t.table_name NOT LIKE '\\_deleted\\_%'
+       ORDER BY c.table_name, c.ordinal_position`
+    ),
+    executor.query(
+      `SELECT tc.table_name, tc.constraint_name, tc.constraint_type, ku.column_name
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.key_column_usage ku
+         ON tc.constraint_name = ku.constraint_name AND tc.table_schema = ku.table_schema
+       WHERE tc.table_schema = 'public'
+         AND tc.constraint_type IN ('PRIMARY KEY', 'UNIQUE')
+       ORDER BY tc.table_name, tc.constraint_name, ku.ordinal_position`
+    ),
+    executor.query(
+      // Read column pairings from pg_catalog: information_schema's
+      // constraint_column_usage is uncorrelated with key_column_usage, so
+      // joining them for a composite FK produces a cross product. Unnesting
+      // conkey/confkey together WITH ORDINALITY keeps referencing↔referenced
+      // columns paired and ordered.
+      `SELECT con.conname AS constraint_name,
+              rel.relname AS table_name,
+              att.attname AS column_name,
+              frel.relname AS referenced_table,
+              fatt.attname AS referenced_column,
+              CASE con.confdeltype WHEN 'a' THEN 'NO ACTION' WHEN 'r' THEN 'RESTRICT'
+                WHEN 'c' THEN 'CASCADE' WHEN 'n' THEN 'SET NULL' WHEN 'd' THEN 'SET DEFAULT' END AS delete_rule,
+              CASE con.confupdtype WHEN 'a' THEN 'NO ACTION' WHEN 'r' THEN 'RESTRICT'
+                WHEN 'c' THEN 'CASCADE' WHEN 'n' THEN 'SET NULL' WHEN 'd' THEN 'SET DEFAULT' END AS update_rule
+       FROM pg_constraint con
+       JOIN pg_class rel ON rel.oid = con.conrelid
+       JOIN pg_namespace ns ON ns.oid = rel.relnamespace
+       JOIN pg_class frel ON frel.oid = con.confrelid
+       JOIN LATERAL unnest(con.conkey, con.confkey) WITH ORDINALITY AS cols(conkey, confkey, ord) ON true
+       JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = cols.conkey
+       JOIN pg_attribute fatt ON fatt.attrelid = con.confrelid AND fatt.attnum = cols.confkey
+       WHERE ns.nspname = 'public' AND con.contype = 'f'
+       ORDER BY rel.relname, con.conname, cols.ord`
+    ),
+    executor.query(
+      `SELECT rel.relname AS table_name, con.conname AS name,
+              pg_get_constraintdef(con.oid) AS definition
+       FROM pg_constraint con
+       JOIN pg_class rel ON rel.oid = con.conrelid
+       JOIN pg_namespace ns ON ns.oid = rel.relnamespace
+       WHERE ns.nspname = 'public' AND con.contype = 'c'
+         AND rel.relname NOT LIKE '\\_deleted\\_%'
+       ORDER BY rel.relname, con.conname`
+    ),
+    executor.query(
+      `SELECT i.indexdef
+       FROM pg_indexes i
+       WHERE i.schemaname = 'public'
+         AND i.tablename NOT LIKE '\\_deleted\\_%'
+         AND NOT EXISTS (
+           SELECT 1 FROM pg_constraint c
+           JOIN pg_class cls ON cls.oid = c.conindid
+           WHERE cls.relname = i.indexname
+         )
+       ORDER BY i.indexname`
+    )
+  ]);
+  const enumMap = /* @__PURE__ */ new Map();
+  for (const row of enums.rows) {
+    const name = String(row.name);
+    if (!enumMap.has(name)) enumMap.set(name, []);
+    enumMap.get(name).push(String(row.value));
+  }
+  const tableMap = /* @__PURE__ */ new Map();
+  for (const row of columns.rows) {
+    const tableName = String(row.table_name);
+    if (!tableMap.has(tableName)) {
+      tableMap.set(tableName, { name: tableName, columns: [], primaryKey: [], uniques: [] });
+    }
+    const defaultExpr = row.column_default === null ? null : String(row.column_default);
+    const isSerial = defaultExpr !== null && /^nextval\(/.test(defaultExpr);
+    const isGenerated = row.is_generated === "ALWAYS";
+    tableMap.get(tableName).columns.push({
+      name: String(row.column_name),
+      sqlType: resolveSqlType({
+        data_type: String(row.data_type),
+        udt_name: String(row.udt_name),
+        character_maximum_length: row.character_maximum_length,
+        numeric_precision: row.numeric_precision,
+        numeric_scale: row.numeric_scale
+      }),
+      nullable: row.is_nullable === "YES",
+      defaultExpr: isGenerated ? null : defaultExpr,
+      isSerial: !isGenerated && isSerial,
+      generatedExpr: isGenerated ? String(row.generation_expression) : null
+    });
+  }
+  const constraintGroups = /* @__PURE__ */ new Map();
+  for (const row of constraints.rows) {
+    const key = String(row.constraint_name);
+    if (!constraintGroups.has(key)) {
+      constraintGroups.set(key, {
+        table: String(row.table_name),
+        type: String(row.constraint_type),
+        columns: []
+      });
+    }
+    constraintGroups.get(key).columns.push(String(row.column_name));
+  }
+  for (const group of constraintGroups.values()) {
+    const table = tableMap.get(group.table);
+    if (!table) continue;
+    if (group.type === "PRIMARY KEY") {
+      table.primaryKey = group.columns;
+    } else if (group.type === "UNIQUE") {
+      table.uniques.push(group.columns);
+    }
+  }
+  const fkGroups = /* @__PURE__ */ new Map();
+  for (const row of fks.rows) {
+    const key = String(row.constraint_name);
+    if (!fkGroups.has(key)) {
+      fkGroups.set(key, {
+        constraintName: key,
+        table: String(row.table_name),
+        columns: [],
+        referencedTable: String(row.referenced_table),
+        referencedColumns: [],
+        onDelete: String(row.delete_rule),
+        onUpdate: String(row.update_rule)
+      });
+    }
+    const fk = fkGroups.get(key);
+    fk.columns.push(String(row.column_name));
+    fk.referencedColumns.push(String(row.referenced_column));
+  }
+  return {
+    extensions: extensions.rows.map((r) => String(r.extname)).filter((name) => TRACKED_EXTENSIONS.has(name)),
+    enums: Array.from(enumMap, ([name, values]) => ({ name, values })),
+    tables: Array.from(tableMap.values()),
+    foreignKeys: Array.from(fkGroups.values()),
+    checks: checks.rows.map((r) => ({
+      table: String(r.table_name),
+      name: String(r.name),
+      definition: String(r.definition)
+    })),
+    indexes: indexes.rows.map((r) => ({ definition: String(r.indexdef) }))
+  };
+}
+function columnDdl(column, isSinglePk) {
+  let sqlType = column.sqlType;
+  if (column.isSerial) {
+    sqlType = sqlType === "bigint" ? "bigserial" : sqlType === "smallint" ? "smallserial" : "serial";
+  }
+  let ddl = `${quoteIdent(column.name)} ${sqlType}`;
+  if (isSinglePk) ddl += " PRIMARY KEY";
+  if (!column.nullable && !isSinglePk) ddl += " NOT NULL";
+  if (column.generatedExpr) {
+    ddl += ` GENERATED ALWAYS AS (${column.generatedExpr}) STORED`;
+  } else if (column.defaultExpr && !column.isSerial) {
+    ddl += ` DEFAULT ${column.defaultExpr}`;
+  }
+  return ddl;
+}
+function generateSchemaSql(snapshot) {
+  const lines = [
+    "-- Auto-generated by @stardeck-customer-apps/data-store-sdk",
+    "-- Schema snapshot of the live data store, applied to PGlite by the test harness.",
+    "-- Do not edit manually \u2014 regenerate with: npx stardeck-data-store generate-types",
+    ""
+  ];
+  for (const ext of snapshot.extensions) {
+    lines.push(`CREATE EXTENSION IF NOT EXISTS ${ext === "uuid-ossp" ? '"uuid-ossp"' : ext};`);
+  }
+  if (snapshot.extensions.length > 0) lines.push("");
+  for (const enumType of snapshot.enums) {
+    const values = enumType.values.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
+    lines.push(`CREATE TYPE ${quoteIdent(enumType.name)} AS ENUM (${values});`);
+  }
+  if (snapshot.enums.length > 0) lines.push("");
+  for (const table of snapshot.tables) {
+    const singlePk = table.primaryKey.length === 1 ? table.primaryKey[0] : null;
+    const parts = table.columns.map((col) => "  " + columnDdl(col, col.name === singlePk));
+    if (table.primaryKey.length > 1) {
+      parts.push(`  PRIMARY KEY (${table.primaryKey.map(quoteIdent).join(", ")})`);
+    }
+    for (const unique of table.uniques) {
+      parts.push(`  UNIQUE (${unique.map(quoteIdent).join(", ")})`);
+    }
+    lines.push(`CREATE TABLE ${quoteIdent(table.name)} (`);
+    lines.push(parts.join(",\n"));
+    lines.push(`);`);
+    lines.push("");
+  }
+  for (const check of snapshot.checks) {
+    lines.push(
+      `ALTER TABLE ${quoteIdent(check.table)} ADD CONSTRAINT ${quoteIdent(check.name)} ${check.definition};`
+    );
+  }
+  if (snapshot.checks.length > 0) lines.push("");
+  for (const fk of snapshot.foreignKeys) {
+    let stmt = `ALTER TABLE ${quoteIdent(fk.table)} ADD CONSTRAINT ${quoteIdent(fk.constraintName)} FOREIGN KEY (${fk.columns.map(quoteIdent).join(", ")}) REFERENCES ${quoteIdent(fk.referencedTable)} (${fk.referencedColumns.map(quoteIdent).join(", ")})`;
+    if (fk.onDelete !== "NO ACTION") stmt += ` ON DELETE ${fk.onDelete}`;
+    if (fk.onUpdate !== "NO ACTION") stmt += ` ON UPDATE ${fk.onUpdate}`;
+    lines.push(`${stmt};`);
+  }
+  if (snapshot.foreignKeys.length > 0) lines.push("");
+  for (const index of snapshot.indexes) {
+    lines.push(`${index.definition};`);
+  }
+  if (snapshot.indexes.length > 0) lines.push("");
+  return lines.join("\n");
+}
+
+// src/cli/generate-types.ts
+var PG_TYPE_MAP = {
+  text: "string",
+  varchar: "string",
+  "character varying": "string",
+  char: "string",
+  character: "string",
+  uuid: "string",
+  integer: "number",
+  int: "number",
+  smallint: "number",
+  bigint: "string",
+  // bigint as string to avoid precision loss
+  numeric: "string",
+  decimal: "string",
+  real: "number",
+  "double precision": "number",
+  boolean: "boolean",
+  jsonb: "unknown",
+  json: "unknown",
+  "timestamp with time zone": "Date",
+  "timestamp without time zone": "Date",
+  timestamp: "Date",
+  date: "string",
+  time: "string",
+  "time with time zone": "string",
+  "time without time zone": "string",
+  bytea: "Buffer",
+  ARRAY: "unknown[]"
+};
+function pgTypeToTs(pgType) {
+  return PG_TYPE_MAP[pgType] ?? "unknown";
+}
+function parseCliArgs(argv, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const env = options.env ?? process.env;
+  let connectionString = env.DATA_STORE_URL;
+  let store;
+  let outputPath = "./src/generated/data-store-types.ts";
+  let schemaOutputPath;
+  let emitSchema = !(0, import_fs2.existsSync)((0, import_path2.resolve)(cwd, "datastore/ledger-order.json"));
+  let modulesDir = (0, import_path2.resolve)(cwd, "./src/modules");
+  let noModules = false;
+  let help = false;
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--connection-string" && argv[i + 1]) {
+      connectionString = argv[++i];
+    } else if (argv[i] === "--store" && argv[i + 1]) {
+      store = argv[++i];
+    } else if (argv[i] === "--output" && argv[i + 1]) {
+      outputPath = argv[++i];
+    } else if (argv[i] === "--schema-output" && argv[i + 1]) {
+      schemaOutputPath = argv[++i];
+      emitSchema = true;
+    } else if (argv[i] === "--no-schema") {
+      emitSchema = false;
+    } else if (argv[i] === "--modules-dir" && argv[i + 1]) {
+      modulesDir = (0, import_path2.resolve)(cwd, argv[++i]);
+    } else if (argv[i] === "--no-modules") {
+      noModules = true;
+    } else if (argv[i] === "--help") {
+      help = true;
+    }
+  }
+  return {
+    connectionString,
+    store,
+    outputPath,
+    schemaOutputPath,
+    emitSchema,
+    modulesDir,
+    noModules,
+    help
+  };
+}
+async function introspectSchema(connectionString) {
+  const pool = new import_serverless.Pool({ connectionString });
+  try {
+    const { rows } = await pool.query(`
+      SELECT
+        c.table_name,
+        c.column_name,
+        c.data_type,
+        c.is_nullable,
+        c.column_default
+      FROM information_schema.columns c
+      JOIN information_schema.tables t
+        ON c.table_name = t.table_name AND c.table_schema = t.table_schema
+      WHERE c.table_schema = 'public'
+        AND t.table_type = 'BASE TABLE'
+        AND t.table_name NOT LIKE '_deleted_%'
+      ORDER BY c.table_name, c.ordinal_position
+    `);
+    const tables = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      if (!tables.has(row.table_name)) {
+        tables.set(row.table_name, []);
+      }
+      tables.get(row.table_name).push(row);
+    }
+    return tables;
+  } finally {
+    await pool.end();
+  }
+}
+function generateTypeScript(tables, moduleSlices) {
+  const lines = [
+    "// AUTO-GENERATED by @stardeck-customer-apps/data-store-sdk \u2014 DO NOT EDIT.",
+    "// This file is overwritten in full on every run of:",
+    "//   npx stardeck-data-store generate-types",
+    "// Anything you add here (hand-written or derived types) WILL BE LOST on the next",
+    "// regeneration. Put those in a separate file that imports from this one, e.g.",
+    "// src/lib/<domain>-types.ts importing the table types or DB from this file.",
+    "// When module manifests are discoverable, per-module DB slices and ModuleDBs are",
+    "// appended below the flat DB interface.",
+    "",
+    'import type { Generated } from "kysely";',
+    ""
+  ];
+  for (const [tableName, columns] of tables) {
+    const interfaceName = toPascalCase(tableName) + "Table";
+    lines.push(`export interface ${interfaceName} {`);
+    for (const col of columns) {
+      const tsType = pgTypeToTs(col.data_type);
+      const isGenerated = col.column_default !== null;
+      const isNullable = col.is_nullable === "YES";
+      let type = tsType;
+      if (isNullable) {
+        type = `${tsType} | null`;
+      }
+      if (isGenerated) {
+        type = `Generated<${type}>`;
+      }
+      lines.push(`  ${col.column_name}: ${type};`);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  lines.push("export interface DB {");
+  for (const tableName of tables.keys()) {
+    const interfaceName = toPascalCase(tableName) + "Table";
+    lines.push(`  ${tableName}: ${interfaceName};`);
+  }
+  lines.push("}");
+  lines.push("");
+  if (moduleSlices) {
+    const trimmed = moduleSlices.trimEnd();
+    if (trimmed.length > 0) {
+      lines.push(trimmed);
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+async function runGenerateTypes(options) {
+  const {
+    connectionString,
+    outputPath,
+    schemaOutputPath,
+    emitSchema = true,
+    modulesDir,
+    noModules,
+    introspect = introspectSchema,
+    warn = (message) => console.warn(message)
+  } = options;
+  console.log("Introspecting database schema...");
+  const tables = await introspect(connectionString);
+  if (tables.size === 0) {
+    console.log("No tables found in database.");
+    return;
+  }
+  console.log(`Found ${tables.size} table(s): ${Array.from(tables.keys()).join(", ")}`);
+  let moduleSlices = "";
+  if (shouldLoadModuleManifests(noModules)) {
+    const manifests = discoverModuleManifests(modulesDir, warn);
+    if (manifests.length > 0) {
+      moduleSlices = emitModuleDbSlices(new Set(tables.keys()), manifests, warn);
+    }
+  }
+  const typeScript = generateTypeScript(tables, moduleSlices || void 0);
+  const dir = outputPath.substring(0, outputPath.lastIndexOf("/"));
+  if (dir) {
+    const { mkdirSync } = await import("fs");
+    mkdirSync(dir, { recursive: true });
+  }
+  (0, import_fs2.writeFileSync)(outputPath, typeScript, "utf-8");
+  console.log(`Types written to ${outputPath}`);
+  if (emitSchema) {
+    const schemaPath = schemaOutputPath ?? `${dir ? `${dir}/` : ""}data-store-schema.sql`;
+    const pool = new import_serverless.Pool({ connectionString });
+    try {
+      const snapshot = await introspectSchemaSnapshot(pool);
+      (0, import_fs2.writeFileSync)(schemaPath, generateSchemaSql(snapshot), "utf-8");
+      console.log(`Schema snapshot written to ${schemaPath} (used by the test harness)`);
+    } finally {
+      await pool.end();
+    }
+  }
+}
+function connectionStringFromManifest(store) {
+  const databases = readDataStoreManifest().filter((entry) => entry.storeType !== "storage");
+  if (store) {
+    const match = resolveDataStore({ storeName: store });
+    if (!match?.url) {
+      return {
+        error: `No connected database store matches --store ${store}. Connected: ${listStores(databases)}.`
+      };
+    }
+    return { url: match.url };
+  }
+  if (databases.length === 1 && databases[0]?.url) return { url: databases[0].url };
+  if (databases.length === 0) {
+    return {
+      error: "No connected database store found. Run `npm run env:pull` in apps/web to write .env.local, or pass --connection-string."
+    };
+  }
+  return {
+    error: `${databases.length} database stores are connected; pass --store <bindingKey>. Connected: ${listStores(databases)}.`
+  };
+}
+function listStores(entries) {
+  return entries.length === 0 ? "none" : entries.map((entry) => entry.bindingKey ?? entry.slug).join(", ");
+}
+function loadEnvLocal(cwd) {
+  const path = (0, import_path2.resolve)(cwd, ".env.local");
+  let content;
+  try {
+    content = (0, import_fs2.readFileSync)(path, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      console.warn(`Warning: could not read ${path}: ${error.message}`);
+    }
+    return;
+  }
+  for (const [key, value] of Object.entries((0, import_util.parseEnv)(content))) {
+    if (value !== void 0 && process.env[key] === void 0) {
+      process.env[key] = value.replace(/\\\$/g, "$");
+    }
+  }
+}
+async function main(argv = process.argv.slice(2)) {
+  loadEnvLocal(process.cwd());
+  const parsed = parseCliArgs(argv);
+  if (parsed.help) {
+    console.log(`Usage: stardeck-data-store generate-types [options]
+
+Options:
+  --connection-string <url>  Postgres connection string (default: DATA_STORE_URL, else the
+                             app's connected store from STARDECK_DATA_STORES / .env.local)
+  --store <bindingKey>       Which connected store to read when the app has several
+  --output <path>            Output file path (default: ./src/generated/data-store-types.ts)
+  --schema-output <path>     DDL snapshot path (default: data-store-schema.sql next to --output)
+  --no-schema                Skip the DDL snapshot used by the test harness (implied when
+                             datastore/ledger-order.json exists: a Blueprint composes its own)
+  --modules-dir <path>       Directory containing module folders (default: ./src/modules)
+  --no-modules               Skip per-module DB slice generation
+  --help                     Show this help message`);
+    process.exit(0);
+  }
+  let connectionString = parsed.connectionString;
+  if (!connectionString) {
+    const resolved = connectionStringFromManifest(parsed.store);
+    if ("error" in resolved) {
+      console.error(`Error: ${resolved.error}`);
+      process.exit(1);
+    }
+    connectionString = resolved.url;
+  }
+  await runGenerateTypes({
+    connectionString,
+    outputPath: parsed.outputPath,
+    schemaOutputPath: parsed.schemaOutputPath,
+    emitSchema: parsed.emitSchema,
+    modulesDir: parsed.modulesDir,
+    noModules: parsed.noModules
+  });
+}
+
+// src/cli/bin.ts
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});