turbine-orm 0.4.0 → 0.5.0

package/dist/cjs/generate.js

@@ -0,0 +1,301 @@
+"use strict";
+/**
+ * @batadata/turbine — Code generator
+ *
+ * Takes an IntrospectedSchema and emits TypeScript files:
+ *   - types.ts     — Entity interfaces, Create/Update input types
+ *   - metadata.ts  — Runtime schema metadata (column maps, relations, etc.)
+ *   - index.ts     — Configured TurbineClient with typed table accessors
+ *
+ * Output goes to the specified directory (default: ./generated/turbine/).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = generate;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const schema_js_1 = require("./schema.js");
+/** Get the TypeScript type name for a table (singularized PascalCase) */
+function entityName(tableName) {
+    return (0, schema_js_1.snakeToPascal)((0, schema_js_1.singularize)(tableName));
+}
+/** Escape a value for embedding in a single-quoted TypeScript string literal */
+function escSQ(value) {
+    return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+// ---------------------------------------------------------------------------
+// Main generate function
+// ---------------------------------------------------------------------------
+function generate(options) {
+    const outDir = options.outDir ?? './generated/turbine';
+    // Path traversal protection — ensure output stays within project root
+    const resolved = (0, node_path_1.resolve)(outDir);
+    const rel = (0, node_path_1.relative)(process.cwd(), resolved);
+    if (rel.startsWith('..') || (0, node_path_1.resolve)(rel) !== resolved) {
+        throw new Error(`Output directory must be within the project root. Got: ${outDir}`);
+    }
+    (0, node_fs_1.mkdirSync)(outDir, { recursive: true });
+    const files = [];
+    // Generate types.ts
+    const typesContent = generateTypes(options.schema);
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(outDir, 'types.ts'), typesContent, 'utf-8');
+    files.push('types.ts');
+    // Generate metadata.ts
+    const metadataContent = generateMetadata(options.schema);
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(outDir, 'metadata.ts'), metadataContent, 'utf-8');
+    files.push('metadata.ts');
+    // Generate index.ts (configured client)
+    const indexContent = generateIndex(options.schema);
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(outDir, 'index.ts'), indexContent, 'utf-8');
+    files.push('index.ts');
+    return { outDir, files };
+}
+// ---------------------------------------------------------------------------
+// types.ts generator
+// ---------------------------------------------------------------------------
+function generatedFileHeader() {
+    return [
+        '/**',
+        ' * Auto-generated by @batadata/turbine — DO NOT EDIT',
+        ' *',
+        ` * Generated at: ${new Date().toISOString()}`,
+        ' * @see https://batadata.com/docs/turbine',
+        ' */',
+        '',
+    ];
+}
+function generateTypes(schema) {
+    const lines = [
+        ...generatedFileHeader(),
+    ];
+    // Generate enum types
+    for (const [enumName, labels] of Object.entries(schema.enums)) {
+        const typeName = (0, schema_js_1.snakeToPascal)(enumName);
+        lines.push(`/** Database enum: ${enumName} */`);
+        lines.push(`export type ${typeName} = ${labels.map((l) => `'${escSQ(l)}'`).join(' | ')};`);
+        lines.push('');
+    }
+    // Generate entity types for each table
+    for (const table of Object.values(schema.tables)) {
+        const typeName = entityName(table.name);
+        // --- Base entity interface ---
+        lines.push(`/** Row type for the \`${table.name}\` table */`);
+        lines.push(`export interface ${typeName} {`);
+        for (const col of table.columns) {
+            const pkNote = table.primaryKey.includes(col.name) ? ' (primary key)' : '';
+            const nullNote = col.nullable ? ' (nullable)' : '';
+            lines.push(`  /** Column: ${col.name} — ${col.pgType}${pkNote}${nullNote} */`);
+            lines.push(`  ${col.field}: ${col.tsType};`);
+        }
+        lines.push('}');
+        lines.push('');
+        // --- Create input type ---
+        // Required: non-nullable columns without defaults (except PK)
+        // Optional: nullable columns (default to NULL) or columns with explicit defaults
+        lines.push(`/** Input type for creating a row in \`${table.name}\` */`);
+        lines.push(`export type ${typeName}Create = {`);
+        for (const col of table.columns) {
+            const isPk = table.primaryKey.includes(col.name);
+            const isOptional = col.hasDefault || col.nullable || isPk;
+            if (isOptional) {
+                const reason = isPk ? 'auto-generated' : col.hasDefault ? 'has default' : 'nullable';
+                lines.push(`  /** Optional: ${reason} */`);
+                lines.push(`  ${col.field}?: ${col.tsType};`);
+            }
+            else {
+                lines.push(`  ${col.field}: ${col.tsType};`);
+            }
+        }
+        lines.push('};');
+        lines.push('');
+        // --- Update input type (all fields optional except PK) ---
+        const nonPkCols = table.columns.filter((c) => !table.primaryKey.includes(c.name));
+        lines.push(`/** Input type for updating a row in \`${table.name}\` */`);
+        lines.push(`export type ${typeName}Update = {`);
+        for (const col of nonPkCols) {
+            lines.push(`  ${col.field}?: ${col.tsType};`);
+        }
+        lines.push('};');
+        lines.push('');
+        // --- Relation types ---
+        const hasRelations = Object.keys(table.relations).length > 0;
+        if (hasRelations) {
+            for (const [relName, rel] of Object.entries(table.relations)) {
+                const targetType = entityName(rel.to);
+                if (rel.type === 'hasMany') {
+                    lines.push(`/** ${typeName} with \`${relName}\` relation loaded (${rel.type}: ${rel.to}) */`);
+                    lines.push(`export interface ${typeName}With${(0, schema_js_1.snakeToPascal)(relName)} extends ${typeName} {`);
+                    lines.push(`  ${relName}: ${targetType}[];`);
+                    lines.push('}');
+                }
+                else {
+                    lines.push(`/** ${typeName} with \`${relName}\` relation loaded (${rel.type}: ${rel.to}) */`);
+                    lines.push(`export interface ${typeName}With${(0, schema_js_1.snakeToPascal)(relName)} extends ${typeName} {`);
+                    lines.push(`  ${relName}: ${targetType} | null;`);
+                    lines.push('}');
+                }
+                lines.push('');
+            }
+        }
+    }
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// metadata.ts generator
+// ---------------------------------------------------------------------------
+function generateMetadata(schema) {
+    const lines = [
+        ...generatedFileHeader(),
+        "import type { SchemaMetadata } from '@batadata/turbine';",
+        '',
+        'export const SCHEMA: SchemaMetadata = {',
+        '  tables: {',
+    ];
+    for (const table of Object.values(schema.tables)) {
+        lines.push(`    ${table.name}: {`);
+        lines.push(`      name: '${escSQ(table.name)}',`);
+        // columns
+        lines.push('      columns: [');
+        for (const col of table.columns) {
+            lines.push(`        ${serializeColumn(col)},`);
+        }
+        lines.push('      ],');
+        // columnMap
+        lines.push('      columnMap: {');
+        for (const [field, col] of Object.entries(table.columnMap)) {
+            lines.push(`        ${field}: '${escSQ(col)}',`);
+        }
+        lines.push('      },');
+        // reverseColumnMap
+        lines.push('      reverseColumnMap: {');
+        for (const [col, field] of Object.entries(table.reverseColumnMap)) {
+            lines.push(`        ${quoteIfNeeded(col)}: '${escSQ(field)}',`);
+        }
+        lines.push('      },');
+        // dateColumns
+        const dateCols = [...table.dateColumns];
+        lines.push(`      dateColumns: new Set([${dateCols.map((c) => `'${escSQ(c)}'`).join(', ')}]),`);
+        // pgTypes
+        lines.push('      pgTypes: {');
+        for (const [col, pgType] of Object.entries(table.pgTypes)) {
+            lines.push(`        ${quoteIfNeeded(col)}: '${escSQ(pgType)}',`);
+        }
+        lines.push('      },');
+        // allColumns
+        lines.push(`      allColumns: [${table.allColumns.map((c) => `'${escSQ(c)}'`).join(', ')}],`);
+        // primaryKey
+        lines.push(`      primaryKey: [${table.primaryKey.map((c) => `'${escSQ(c)}'`).join(', ')}],`);
+        // uniqueColumns
+        lines.push(`      uniqueColumns: [${table.uniqueColumns.map((uc) => `[${uc.map((c) => `'${escSQ(c)}'`).join(', ')}]`).join(', ')}],`);
+        // relations
+        lines.push('      relations: {');
+        for (const [relName, rel] of Object.entries(table.relations)) {
+            lines.push(`        ${relName}: { type: '${escSQ(rel.type)}', name: '${escSQ(rel.name)}', from: '${escSQ(rel.from)}', to: '${escSQ(rel.to)}', foreignKey: '${escSQ(rel.foreignKey)}', referenceKey: '${escSQ(rel.referenceKey)}' },`);
+        }
+        lines.push('      },');
+        // indexes
+        lines.push('      indexes: [');
+        for (const idx of table.indexes) {
+            lines.push(`        { name: '${escSQ(idx.name)}', columns: [${idx.columns.map((c) => `'${escSQ(c)}'`).join(', ')}], unique: ${idx.unique}, definition: ${JSON.stringify(idx.definition)} },`);
+        }
+        lines.push('      ],');
+        lines.push('    },');
+    }
+    lines.push('  },');
+    // enums
+    lines.push('  enums: {');
+    for (const [enumName, labels] of Object.entries(schema.enums)) {
+        lines.push(`    ${enumName}: [${labels.map((l) => `'${escSQ(l)}'`).join(', ')}],`);
+    }
+    lines.push('  },');
+    lines.push('};');
+    lines.push('');
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// index.ts generator (configured client with typed table accessors)
+// ---------------------------------------------------------------------------
+function generateIndex(schema) {
+    const tableEntries = Object.values(schema.tables);
+    const lines = [
+        ...generatedFileHeader(),
+        "import { TurbineClient as BaseTurbineClient, QueryInterface } from '@batadata/turbine';",
+        "import type { TurbineConfig } from '@batadata/turbine';",
+        "import { SCHEMA } from './metadata.js';",
+    ];
+    // Import all entity types
+    const typeImports = tableEntries.map((t) => entityName(t.name));
+    lines.push(`import type { ${typeImports.join(', ')} } from './types.js';`);
+    lines.push('');
+    // Generate the client class with JSDoc
+    lines.push('/**');
+    lines.push(' * Generated Turbine client with typed table accessors.');
+    lines.push(' *');
+    lines.push(' * Tables:');
+    for (const table of tableEntries) {
+        lines.push(` *   - \`${snakeToCamelStr(table.name)}\` (${table.name})`);
+    }
+    lines.push(' *');
+    lines.push(' * @example');
+    lines.push(' * ```ts');
+    lines.push(' * const db = turbine({ connectionString: process.env.DATABASE_URL });');
+    if (tableEntries.length > 0) {
+        const firstTable = tableEntries[0];
+        const accessor = snakeToCamelStr(firstTable.name);
+        lines.push(` * const rows = await db.${accessor}.findMany();`);
+    }
+    lines.push(' * ```');
+    lines.push(' */');
+    lines.push('export class TurbineClient extends BaseTurbineClient {');
+    for (const table of tableEntries) {
+        const typeName = entityName(table.name);
+        const accessor = snakeToCamelStr(table.name);
+        lines.push(`  /** Query interface for the \`${table.name}\` table */`);
+        lines.push(`  declare readonly ${accessor}: QueryInterface<${typeName}>;`);
+    }
+    lines.push('');
+    lines.push('  constructor(config?: TurbineConfig) {');
+    lines.push('    super(config, SCHEMA);');
+    lines.push('  }');
+    lines.push('}');
+    lines.push('');
+    // Factory function with JSDoc
+    lines.push('/**');
+    lines.push(' * Create a new Turbine client instance.');
+    lines.push(' *');
+    lines.push(' * @param config - Connection configuration. Falls back to DATABASE_URL env var.');
+    lines.push(' * @returns A fully-typed TurbineClient with table accessors.');
+    lines.push(' */');
+    lines.push('export function turbine(config?: TurbineConfig): TurbineClient {');
+    lines.push('  return new TurbineClient(config);');
+    lines.push('}');
+    lines.push('');
+    // Re-export everything
+    lines.push("export * from './types.js';");
+    lines.push("export { SCHEMA } from './metadata.js';");
+    lines.push('');
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function serializeColumn(col) {
+    const parts = [
+        `name: '${escSQ(col.name)}'`,
+        `field: '${escSQ(col.field)}'`,
+        `pgType: '${escSQ(col.pgType)}'`,
+        `tsType: '${escSQ(col.tsType)}'`,
+        `nullable: ${col.nullable}`,
+        `hasDefault: ${col.hasDefault}`,
+        `isArray: ${col.isArray}`,
+        `pgArrayType: '${escSQ(col.pgArrayType)}'`,
+    ];
+    if (col.maxLength !== undefined)
+        parts.push(`maxLength: ${col.maxLength}`);
+    return `{ ${parts.join(', ')} }`;
+}
+function quoteIfNeeded(s) {
+    return /[^a-zA-Z0-9_$]/.test(s) ? `'${s}'` : s;
+}
+function snakeToCamelStr(s) {
+    return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}

package/dist/cjs/index.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * @batadata/turbine
+ *
+ * Turbine TypeScript SDK — type-safe Postgres queries with nested relations
+ * and pipeline batching. Feels like Prisma, runs at raw-SQL speed.
+ *
+ * @example
+ * ```ts
+ * // 1. Generate types from your database:
+ * //    npx turbine generate
+ *
+ * // 2. Import the generated client:
+ * import { turbine } from './generated/turbine';
+ *
+ * const db = turbine({ connectionString: process.env.DATABASE_URL });
+ *
+ * // Type-safe queries with auto-complete
+ * const user = await db.users.findUnique({ where: { id: 1 } });
+ *
+ * // Nested relations in a single query (json_agg, no N+1)
+ * const userWithPosts = await db.users.findUnique({
+ *   where: { id: 1 },
+ *   with: { posts: { with: { comments: true } } },
+ * });
+ *
+ * // Pipeline: multiple queries in one round-trip
+ * const [user, count] = await db.pipeline(
+ *   db.users.buildFindUnique({ where: { id: 1 } }),
+ *   db.posts.buildCount({ where: { orgId: 1 } }),
+ * );
+ *
+ * await db.disconnect();
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaPush = exports.schemaDiff = exports.schemaToSQLString = exports.schemaToSQL = exports.ColumnBuilder = exports.column = exports.table = exports.defineSchema = exports.generate = exports.introspect = exports.pgArrayType = exports.isDateType = exports.pgTypeToTs = exports.singularize = exports.snakeToPascal = exports.camelToSnake = exports.snakeToCamel = exports.executePipeline = exports.QueryInterface = exports.TransactionClient = exports.TurbineClient = void 0;
+// Client
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "TurbineClient", { enumerable: true, get: function () { return client_js_1.TurbineClient; } });
+Object.defineProperty(exports, "TransactionClient", { enumerable: true, get: function () { return client_js_1.TransactionClient; } });
+// Query builder
+var query_js_1 = require("./query.js");
+Object.defineProperty(exports, "QueryInterface", { enumerable: true, get: function () { return query_js_1.QueryInterface; } });
+// Pipeline
+var pipeline_js_1 = require("./pipeline.js");
+Object.defineProperty(exports, "executePipeline", { enumerable: true, get: function () { return pipeline_js_1.executePipeline; } });
+// Schema utilities
+var schema_js_1 = require("./schema.js");
+Object.defineProperty(exports, "snakeToCamel", { enumerable: true, get: function () { return schema_js_1.snakeToCamel; } });
+Object.defineProperty(exports, "camelToSnake", { enumerable: true, get: function () { return schema_js_1.camelToSnake; } });
+Object.defineProperty(exports, "snakeToPascal", { enumerable: true, get: function () { return schema_js_1.snakeToPascal; } });
+Object.defineProperty(exports, "singularize", { enumerable: true, get: function () { return schema_js_1.singularize; } });
+Object.defineProperty(exports, "pgTypeToTs", { enumerable: true, get: function () { return schema_js_1.pgTypeToTs; } });
+Object.defineProperty(exports, "isDateType", { enumerable: true, get: function () { return schema_js_1.isDateType; } });
+Object.defineProperty(exports, "pgArrayType", { enumerable: true, get: function () { return schema_js_1.pgArrayType; } });
+// Introspection
+var introspect_js_1 = require("./introspect.js");
+Object.defineProperty(exports, "introspect", { enumerable: true, get: function () { return introspect_js_1.introspect; } });
+// Code generation
+var generate_js_1 = require("./generate.js");
+Object.defineProperty(exports, "generate", { enumerable: true, get: function () { return generate_js_1.generate; } });
+// Schema builder — define schemas in TypeScript
+var schema_builder_js_1 = require("./schema-builder.js");
+Object.defineProperty(exports, "defineSchema", { enumerable: true, get: function () { return schema_builder_js_1.defineSchema; } });
+// Legacy compat (deprecated — use object format with defineSchema)
+Object.defineProperty(exports, "table", { enumerable: true, get: function () { return schema_builder_js_1.table; } });
+Object.defineProperty(exports, "column", { enumerable: true, get: function () { return schema_builder_js_1.column; } });
+Object.defineProperty(exports, "ColumnBuilder", { enumerable: true, get: function () { return schema_builder_js_1.ColumnBuilder; } });
+// Schema SQL — generate DDL, diff, and push
+var schema_sql_js_1 = require("./schema-sql.js");
+Object.defineProperty(exports, "schemaToSQL", { enumerable: true, get: function () { return schema_sql_js_1.schemaToSQL; } });
+Object.defineProperty(exports, "schemaToSQLString", { enumerable: true, get: function () { return schema_sql_js_1.schemaToSQLString; } });
+Object.defineProperty(exports, "schemaDiff", { enumerable: true, get: function () { return schema_sql_js_1.schemaDiff; } });
+Object.defineProperty(exports, "schemaPush", { enumerable: true, get: function () { return schema_sql_js_1.schemaPush; } });

package/dist/cjs/introspect.js

@@ -0,0 +1,289 @@
+"use strict";
+/**
+ * @batadata/turbine — Schema introspection
+ *
+ * Connects to a live Postgres database, reads information_schema + pg_catalog,
+ * and produces a SchemaMetadata object describing every table, column, relation,
+ * and index in the target schema.
+ *
+ * This is the foundation of `npx turbine generate`.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.introspect = introspect;
+const pg_1 = __importDefault(require("pg"));
+const schema_js_1 = require("./schema.js");
+// ---------------------------------------------------------------------------
+// SQL queries (all parameterized, no interpolation)
+// ---------------------------------------------------------------------------
+const SQL_TABLES = `
+  SELECT table_name
+  FROM information_schema.tables
+  WHERE table_schema = $1
+    AND table_type = 'BASE TABLE'
+  ORDER BY table_name
+`;
+const SQL_COLUMNS = `
+  SELECT
+    table_name,
+    column_name,
+    udt_name,
+    data_type,
+    is_nullable,
+    column_default,
+    ordinal_position,
+    character_maximum_length
+  FROM information_schema.columns
+  WHERE table_schema = $1
+  ORDER BY table_name, ordinal_position
+`;
+const SQL_PRIMARY_KEYS = `
+  SELECT
+    tc.table_name,
+    kcu.column_name,
+    kcu.ordinal_position
+  FROM information_schema.table_constraints tc
+  JOIN information_schema.key_column_usage kcu
+    ON tc.constraint_name = kcu.constraint_name
+    AND tc.table_schema = kcu.table_schema
+  WHERE tc.constraint_type = 'PRIMARY KEY'
+    AND tc.table_schema = $1
+  ORDER BY tc.table_name, kcu.ordinal_position
+`;
+const SQL_FOREIGN_KEYS = `
+  SELECT
+    tc.table_name AS source_table,
+    kcu.column_name AS source_column,
+    ccu.table_name AS target_table,
+    ccu.column_name AS target_column,
+    tc.constraint_name
+  FROM information_schema.table_constraints tc
+  JOIN information_schema.key_column_usage kcu
+    ON tc.constraint_name = kcu.constraint_name
+    AND tc.table_schema = kcu.table_schema
+  JOIN information_schema.constraint_column_usage ccu
+    ON tc.constraint_name = ccu.constraint_name
+    AND tc.table_schema = ccu.table_schema
+  WHERE tc.constraint_type = 'FOREIGN KEY'
+    AND tc.table_schema = $1
+`;
+const SQL_UNIQUE_CONSTRAINTS = `
+  SELECT
+    tc.table_name,
+    kcu.column_name
+  FROM information_schema.table_constraints tc
+  JOIN information_schema.key_column_usage kcu
+    ON tc.constraint_name = kcu.constraint_name
+    AND tc.table_schema = kcu.table_schema
+  WHERE tc.constraint_type = 'UNIQUE'
+    AND tc.table_schema = $1
+`;
+const SQL_INDEXES = `
+  SELECT tablename, indexname, indexdef
+  FROM pg_indexes
+  WHERE schemaname = $1
+`;
+const SQL_ENUMS = `
+  SELECT t.typname, e.enumlabel
+  FROM pg_type t
+  JOIN pg_enum e ON t.oid = e.enumtypid
+  JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+  WHERE n.nspname = $1
+  ORDER BY t.typname, e.enumsortorder
+`;
+// ---------------------------------------------------------------------------
+// Main introspection function
+// ---------------------------------------------------------------------------
+async function introspect(options) {
+    const schema = options.schema ?? 'public';
+    const pool = new pg_1.default.Pool({
+        connectionString: options.connectionString,
+        max: 1,
+        connectionTimeoutMillis: 10_000,
+    });
+    try {
+        // Run all information_schema queries in parallel
+        const [tablesResult, columnsResult, pkResult, fkResult, uniqueResult, indexResult, enumResult,] = await Promise.all([
+            pool.query(SQL_TABLES, [schema]),
+            pool.query(SQL_COLUMNS, [schema]),
+            pool.query(SQL_PRIMARY_KEYS, [schema]),
+            pool.query(SQL_FOREIGN_KEYS, [schema]),
+            pool.query(SQL_UNIQUE_CONSTRAINTS, [schema]),
+            pool.query(SQL_INDEXES, [schema]),
+            pool.query(SQL_ENUMS, [schema]),
+        ]);
+        // Filter tables by include/exclude
+        let tableNames = tablesResult.rows.map((r) => r.table_name);
+        if (options.include?.length) {
+            const includeSet = new Set(options.include);
+            tableNames = tableNames.filter((t) => includeSet.has(t));
+        }
+        if (options.exclude?.length) {
+            const excludeSet = new Set(options.exclude);
+            tableNames = tableNames.filter((t) => !excludeSet.has(t));
+        }
+        const tableSet = new Set(tableNames);
+        // ----- Group columns by table -----
+        const columnsByTable = new Map();
+        for (const row of columnsResult.rows) {
+            const tableName = row.table_name;
+            if (!tableSet.has(tableName))
+                continue;
+            const isNullable = row.is_nullable === 'YES';
+            const isArray = row.data_type === 'ARRAY';
+            const baseType = isArray ? row.udt_name.slice(1) : row.udt_name;
+            const col = {
+                name: row.column_name,
+                field: (0, schema_js_1.snakeToCamel)(row.column_name),
+                pgType: row.udt_name,
+                tsType: (0, schema_js_1.pgTypeToTs)(isArray ? row.udt_name : baseType, isNullable),
+                nullable: isNullable,
+                hasDefault: row.column_default !== null,
+                isArray,
+                pgArrayType: (0, schema_js_1.pgArrayType)(baseType),
+                maxLength: row.character_maximum_length ?? undefined,
+            };
+            if (!columnsByTable.has(tableName))
+                columnsByTable.set(tableName, []);
+            columnsByTable.get(tableName).push(col);
+        }
+        // ----- Group primary keys by table -----
+        const pkByTable = new Map();
+        for (const row of pkResult.rows) {
+            if (!tableSet.has(row.table_name))
+                continue;
+            if (!pkByTable.has(row.table_name))
+                pkByTable.set(row.table_name, []);
+            pkByTable.get(row.table_name).push(row.column_name);
+        }
+        // ----- Group unique constraints by table -----
+        const uniqueByTable = new Map();
+        for (const row of uniqueResult.rows) {
+            if (!tableSet.has(row.table_name))
+                continue;
+            if (!uniqueByTable.has(row.table_name))
+                uniqueByTable.set(row.table_name, []);
+            // Each unique constraint may be multi-column; for simplicity, treat as single-col here
+            uniqueByTable.get(row.table_name).push([row.column_name]);
+        }
+        // ----- Group indexes by table -----
+        const indexesByTable = new Map();
+        for (const row of indexResult.rows) {
+            if (!tableSet.has(row.tablename))
+                continue;
+            if (!indexesByTable.has(row.tablename))
+                indexesByTable.set(row.tablename, []);
+            const isUnique = row.indexdef.includes('UNIQUE');
+            // Extract column names from indexdef (e.g. "CREATE INDEX idx ON tbl USING btree (col1, col2)")
+            const colMatch = row.indexdef.match(/\((.+)\)/);
+            const columns = colMatch
+                ? colMatch[1].split(',').map((c) => c.trim().replace(/ (ASC|DESC)/i, ''))
+                : [];
+            indexesByTable.get(row.tablename).push({
+                name: row.indexname,
+                columns,
+                unique: isUnique,
+                definition: row.indexdef,
+            });
+        }
+        // ----- Collect enums -----
+        const enums = {};
+        for (const row of enumResult.rows) {
+            if (!enums[row.typname])
+                enums[row.typname] = [];
+            enums[row.typname].push(row.enumlabel);
+        }
+        const foreignKeys = [];
+        for (const row of fkResult.rows) {
+            if (!tableSet.has(row.source_table) || !tableSet.has(row.target_table))
+                continue;
+            foreignKeys.push({
+                sourceTable: row.source_table,
+                sourceColumn: row.source_column,
+                targetTable: row.target_table,
+                targetColumn: row.target_column,
+            });
+        }
+        // ----- Build relations from foreign keys -----
+        // Count FKs per (source, target) pair for disambiguation
+        const fkCounts = new Map();
+        for (const fk of foreignKeys) {
+            const key = `${fk.sourceTable}→${fk.targetTable}`;
+            fkCounts.set(key, (fkCounts.get(key) ?? 0) + 1);
+        }
+        const relationsByTable = new Map();
+        for (const fk of foreignKeys) {
+            const pairKey = `${fk.sourceTable}→${fk.targetTable}`;
+            const needsDisambiguation = (fkCounts.get(pairKey) ?? 0) > 1;
+            // --- belongsTo on the source (child) table ---
+            // e.g. posts.user_id → users.id creates posts.user (belongsTo)
+            const belongsToName = needsDisambiguation
+                ? (0, schema_js_1.snakeToCamel)(fk.sourceColumn.replace(/_id$/, ''))
+                : (0, schema_js_1.singularize)((0, schema_js_1.snakeToCamel)(fk.targetTable));
+            if (!relationsByTable.has(fk.sourceTable))
+                relationsByTable.set(fk.sourceTable, {});
+            relationsByTable.get(fk.sourceTable)[belongsToName] = {
+                type: 'belongsTo',
+                name: belongsToName,
+                from: fk.sourceTable,
+                to: fk.targetTable,
+                foreignKey: fk.sourceColumn,
+                referenceKey: fk.targetColumn,
+            };
+            // --- hasMany on the target (parent) table ---
+            // e.g. posts.user_id → users.id creates users.posts (hasMany)
+            const hasManyName = needsDisambiguation
+                ? (0, schema_js_1.snakeToCamel)(`${fk.sourceTable}_by_${fk.sourceColumn.replace(/_id$/, '')}`)
+                : (0, schema_js_1.snakeToCamel)(fk.sourceTable);
+            if (!relationsByTable.has(fk.targetTable))
+                relationsByTable.set(fk.targetTable, {});
+            relationsByTable.get(fk.targetTable)[hasManyName] = {
+                type: 'hasMany',
+                name: hasManyName,
+                from: fk.targetTable,
+                to: fk.sourceTable,
+                foreignKey: fk.sourceColumn,
+                referenceKey: fk.targetColumn,
+            };
+        }
+        // ----- Assemble TableMetadata for each table -----
+        const tables = {};
+        for (const tableName of tableNames) {
+            const columns = columnsByTable.get(tableName) ?? [];
+            const columnMap = {};
+            const reverseColumnMap = {};
+            const dateColumns = new Set();
+            const pgTypes = {};
+            const allColumns = [];
+            for (const col of columns) {
+                columnMap[col.field] = col.name;
+                reverseColumnMap[col.name] = col.field;
+                allColumns.push(col.name);
+                pgTypes[col.name] = col.pgType;
+                const baseType = col.isArray ? col.pgType.slice(1) : col.pgType;
+                if ((0, schema_js_1.isDateType)(baseType)) {
+                    dateColumns.add(col.name);
+                }
+            }
+            tables[tableName] = {
+                name: tableName,
+                columns,
+                columnMap,
+                reverseColumnMap,
+                dateColumns,
+                pgTypes,
+                allColumns,
+                primaryKey: pkByTable.get(tableName) ?? [],
+                uniqueColumns: uniqueByTable.get(tableName) ?? [],
+                relations: relationsByTable.get(tableName) ?? {},
+                indexes: indexesByTable.get(tableName) ?? [],
+            };
+        }
+        return { tables, enums };
+    }
+    finally {
+        await pool.end();
+    }
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}