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

package/dist/cli/bin.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  main
+} from "../chunk-EWWQPGFI.mjs";
+import "../chunk-FEKROS4B.mjs";
+
+// src/cli/bin.ts
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/dist/cli/generate-types.d.mts

@@ -1 +1,75 @@
-#!/usr/bin/env node
+declare function toPascalCase(name: string): string;
+
+interface ColumnInfo {
+    table_name: string;
+    column_name: string;
+    data_type: string;
+    is_nullable: string;
+    column_default: string | null;
+}
+declare const PG_TYPE_MAP: Record<string, string>;
+declare function pgTypeToTs(pgType: string): string;
+
+type ParsedCliArgs = {
+    connectionString: string | undefined;
+    /** `--store`: which manifest entry to use when the app has several connected. */
+    store: string | undefined;
+    outputPath: string;
+    schemaOutputPath: string | undefined;
+    emitSchema: boolean;
+    modulesDir: string;
+    noModules: boolean;
+    help: boolean;
+};
+/**
+ * Pure argv parser for generate-types flags. Exported for unit tests.
+ */
+declare function parseCliArgs(argv: string[], options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): ParsedCliArgs;
+declare function introspectSchema(connectionString: string): Promise<Map<string, ColumnInfo[]>>;
+declare function generateTypeScript(tables: Map<string, ColumnInfo[]>, moduleSlices?: string): string;
+type RunGenerateTypesOptions = {
+    connectionString: string;
+    outputPath: string;
+    schemaOutputPath?: string;
+    emitSchema?: boolean;
+    modulesDir: string;
+    noModules: boolean;
+    /** Injectable for tests — defaults to live Postgres introspection. */
+    introspect?: (connectionString: string) => Promise<Map<string, ColumnInfo[]>>;
+    warn?: (message: string) => void;
+};
+/**
+ * Flag → discovery → emitter orchestration. Accepts an injectable introspect
+ * so tests can stub the pool without a live database.
+ */
+declare function runGenerateTypes(options: RunGenerateTypesOptions): Promise<void>;
+/**
+ * The connection string for the store the app is pointed at, from the manifest
+ * the app runtime itself resolves stores from. `--store` picks one entry the way
+ * `resolveDataStore` does (id, binding key, slug, name); otherwise the app's
+ * single database store is the answer, and anything else is an error the
+ * operator can act on. Storage stores carry no url and never count.
+ */
+declare function connectionStringFromManifest(store: string | undefined): {
+    url: string;
+} | {
+    error: string;
+};
+/**
+ * Load `./.env.local` the way the app's `next dev` reads it. `env:pull` writes
+ * the file for `@next/env` — dotenv parse followed by dotenv-expand — and
+ * escapes every `$` as `\$` so expand leaves the value alone; Node's parser
+ * keeps that backslash, which turns a manifest holding a `$` (a store name, a
+ * password) into invalid JSON. Undo the one escape so the manifest is the JSON
+ * the app sees. Shell values win over the file, like `node --env-file`.
+ *
+ * ponytail: no `$VAR` expansion of hand-edited lines; `env:pull` never writes
+ * one. Add dotenv-expand if a file ever needs it.
+ */
+declare function loadEnvLocal(cwd: string): void;
+declare function main(argv?: string[]): Promise<void>;
+
+export { type ColumnInfo, PG_TYPE_MAP, type ParsedCliArgs, type RunGenerateTypesOptions, connectionStringFromManifest, generateTypeScript, introspectSchema, loadEnvLocal, main, parseCliArgs, pgTypeToTs, runGenerateTypes, toPascalCase };

package/dist/cli/generate-types.d.ts

@@ -1 +1,75 @@
-#!/usr/bin/env node
+declare function toPascalCase(name: string): string;
+
+interface ColumnInfo {
+    table_name: string;
+    column_name: string;
+    data_type: string;
+    is_nullable: string;
+    column_default: string | null;
+}
+declare const PG_TYPE_MAP: Record<string, string>;
+declare function pgTypeToTs(pgType: string): string;
+
+type ParsedCliArgs = {
+    connectionString: string | undefined;
+    /** `--store`: which manifest entry to use when the app has several connected. */
+    store: string | undefined;
+    outputPath: string;
+    schemaOutputPath: string | undefined;
+    emitSchema: boolean;
+    modulesDir: string;
+    noModules: boolean;
+    help: boolean;
+};
+/**
+ * Pure argv parser for generate-types flags. Exported for unit tests.
+ */
+declare function parseCliArgs(argv: string[], options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): ParsedCliArgs;
+declare function introspectSchema(connectionString: string): Promise<Map<string, ColumnInfo[]>>;
+declare function generateTypeScript(tables: Map<string, ColumnInfo[]>, moduleSlices?: string): string;
+type RunGenerateTypesOptions = {
+    connectionString: string;
+    outputPath: string;
+    schemaOutputPath?: string;
+    emitSchema?: boolean;
+    modulesDir: string;
+    noModules: boolean;
+    /** Injectable for tests — defaults to live Postgres introspection. */
+    introspect?: (connectionString: string) => Promise<Map<string, ColumnInfo[]>>;
+    warn?: (message: string) => void;
+};
+/**
+ * Flag → discovery → emitter orchestration. Accepts an injectable introspect
+ * so tests can stub the pool without a live database.
+ */
+declare function runGenerateTypes(options: RunGenerateTypesOptions): Promise<void>;
+/**
+ * The connection string for the store the app is pointed at, from the manifest
+ * the app runtime itself resolves stores from. `--store` picks one entry the way
+ * `resolveDataStore` does (id, binding key, slug, name); otherwise the app's
+ * single database store is the answer, and anything else is an error the
+ * operator can act on. Storage stores carry no url and never count.
+ */
+declare function connectionStringFromManifest(store: string | undefined): {
+    url: string;
+} | {
+    error: string;
+};
+/**
+ * Load `./.env.local` the way the app's `next dev` reads it. `env:pull` writes
+ * the file for `@next/env` — dotenv parse followed by dotenv-expand — and
+ * escapes every `$` as `\$` so expand leaves the value alone; Node's parser
+ * keeps that backslash, which turns a manifest holding a `$` (a store name, a
+ * password) into invalid JSON. Undo the one escape so the manifest is the JSON
+ * the app sees. Shell values win over the file, like `node --env-file`.
+ *
+ * ponytail: no `$VAR` expansion of hand-edited lines; `env:pull` never writes
+ * one. Add dotenv-expand if a file ever needs it.
+ */
+declare function loadEnvLocal(cwd: string): void;
+declare function main(argv?: string[]): Promise<void>;
+
+export { type ColumnInfo, PG_TYPE_MAP, type ParsedCliArgs, type RunGenerateTypesOptions, connectionStringFromManifest, generateTypeScript, introspectSchema, loadEnvLocal, main, parseCliArgs, pgTypeToTs, runGenerateTypes, toPascalCase };

package/dist/cli/generate-types.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -6,6 +5,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -22,11 +25,188 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/cli/generate-types.ts
-var import_fs = require("fs");
+var generate_types_exports = {};
+__export(generate_types_exports, {
+  PG_TYPE_MAP: () => PG_TYPE_MAP,
+  connectionStringFromManifest: () => connectionStringFromManifest,
+  generateTypeScript: () => generateTypeScript,
+  introspectSchema: () => introspectSchema,
+  loadEnvLocal: () => loadEnvLocal,
+  main: () => main,
+  parseCliArgs: () => parseCliArgs,
+  pgTypeToTs: () => pgTypeToTs,
+  runGenerateTypes: () => runGenerateTypes,
+  toPascalCase: () => toPascalCase
+});
+module.exports = __toCommonJS(generate_types_exports);
+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, '""')}"`;
@@ -315,8 +495,47 @@ var PG_TYPE_MAP = {
 function pgTypeToTs(pgType) {
   return PG_TYPE_MAP[pgType] ?? "unknown";
 }
-function toPascalCase(name) {
-  return name.split("_").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+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 });
@@ -348,7 +567,7 @@ async function introspectSchema(connectionString) {
     await pool.end();
   }
 }
-function generateTypeScript(tables) {
+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:",
@@ -356,6 +575,8 @@ function generateTypeScript(tables) {
     "// 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";',
     ""
@@ -386,69 +607,148 @@ function generateTypeScript(tables) {
   }
   lines.push("}");
   lines.push("");
-  return lines.join("\n");
-}
-async function main() {
-  const args = process.argv.slice(2);
-  let connectionString = process.env.DATA_STORE_URL;
-  let outputPath = "./src/generated/data-store-types.ts";
-  let schemaOutputPath;
-  let emitSchema = true;
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--connection-string" && args[i + 1]) {
-      connectionString = args[++i];
-    } else if (args[i] === "--output" && args[i + 1]) {
-      outputPath = args[++i];
-    } else if (args[i] === "--schema-output" && args[i + 1]) {
-      schemaOutputPath = args[++i];
-    } else if (args[i] === "--no-schema") {
-      emitSchema = false;
-    } else if (args[i] === "--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
-  --help                     Show this help message`);
-      process.exit(0);
+  if (moduleSlices) {
+    const trimmed = moduleSlices.trimEnd();
+    if (trimmed.length > 0) {
+      lines.push(trimmed);
+      lines.push("");
     }
   }
-  if (!connectionString) {
-    console.error(
-      "Error: No connection string provided. Set DATA_STORE_URL or use --connection-string."
-    );
-    process.exit(1);
-  }
+  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 introspectSchema(connectionString);
+  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(", ")}`);
-  const typeScript = generateTypeScript(tables);
+  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_fs.writeFileSync)(outputPath, typeScript, "utf-8");
+  (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_fs.writeFileSync)(schemaPath, generateSchemaSql(snapshot), "utf-8");
+      (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();
     }
   }
 }
-main().catch((error) => {
-  console.error("Failed to generate types:", error);
-  process.exit(1);
+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
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PG_TYPE_MAP,
+  connectionStringFromManifest,
+  generateTypeScript,
+  introspectSchema,
+  loadEnvLocal,
+  main,
+  parseCliArgs,
+  pgTypeToTs,
+  runGenerateTypes,
+  toPascalCase
 });