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

package/dist/cli/generate-types.mjs

@@ -1,615 +1,22 @@
-#!/usr/bin/env node
-
-// src/cli/generate-types.ts
-import { writeFileSync } from "fs";
-import { resolve } from "path";
-import { pathToFileURL } from "url";
-import { Pool } from "@neondatabase/serverless";
-
-// src/cli/module-type-slices.ts
-import { existsSync, readdirSync, readFileSync } from "fs";
-import { join } from "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 (!existsSync(modulesDir)) {
-    return [];
-  }
-  let entries;
-  try {
-    entries = 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 = join(modulesDir, dirName, "module.json");
-    if (!existsSync(manifestPath)) {
-      continue;
-    }
-    let content;
-    try {
-      content = 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 outputPath = "./src/generated/data-store-types.ts";
-  let schemaOutputPath;
-  let emitSchema = true;
-  let modulesDir = 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] === "--output" && argv[i + 1]) {
-      outputPath = argv[++i];
-    } else if (argv[i] === "--schema-output" && argv[i + 1]) {
-      schemaOutputPath = argv[++i];
-    } else if (argv[i] === "--no-schema") {
-      emitSchema = false;
-    } else if (argv[i] === "--modules-dir" && argv[i + 1]) {
-      modulesDir = resolve(cwd, argv[++i]);
-    } else if (argv[i] === "--no-modules") {
-      noModules = true;
-    } else if (argv[i] === "--help") {
-      help = true;
-    }
-  }
-  return {
-    connectionString,
-    outputPath,
-    schemaOutputPath,
-    emitSchema,
-    modulesDir,
-    noModules,
-    help
-  };
-}
-async function introspectSchema(connectionString) {
-  const pool = new 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 });
-  }
-  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 Pool({ connectionString });
-    try {
-      const snapshot = await introspectSchemaSnapshot(pool);
-      writeFileSync(schemaPath, generateSchemaSql(snapshot), "utf-8");
-      console.log(`Schema snapshot written to ${schemaPath} (used by the test harness)`);
-    } finally {
-      await pool.end();
-    }
-  }
-}
-async function main(argv = process.argv.slice(2)) {
-  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 env var)
-  --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
-  --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);
-  }
-  if (!parsed.connectionString) {
-    console.error(
-      "Error: No connection string provided. Set DATA_STORE_URL or use --connection-string."
-    );
-    process.exit(1);
-  }
-  await runGenerateTypes({
-    connectionString: parsed.connectionString,
-    outputPath: parsed.outputPath,
-    schemaOutputPath: parsed.schemaOutputPath,
-    emitSchema: parsed.emitSchema,
-    modulesDir: parsed.modulesDir,
-    noModules: parsed.noModules
-  });
-}
-function isDirectCliRun() {
-  const entry = process.argv[1];
-  if (!entry) return false;
-  try {
-    return import.meta.url === pathToFileURL(resolve(entry)).href;
-  } catch {
-    return false;
-  }
-}
-if (isDirectCliRun()) {
-  main().catch((error) => {
-    console.error("Failed to generate types:", error);
-    process.exit(1);
-  });
-}
+import {
+  PG_TYPE_MAP,
+  connectionStringFromManifest,
+  generateTypeScript,
+  introspectSchema,
+  loadEnvLocal,
+  main,
+  parseCliArgs,
+  pgTypeToTs,
+  runGenerateTypes,
+  toPascalCase
+} from "../chunk-EWWQPGFI.mjs";
+import "../chunk-FEKROS4B.mjs";
 export {
   PG_TYPE_MAP,
+  connectionStringFromManifest,
   generateTypeScript,
   introspectSchema,
+  loadEnvLocal,
   main,
   parseCliArgs,
   pgTypeToTs,