turbine-orm 0.13.3 → 0.14.0

package/dist/cjs/dialect.js

@@ -9,6 +9,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.postgresDialect = void 0;
 const errors_js_1 = require("./errors.js");
+const schema_js_1 = require("./schema.js");
 /** PostgreSQL implementation of the dialect contract. */
 exports.postgresDialect = {
     name: 'postgresql',
@@ -72,10 +73,11 @@ exports.postgresDialect = {
             .map((col, i) => `${leftRef}.${this.quoteIdentifier(col)} = ${rightRef}.${this.quoteIdentifier(rightCols[i])}`)
             .join(' AND ');
     },
-    typeToTypeScript(_dialectType, _nullable) {
-        // Existing PostgreSQL type mapping remains in schema.ts/generate.ts for now.
-        // This hook is the package boundary MySQL/SQLite implementations will fill.
-        return 'unknown';
+    typeToTypeScript(dialectType, nullable) {
+        return (0, schema_js_1.pgTypeToTs)(dialectType, nullable);
+    },
+    arrayType(baseType) {
+        return (0, schema_js_1.pgArrayType)(baseType);
     },
     buildColumnType(input) {
         if (input.type === 'VARCHAR' && input.maxLength != null) {

package/dist/cjs/generate.js

@@ -218,7 +218,13 @@ function generateMetadata(schema) {
         // dateColumns
         const dateCols = [...table.dateColumns];
         lines.push(`      dateColumns: new Set([${dateCols.map((c) => `'${escSQ(c)}'`).join(', ')}]),`);
-        // pgTypes
+        // dialectTypes + pgTypes (pgTypes is kept for backwards compatibility)
+        const dialectTypes = table.dialectTypes ?? table.pgTypes;
+        lines.push('      dialectTypes: {');
+        for (const [col, dialectType] of Object.entries(dialectTypes)) {
+            lines.push(`        ${quoteIfNeeded(col)}: '${escSQ(dialectType)}',`);
+        }
+        lines.push('      },');
         lines.push('      pgTypes: {');
         for (const [col, pgType] of Object.entries(table.pgTypes)) {
             lines.push(`        ${quoteIfNeeded(col)}: '${escSQ(pgType)}',`);
@@ -392,11 +398,13 @@ function serializeColumn(col) {
     const parts = [
         `name: '${escSQ(col.name)}'`,
         `field: '${escSQ(col.field)}'`,
+        `dialectType: '${escSQ(col.dialectType ?? col.pgType)}'`,
         `pgType: '${escSQ(col.pgType)}'`,
         `tsType: '${escSQ(col.tsType)}'`,
         `nullable: ${col.nullable}`,
         `hasDefault: ${col.hasDefault}`,
         `isArray: ${col.isArray}`,
+        `arrayType: '${escSQ(col.arrayType ?? col.pgArrayType)}'`,
         `pgArrayType: '${escSQ(col.pgArrayType)}'`,
     ];
     if (col.maxLength !== undefined)

package/dist/cjs/introspect.js

@@ -14,6 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.introspect = introspect;
 const pg_1 = __importDefault(require("pg"));
+const dialect_js_1 = require("./dialect.js");
 const schema_js_1 = require("./schema.js");
 // ---------------------------------------------------------------------------
 // SQL queries (all parameterized, no interpolation)
@@ -101,6 +102,7 @@ const SQL_ENUMS = `
 // ---------------------------------------------------------------------------
 async function introspect(options) {
     const schema = options.schema ?? 'public';
+    const dialect = dialect_js_1.postgresDialect;
     const pool = new pg_1.default.Pool({
         connectionString: options.connectionString,
         max: 1,
@@ -137,15 +139,20 @@ async function introspect(options) {
             const isNullable = row.is_nullable === 'YES';
             const isArray = row.data_type === 'ARRAY';
             const baseType = isArray ? row.udt_name.slice(1) : row.udt_name;
+            const dialectType = row.udt_name;
+            const arrayType = dialect.arrayType?.(baseType) ?? 'text[]';
             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),
+                dialectType,
+                pgType: dialectType,
+                tsType: dialect.typeToTypeScript?.(isArray ? dialectType : baseType, isNullable) ??
+                    (0, schema_js_1.pgTypeToTs)(isArray ? dialectType : baseType, isNullable),
                 nullable: isNullable,
                 hasDefault: row.column_default !== null,
                 isArray,
-                pgArrayType: (0, schema_js_1.pgArrayType)(baseType),
+                arrayType,
+                pgArrayType: arrayType,
                 maxLength: row.character_maximum_length ?? undefined,
             };
             if (!columnsByTable.has(tableName))
@@ -281,14 +288,16 @@ async function introspect(options) {
             const columnMap = {};
             const reverseColumnMap = {};
             const dateColumns = new Set();
+            const dialectTypes = {};
             const pgTypes = {};
             const allColumns = [];
             for (const col of columns) {
                 columnMap[col.field] = col.name;
                 reverseColumnMap[col.name] = col.field;
                 allColumns.push(col.name);
+                dialectTypes[col.name] = col.dialectType ?? col.pgType;
                 pgTypes[col.name] = col.pgType;
-                const baseType = col.isArray ? col.pgType.slice(1) : col.pgType;
+                const baseType = col.isArray ? (col.dialectType ?? col.pgType).slice(1) : (col.dialectType ?? col.pgType);
                 if ((0, schema_js_1.isDateType)(baseType)) {
                     dateColumns.add(col.name);
                 }
@@ -299,6 +308,7 @@ async function introspect(options) {
                 columnMap,
                 reverseColumnMap,
                 dateColumns,
+                dialectTypes,
                 pgTypes,
                 allColumns,
                 primaryKey: pkByTable.get(tableName) ?? [],

package/dist/cjs/query/builder.js

@@ -153,8 +153,8 @@ class QueryInterface {
         this.columnPgTypeMap = new Map();
         this.columnArrayTypeMap = new Map();
         for (const col of this.tableMeta.columns) {
-            this.columnPgTypeMap.set(col.name, col.pgType);
-            this.columnArrayTypeMap.set(col.name, col.pgArrayType);
+            this.columnPgTypeMap.set(col.name, col.dialectType ?? col.pgType);
+            this.columnArrayTypeMap.set(col.name, col.arrayType ?? col.pgArrayType);
         }
     }
     /** Quote an identifier through the active SQL dialect. */
@@ -2680,12 +2680,13 @@ class QueryInterface {
         const arrayType = this.columnArrayTypeMap.get(column);
         if (arrayType)
             return arrayType;
-        // Fallback heuristic for unknown columns
+        // Fallback heuristic for unknown columns, routed through the active dialect
+        // so non-Postgres packages can supply their own bulk-insert cast shape.
         if (column === 'id' || column.endsWith('_id'))
-            return 'bigint[]';
+            return this.dialect.arrayType?.('int8') ?? 'text[]';
         if (column.endsWith('_at'))
-            return 'timestamptz[]';
-        return 'text[]';
+            return this.dialect.arrayType?.('timestamptz') ?? 'text[]';
+        return this.dialect.arrayType?.('text') ?? 'text[]';
     }
 }
 exports.QueryInterface = QueryInterface;

package/dist/dialect.d.ts

@@ -5,7 +5,7 @@
  * PostgreSQL-native by default, but query generation now depends on this
  * contract for the SQL primitives that vary across MySQL and SQLite.
  */
-import type { SchemaMetadata } from './schema.js';
+import { type SchemaMetadata } from './schema.js';
 export type DialectName = 'postgresql' | 'mysql' | 'sqlite' | (string & {});
 export interface InsertStatementInput {
     /** SQL-ready quoted table name. */
@@ -125,8 +125,8 @@ export interface Dialect {
     buildJsonPathExtract(column: string, pathParamRef: string): string;
     /** Build a correlation clause across single or composite keys. */
     buildCorrelation(leftRef: string, leftColumns: string | string[], rightRef: string, rightColumns: string | string[]): string;
-    /** Type mapping hook for code generation. */
-    typeToTypeScript(dialectType: string, nullable: boolean): string;
+    /** Optional type mapping hook for code generation/introspection. */
+    typeToTypeScript?(dialectType: string, nullable: boolean): string;
     /** Optional array-cast hook for bulk insert implementations. */
     arrayType?(baseType: string): string;
     /** Map a schema-builder column type to dialect DDL. */

package/dist/dialect.js

@@ -6,6 +6,7 @@
  * contract for the SQL primitives that vary across MySQL and SQLite.
  */
 import { ValidationError } from './errors.js';
+import { pgArrayType, pgTypeToTs } from './schema.js';
 /** PostgreSQL implementation of the dialect contract. */
 export const postgresDialect = {
     name: 'postgresql',
@@ -69,10 +70,11 @@ export const postgresDialect = {
             .map((col, i) => `${leftRef}.${this.quoteIdentifier(col)} = ${rightRef}.${this.quoteIdentifier(rightCols[i])}`)
             .join(' AND ');
     },
-    typeToTypeScript(_dialectType, _nullable) {
-        // Existing PostgreSQL type mapping remains in schema.ts/generate.ts for now.
-        // This hook is the package boundary MySQL/SQLite implementations will fill.
-        return 'unknown';
+    typeToTypeScript(dialectType, nullable) {
+        return pgTypeToTs(dialectType, nullable);
+    },
+    arrayType(baseType) {
+        return pgArrayType(baseType);
     },
     buildColumnType(input) {
         if (input.type === 'VARCHAR' && input.maxLength != null) {

package/dist/generate.js

@@ -214,7 +214,13 @@ function generateMetadata(schema) {
         // dateColumns
         const dateCols = [...table.dateColumns];
         lines.push(`      dateColumns: new Set([${dateCols.map((c) => `'${escSQ(c)}'`).join(', ')}]),`);
-        // pgTypes
+        // dialectTypes + pgTypes (pgTypes is kept for backwards compatibility)
+        const dialectTypes = table.dialectTypes ?? table.pgTypes;
+        lines.push('      dialectTypes: {');
+        for (const [col, dialectType] of Object.entries(dialectTypes)) {
+            lines.push(`        ${quoteIfNeeded(col)}: '${escSQ(dialectType)}',`);
+        }
+        lines.push('      },');
         lines.push('      pgTypes: {');
         for (const [col, pgType] of Object.entries(table.pgTypes)) {
             lines.push(`        ${quoteIfNeeded(col)}: '${escSQ(pgType)}',`);
@@ -388,11 +394,13 @@ function serializeColumn(col) {
     const parts = [
         `name: '${escSQ(col.name)}'`,
         `field: '${escSQ(col.field)}'`,
+        `dialectType: '${escSQ(col.dialectType ?? col.pgType)}'`,
         `pgType: '${escSQ(col.pgType)}'`,
         `tsType: '${escSQ(col.tsType)}'`,
         `nullable: ${col.nullable}`,
         `hasDefault: ${col.hasDefault}`,
         `isArray: ${col.isArray}`,
+        `arrayType: '${escSQ(col.arrayType ?? col.pgArrayType)}'`,
         `pgArrayType: '${escSQ(col.pgArrayType)}'`,
     ];
     if (col.maxLength !== undefined)

package/dist/introspect.js

@@ -8,7 +8,8 @@
  * This is the foundation of `npx turbine generate`.
  */
 import pg from 'pg';
-import { isDateType, pgArrayType, pgTypeToTs, singularize, snakeToCamel, } from './schema.js';
+import { postgresDialect } from './dialect.js';
+import { isDateType, pgTypeToTs, singularize, snakeToCamel, } from './schema.js';
 // ---------------------------------------------------------------------------
 // SQL queries (all parameterized, no interpolation)
 // ---------------------------------------------------------------------------
@@ -95,6 +96,7 @@ const SQL_ENUMS = `
 // ---------------------------------------------------------------------------
 export async function introspect(options) {
     const schema = options.schema ?? 'public';
+    const dialect = postgresDialect;
     const pool = new pg.Pool({
         connectionString: options.connectionString,
         max: 1,
@@ -131,15 +133,20 @@ export async function introspect(options) {
             const isNullable = row.is_nullable === 'YES';
             const isArray = row.data_type === 'ARRAY';
             const baseType = isArray ? row.udt_name.slice(1) : row.udt_name;
+            const dialectType = row.udt_name;
+            const arrayType = dialect.arrayType?.(baseType) ?? 'text[]';
             const col = {
                 name: row.column_name,
                 field: snakeToCamel(row.column_name),
-                pgType: row.udt_name,
-                tsType: pgTypeToTs(isArray ? row.udt_name : baseType, isNullable),
+                dialectType,
+                pgType: dialectType,
+                tsType: dialect.typeToTypeScript?.(isArray ? dialectType : baseType, isNullable) ??
+                    pgTypeToTs(isArray ? dialectType : baseType, isNullable),
                 nullable: isNullable,
                 hasDefault: row.column_default !== null,
                 isArray,
-                pgArrayType: pgArrayType(baseType),
+                arrayType,
+                pgArrayType: arrayType,
                 maxLength: row.character_maximum_length ?? undefined,
             };
             if (!columnsByTable.has(tableName))
@@ -275,14 +282,16 @@ export async function introspect(options) {
             const columnMap = {};
             const reverseColumnMap = {};
             const dateColumns = new Set();
+            const dialectTypes = {};
             const pgTypes = {};
             const allColumns = [];
             for (const col of columns) {
                 columnMap[col.field] = col.name;
                 reverseColumnMap[col.name] = col.field;
                 allColumns.push(col.name);
+                dialectTypes[col.name] = col.dialectType ?? col.pgType;
                 pgTypes[col.name] = col.pgType;
-                const baseType = col.isArray ? col.pgType.slice(1) : col.pgType;
+                const baseType = col.isArray ? (col.dialectType ?? col.pgType).slice(1) : (col.dialectType ?? col.pgType);
                 if (isDateType(baseType)) {
                     dateColumns.add(col.name);
                 }
@@ -293,6 +302,7 @@ export async function introspect(options) {
                 columnMap,
                 reverseColumnMap,
                 dateColumns,
+                dialectTypes,
                 pgTypes,
                 allColumns,
                 primaryKey: pkByTable.get(tableName) ?? [],

package/dist/query/builder.js

@@ -150,8 +150,8 @@ export class QueryInterface {
         this.columnPgTypeMap = new Map();
         this.columnArrayTypeMap = new Map();
         for (const col of this.tableMeta.columns) {
-            this.columnPgTypeMap.set(col.name, col.pgType);
-            this.columnArrayTypeMap.set(col.name, col.pgArrayType);
+            this.columnPgTypeMap.set(col.name, col.dialectType ?? col.pgType);
+            this.columnArrayTypeMap.set(col.name, col.arrayType ?? col.pgArrayType);
         }
     }
     /** Quote an identifier through the active SQL dialect. */
@@ -2677,12 +2677,13 @@ export class QueryInterface {
         const arrayType = this.columnArrayTypeMap.get(column);
         if (arrayType)
             return arrayType;
-        // Fallback heuristic for unknown columns
+        // Fallback heuristic for unknown columns, routed through the active dialect
+        // so non-Postgres packages can supply their own bulk-insert cast shape.
         if (column === 'id' || column.endsWith('_id'))
-            return 'bigint[]';
+            return this.dialect.arrayType?.('int8') ?? 'text[]';
         if (column.endsWith('_at'))
-            return 'timestamptz[]';
-        return 'text[]';
+            return this.dialect.arrayType?.('timestamptz') ?? 'text[]';
+        return this.dialect.arrayType?.('text') ?? 'text[]';
     }
 }
 //# sourceMappingURL=builder.js.map

package/dist/schema.d.ts

@@ -21,7 +21,9 @@ export interface TableMetadata {
     reverseColumnMap: Record<string, string>;
     /** snake_case columns that are timestamp/date types (need Date parsing) */
     dateColumns: Set<string>;
-    /** snake_case column → Postgres type for UNNEST casts */
+    /** snake_case column → dialect-native database type. */
+    dialectTypes?: Record<string, string>;
+    /** snake_case column → Postgres type for UNNEST casts. Back-compat alias for dialectTypes. */
     pgTypes: Record<string, string>;
     /** All snake_case column names in ordinal order */
     allColumns: string[];
@@ -39,7 +41,9 @@ export interface ColumnMetadata {
     name: string;
     /** camelCase field name for TypeScript */
     field: string;
-    /** Postgres base type (e.g. 'int8', 'text', 'timestamptz') */
+    /** Dialect-native database type (e.g. PostgreSQL 'int8', MySQL 'bigint', SQLite 'INTEGER'). */
+    dialectType?: string;
+    /** Postgres base type (e.g. 'int8', 'text', 'timestamptz'). Back-compat alias for dialectType. */
     pgType: string;
     /** TypeScript type string (e.g. 'number', 'string', 'Date') */
     tsType: string;
@@ -49,7 +53,9 @@ export interface ColumnMetadata {
     hasDefault: boolean;
     /** Whether this is an array column */
     isArray: boolean;
-    /** Postgres array type for UNNEST (e.g. 'bigint[]') */
+    /** Dialect-specific array/bulk-insert type token when needed. */
+    arrayType?: string;
+    /** Postgres array type for UNNEST (e.g. 'bigint[]'). Back-compat alias for arrayType. */
     pgArrayType: string;
     /** Max character length (for varchar) */
     maxLength?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.13.3",
+  "version": "0.14.0",
   "description": "Postgres-native TypeScript ORM — runs on Neon, Vercel Postgres, Cloudflare, Supabase. Streaming cursors, typed errors, single-query nested relations. 1 dependency, ~110KB",
   "type": "module",
   "exports": {