turbine-orm 0.4.0 → 0.5.0

package/dist/query.js

@@ -1,5 +1,5 @@
 /**
- * turbine-orm — Query builder
+ * @batadata/turbine — Query builder
  *
  * Each table accessor (db.users, db.posts, etc.) returns a QueryInterface<T>
  * that builds parameterized SQL and executes it through the connection pool.
@@ -26,6 +26,13 @@ import { snakeToCamel, camelToSnake } from './schema.js';
 export function quoteIdent(name) {
     return `"${name.replace(/"/g, '""')}"`;
 }
+/**
+ * Escape single quotes for use as string keys in json_build_object().
+ * Doubles single quotes per SQL quoting rules.
+ */
+function escSingleQuote(s) {
+    return s.replace(/'/g, "''");
+}
 /**
  * Escape LIKE pattern metacharacters: %, _, and \.
  * Must be used with `ESCAPE '\'` in the LIKE clause.
@@ -36,7 +43,7 @@ function escapeLike(value) {
 /** Known operator keys — used to detect operator objects vs plain values */
 const OPERATOR_KEYS = new Set([
     'gt', 'gte', 'lt', 'lte', 'not', 'in', 'notIn',
-    'contains', 'startsWith', 'endsWith',
+    'contains', 'startsWith', 'endsWith', 'mode',
 ]);
 /** Check if a value is a where operator object (has at least one known operator key) */
 function isWhereOperator(value) {
@@ -66,18 +73,57 @@ function isArrayFilter(value) {
     const keys = Object.keys(value);
     return keys.length > 0 && keys.some((k) => ARRAY_OPERATOR_KEYS.has(k));
 }
+// ---------------------------------------------------------------------------
+// LRU cache — bounded SQL template cache to prevent memory leaks
+// ---------------------------------------------------------------------------
+/**
+ * Simple LRU (Least Recently Used) cache with a fixed maximum size.
+ * When the cache exceeds maxSize, the oldest (least recently used) entry is evicted.
+ * Uses Map insertion order for O(1) eviction.
+ */
+class LRUCache {
+    maxSize;
+    cache = new Map();
+    constructor(maxSize) {
+        this.maxSize = maxSize;
+    }
+    get(key) {
+        const value = this.cache.get(key);
+        if (value !== undefined) {
+            // Move to end (most recently used)
+            this.cache.delete(key);
+            this.cache.set(key, value);
+        }
+        return value;
+    }
+    set(key, value) {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        else if (this.cache.size >= this.maxSize) {
+            // Delete oldest (first) entry
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined)
+                this.cache.delete(firstKey);
+        }
+        this.cache.set(key, value);
+    }
+    get size() { return this.cache.size; }
+}
 export class QueryInterface {
     pool;
     table;
     schema;
     tableMeta;
     /** SQL template cache: cacheKey → sql string (params are always positional $1,$2,...) */
-    sqlCache = new Map();
+    sqlCache = new LRUCache(1000);
     middlewares;
-    // Fast path: pre-computed flag — true when this table has zero date/timestamp columns.
-    // When true, parseRow can skip the per-field dateCols.has() check entirely.
-    hasNoDateColumns;
-    constructor(pool, table, schema, middlewares) {
+    defaultLimit;
+    warnOnUnlimited;
+    /** Pre-computed column type lookups (avoids linear scans per query) */
+    columnPgTypeMap;
+    columnArrayTypeMap;
+    constructor(pool, table, schema, middlewares, options) {
         this.pool = pool;
         this.table = table;
         this.schema = schema;
@@ -87,11 +133,43 @@ export class QueryInterface {
         }
         this.tableMeta = meta;
         this.middlewares = middlewares ?? [];
-        this.hasNoDateColumns = meta.dateColumns.size === 0;
+        this.defaultLimit = options?.defaultLimit;
+        this.warnOnUnlimited = options?.warnOnUnlimited ?? false;
+        // Pre-compute column type lookup maps (TASK-26)
+        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);
+        }
+    }
+    /**
+     * Execute a pool.query with an optional timeout.
+     * If timeout is set, races the query against a timer and rejects on expiry.
+     */
+    async queryWithTimeout(sql, params, timeout) {
+        if (!timeout) {
+            return this.pool.query(sql, params);
+        }
+        let timer;
+        const timeoutPromise = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`[turbine] Query timed out after ${timeout}ms`)), timeout);
+        });
+        try {
+            return await Promise.race([this.pool.query(sql, params), timeoutPromise]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
     }
     /**
      * Execute a query through the middleware chain.
      * If no middlewares are registered, executes directly.
+     *
+     * Middleware can inspect and log query parameters, modify results after execution,
+     * and measure timing. Note: query SQL is generated before middleware runs, so
+     * modifying params.args in middleware will NOT affect the executed SQL.
+     * To intercept queries before SQL generation, use the raw() method instead.
      */
     async executeWithMiddleware(action, args, executor) {
         if (this.middlewares.length === 0) {
@@ -128,7 +206,7 @@ export class QueryInterface {
     async findUnique(args) {
         return this.executeWithMiddleware('findUnique', args, async () => {
             const deferred = this.buildFindUnique(args);
-            const result = await this.pool.query(deferred.sql, deferred.params);
+            const result = await this.queryWithTimeout(deferred.sql, deferred.params, args.timeout);
             return deferred.transform(result);
         });
     }
@@ -137,15 +215,11 @@ export class QueryInterface {
         const whereObj = args.where;
         // Check if all where values are simple (plain equality, no operators/null/OR)
         const whereKeys = Object.keys(whereObj).filter((k) => whereObj[k] !== undefined);
-        const isSimpleWhere = !whereObj['OR'] && !whereObj['AND'] && !whereObj['NOT'] && whereKeys.every((k) => {
+        const isSimpleWhere = !whereObj['OR'] && whereKeys.every((k) => {
             const v = whereObj[k];
-            return v !== null && !isWhereOperator(v) && !isJsonFilter(v) && !isArrayFilter(v);
+            return v !== null && !isWhereOperator(v);
         });
-        // -----------------------------------------------------------------------
-        // Fast path: no relations, simple equality where — cache SQL template.
-        // Generates: SELECT col1, col2 FROM "table" WHERE "id" = $1 LIMIT 1
-        // No json_build_object, no subqueries, no COALESCE wrappers.
-        // -----------------------------------------------------------------------
+        // For simple queries (no nested with, no operators), use cached SQL template
         if (!args.with && isSimpleWhere) {
             const colKey = columnsList ? columnsList.join(',') : '*';
             const ck = `fu:${whereKeys.sort().join(',')}:c=${colKey}`;
@@ -161,23 +235,18 @@ export class QueryInterface {
                 sql = `SELECT ${selectExpr} FROM ${qt}${whereSql} LIMIT 1`;
                 this.sqlCache.set(ck, sql);
             }
-            // Fast path: skip date coercion when table has no date columns
-            const transformRow = this.hasNoDateColumns
-                ? (row) => this.parseRowFast(row)
-                : (row) => this.parseRow(row, this.table);
             return {
                 sql,
                 params,
                 transform: (result) => {
                     const row = result.rows[0];
-                    return row ? transformRow(row) : null;
+                    return row ? this.parseRow(row, this.table) : null;
                 },
                 tag: `${this.table}.findUnique`,
             };
         }
         // General path: supports operators, null, OR, nested with
         const { sql: whereSql, params } = this.buildWhere(args.where);
-        // Fast path: no relations, skip json_agg (but where has operators/null/OR)
         if (!args.with) {
             const qt = quoteIdent(this.table);
             const selectExpr = columnsList
@@ -211,85 +280,23 @@ export class QueryInterface {
     // findMany
     // -------------------------------------------------------------------------
     async findMany(args) {
+        // Warn if no limit specified and warnOnUnlimited is enabled
+        const hasExplicitLimit = args?.limit !== undefined || args?.take !== undefined;
+        if (this.warnOnUnlimited && !hasExplicitLimit) {
+            console.warn(`[turbine] findMany() called without limit on table "${this.table}". Set defaultLimit in config to prevent unbounded queries.`);
+        }
         return this.executeWithMiddleware('findMany', (args ?? {}), async () => {
             const deferred = this.buildFindMany(args);
-            const result = await this.pool.query(deferred.sql, deferred.params);
+            const result = await this.queryWithTimeout(deferred.sql, deferred.params, args?.timeout);
             return deferred.transform(result);
         });
     }
     buildFindMany(args) {
-        const columnsList = this.resolveColumns(args?.select, args?.omit);
-        const qt = quoteIdent(this.table);
-        const hasWith = !!(args?.with);
-        // -----------------------------------------------------------------------
-        // Fast path: no relations, no cursor, no distinct — cache SQL template
-        // Skip json_agg subquery machinery entirely for simple table scans.
-        // -----------------------------------------------------------------------
-        if (!hasWith && !args?.cursor && !args?.distinct) {
-            const whereObj = args?.where;
-            const whereKeys = whereObj
-                ? Object.keys(whereObj).filter((k) => whereObj[k] !== undefined)
-                : [];
-            // Check if all where values are simple equality (no operators, null, OR/AND/NOT)
-            const isSimpleWhere = !whereObj || (!whereObj['OR'] && !whereObj['AND'] && !whereObj['NOT'] && whereKeys.every((k) => {
-                const v = whereObj[k];
-                return v !== null && !isWhereOperator(v) && !isJsonFilter(v) && !isArrayFilter(v);
-            }));
-            if (isSimpleWhere) {
-                // Build cache key: operation + where keys + columns + orderBy + hasLimit + hasOffset
-                const colKey = columnsList ? columnsList.join(',') : '*';
-                const orderKey = args?.orderBy ? Object.entries(args.orderBy).map(([k, d]) => `${k}:${d}`).join(',') : '';
-                const hasLimit = args?.limit !== undefined || args?.take !== undefined;
-                const hasOffset = args?.offset !== undefined;
-                const ck = `fm:${whereKeys.sort().join(',')}:c=${colKey}:o=${orderKey}:l=${hasLimit ? '1' : '0'}:off=${hasOffset ? '1' : '0'}`;
-                let sql = this.sqlCache.get(ck);
-                const params = whereKeys.map((k) => whereObj[k]);
-                if (!sql) {
-                    // Build SQL template once and cache it
-                    const selectExpr = columnsList
-                        ? columnsList.map((c) => `${qt}.${quoteIdent(c)}`).join(', ')
-                        : `${qt}.*`;
-                    const whereClauses = whereKeys.map((k, i) => `${this.toSqlColumn(k)} = $${i + 1}`);
-                    const whereSql = whereClauses.length > 0 ? ` WHERE ${whereClauses.join(' AND ')}` : '';
-                    sql = `SELECT ${selectExpr} FROM ${qt}${whereSql}`;
-                    if (args?.orderBy) {
-                        sql += ` ORDER BY ${this.buildOrderBy(args.orderBy)}`;
-                    }
-                    // Placeholders for LIMIT/OFFSET — positions are stable since where params come first
-                    if (hasLimit) {
-                        sql += ` LIMIT $${params.length + 1}`;
-                    }
-                    if (hasOffset) {
-                        sql += ` OFFSET $${params.length + (hasLimit ? 2 : 1)}`;
-                    }
-                    this.sqlCache.set(ck, sql);
-                }
-                // Append runtime param values for LIMIT and OFFSET
-                const effectiveLimit = args?.take ?? args?.limit;
-                if (effectiveLimit !== undefined) {
-                    params.push(Number(effectiveLimit));
-                }
-                if (args?.offset !== undefined) {
-                    params.push(Number(args.offset));
-                }
-                // Fast path: no relations, use parseRow (or parseRowFast when no date columns)
-                const parseRow = this.hasNoDateColumns
-                    ? (row) => this.parseRowFast(row)
-                    : (row) => this.parseRow(row, this.table);
-                return {
-                    sql,
-                    params,
-                    transform: (result) => result.rows.map(parseRow),
-                    tag: `${this.table}.findMany`,
-                };
-            }
-        }
-        // -----------------------------------------------------------------------
-        // General path: supports operators, null, OR, cursor, distinct, nested with
-        // -----------------------------------------------------------------------
         const { sql: whereSql, params } = args?.where
             ? this.buildWhere(args.where)
             : { sql: '', params: [] };
+        const columnsList = this.resolveColumns(args?.select, args?.omit);
+        const qt = quoteIdent(this.table);
         // Distinct support
         let distinctPrefix = '';
         if (args?.distinct && args.distinct.length > 0) {
@@ -297,7 +304,7 @@ export class QueryInterface {
             distinctPrefix = `DISTINCT ON (${distinctCols.join(', ')}) `;
         }
         let selectClause;
-        if (hasWith) {
+        if (args?.with) {
             selectClause = this.buildSelectWithRelations(this.table, args.with, params, columnsList);
         }
         else if (columnsList) {
@@ -331,8 +338,8 @@ export class QueryInterface {
         if (args?.orderBy) {
             sql += ` ORDER BY ${this.buildOrderBy(args.orderBy)}`;
         }
-        // take overrides limit when cursor pagination is used
-        const effectiveLimit = args?.take ?? args?.limit;
+        // take overrides limit when cursor pagination is used; fall back to defaultLimit
+        const effectiveLimit = args?.take ?? args?.limit ?? this.defaultLimit;
         if (effectiveLimit !== undefined) {
             params.push(Number(effectiveLimit));
             sql += ` LIMIT $${params.length}`;
@@ -344,7 +351,7 @@ export class QueryInterface {
         return {
             sql,
             params,
-            transform: (result) => result.rows.map((row) => hasWith
+            transform: (result) => result.rows.map((row) => args?.with
                 ? this.parseNestedRow(row, this.table)
                 : this.parseRow(row, this.table)),
             tag: `${this.table}.findMany`,
@@ -356,7 +363,7 @@ export class QueryInterface {
     async findFirst(args) {
         return this.executeWithMiddleware('findFirst', (args ?? {}), async () => {
             const deferred = this.buildFindFirst(args);
-            const result = await this.pool.query(deferred.sql, deferred.params);
+            const result = await this.queryWithTimeout(deferred.sql, deferred.params, args?.timeout);
             return deferred.transform(result);
         });
     }
@@ -380,7 +387,7 @@ export class QueryInterface {
     async findFirstOrThrow(args) {
         return this.executeWithMiddleware('findFirstOrThrow', (args ?? {}), async () => {
             const deferred = this.buildFindFirstOrThrow(args);
-            const result = await this.pool.query(deferred.sql, deferred.params);
+            const result = await this.queryWithTimeout(deferred.sql, deferred.params, args?.timeout);
             return deferred.transform(result);
         });
     }
@@ -405,7 +412,7 @@ export class QueryInterface {
     async findUniqueOrThrow(args) {
         return this.executeWithMiddleware('findUniqueOrThrow', args, async () => {
             const deferred = this.buildFindUniqueOrThrow(args);
-            const result = await this.pool.query(deferred.sql, deferred.params);
+            const result = await this.queryWithTimeout(deferred.sql, deferred.params, args.timeout);
             return deferred.transform(result);
         });
     }
@@ -430,7 +437,7 @@ export class QueryInterface {
     async create(args) {
         return this.executeWithMiddleware('create', args, async () => {
             const deferred = this.buildCreate(args);
-            const result = await this.pool.query(deferred.sql, deferred.params);
+            const result = await this.queryWithTimeout(deferred.sql, deferred.params, args.timeout);
             return deferred.transform(result);
         });
     }
@@ -458,7 +465,7 @@ export class QueryInterface {
     async createMany(args) {
         return this.executeWithMiddleware('createMany', args, async () => {
             const deferred = this.buildCreateMany(args);
-            const result = await this.pool.query(deferred.sql, deferred.params);
+            const result = await this.queryWithTimeout(deferred.sql, deferred.params, args.timeout);
             return deferred.transform(result);
         });
     }
@@ -505,7 +512,7 @@ export class QueryInterface {
     async update(args) {
         return this.executeWithMiddleware('update', args, async () => {
             const deferred = this.buildUpdate(args);
-            const result = await this.pool.query(deferred.sql, deferred.params);
+            const result = await this.queryWithTimeout(deferred.sql, deferred.params, args.timeout);
             return deferred.transform(result);
         });
     }
@@ -539,7 +546,7 @@ export class QueryInterface {
     async delete(args) {
         return this.executeWithMiddleware('delete', args, async () => {
             const deferred = this.buildDelete(args);
-            const result = await this.pool.query(deferred.sql, deferred.params);
+            const result = await this.queryWithTimeout(deferred.sql, deferred.params, args.timeout);
             return deferred.transform(result);
         });
     }
@@ -564,7 +571,7 @@ export class QueryInterface {
     async upsert(args) {
         return this.executeWithMiddleware('upsert', args, async () => {
             const deferred = this.buildUpsert(args);
-            const result = await this.pool.query(deferred.sql, deferred.params);
+            const result = await this.queryWithTimeout(deferred.sql, deferred.params, args.timeout);
             return deferred.transform(result);
         });
     }
@@ -608,7 +615,7 @@ export class QueryInterface {
     async updateMany(args) {
         return this.executeWithMiddleware('updateMany', args, async () => {
             const deferred = this.buildUpdateMany(args);
-            const result = await this.pool.query(deferred.sql, deferred.params);
+            const result = await this.queryWithTimeout(deferred.sql, deferred.params, args.timeout);
             return deferred.transform(result);
         });
     }
@@ -637,7 +644,7 @@ export class QueryInterface {
     async deleteMany(args) {
         return this.executeWithMiddleware('deleteMany', args, async () => {
             const deferred = this.buildDeleteMany(args);
-            const result = await this.pool.query(deferred.sql, deferred.params);
+            const result = await this.queryWithTimeout(deferred.sql, deferred.params, args.timeout);
             return deferred.transform(result);
         });
     }
@@ -657,7 +664,7 @@ export class QueryInterface {
     async count(args) {
         return this.executeWithMiddleware('count', (args ?? {}), async () => {
             const deferred = this.buildCount(args);
-            const result = await this.pool.query(deferred.sql, deferred.params);
+            const result = await this.queryWithTimeout(deferred.sql, deferred.params, args?.timeout);
             return deferred.transform(result);
         });
     }
@@ -679,7 +686,7 @@ export class QueryInterface {
     async groupBy(args) {
         return this.executeWithMiddleware('groupBy', args, async () => {
             const deferred = this.buildGroupBy(args);
-            const result = await this.pool.query(deferred.sql, deferred.params);
+            const result = await this.queryWithTimeout(deferred.sql, deferred.params, args.timeout);
             return deferred.transform(result);
         });
     }
@@ -806,7 +813,7 @@ export class QueryInterface {
     async aggregate(args) {
         return this.executeWithMiddleware('aggregate', args, async () => {
             const deferred = this.buildAggregate(args);
-            const result = await this.pool.query(deferred.sql, deferred.params);
+            const result = await this.queryWithTimeout(deferred.sql, deferred.params, args.timeout);
             return deferred.transform(result);
         });
     }
@@ -1197,17 +1204,19 @@ export class QueryInterface {
             params.push(op.notIn);
             clauses.push(`${column} != ALL($${params.length})`);
         }
+        // Use ILIKE for case-insensitive mode, LIKE otherwise
+        const likeOp = op.mode === 'insensitive' ? 'ILIKE' : 'LIKE';
         if (op.contains !== undefined) {
             params.push(`%${escapeLike(op.contains)}%`);
-            clauses.push(`${column} LIKE $${params.length} ESCAPE '\\'`);
+            clauses.push(`${column} ${likeOp} $${params.length} ESCAPE '\\'`);
         }
         if (op.startsWith !== undefined) {
             params.push(`${escapeLike(op.startsWith)}%`);
-            clauses.push(`${column} LIKE $${params.length} ESCAPE '\\'`);
+            clauses.push(`${column} ${likeOp} $${params.length} ESCAPE '\\'`);
         }
         if (op.endsWith !== undefined) {
             params.push(`%${escapeLike(op.endsWith)}`);
-            clauses.push(`${column} LIKE $${params.length} ESCAPE '\\'`);
+            clauses.push(`${column} ${likeOp} $${params.length} ESCAPE '\\'`);
         }
         return clauses;
     }
@@ -1249,22 +1258,6 @@ export class QueryInterface {
         }
         return parsed;
     }
-    /**
-     * Fast path: parse a flat row when the table has NO date columns.
-     * Only renames snake_case -> camelCase via the pre-computed reverseMap.
-     * Skips all date coercion checks — avoids Set.has() per field per row.
-     * Used by findUnique/findMany fast paths when hasNoDateColumns is true.
-     */
-    parseRowFast(row) {
-        const parsed = {};
-        const reverseMap = this.tableMeta.reverseColumnMap;
-        const keys = Object.keys(row);
-        for (let i = 0; i < keys.length; i++) {
-            const col = keys[i];
-            parsed[reverseMap[col] ?? col] = row[col];
-        }
-        return parsed;
-    }
     /** Parse a row that may contain JSON nested relation columns */
     parseNestedRow(row, table) {
         const parsed = this.parseRow(row, table);
@@ -1361,7 +1354,7 @@ export class QueryInterface {
             targetColumns = targetMeta.allColumns.filter((col) => !omittedFields.has(col));
         }
         // Build json_build_object pairs for resolved columns
-        const jsonPairs = targetColumns.map((col) => `'${targetMeta.reverseColumnMap[col] ?? snakeToCamel(col)}', ${alias}.${quoteIdent(col)}`);
+        const jsonPairs = targetColumns.map((col) => `'${escSingleQuote(targetMeta.reverseColumnMap[col] ?? snakeToCamel(col))}', ${alias}.${quoteIdent(col)}`);
         // Nested relations?
         if (spec !== true && spec.with) {
             for (const [nestedRelName, nestedSpec] of Object.entries(spec.with)) {
@@ -1372,7 +1365,7 @@ export class QueryInterface {
                 }
                 // Recursively build nested subquery, passing THIS alias as the parent reference
                 const nestedSubquery = this.buildRelationSubquery(nestedRelDef, nestedSpec, params, alias, aliasCounter);
-                jsonPairs.push(`'${nestedRelName}', COALESCE((${nestedSubquery}), '[]'::json)`);
+                jsonPairs.push(`'${escSingleQuote(nestedRelName)}', COALESCE((${nestedSubquery}), '[]'::json)`);
             }
         }
         const jsonObj = `json_build_object(${jsonPairs.join(', ')})`;
@@ -1430,14 +1423,14 @@ export class QueryInterface {
                 // Inner SELECT always needs all columns for WHERE/ORDER to work; json_build_object filters later
                 const innerSql = `SELECT ${targetMeta.allColumns.map((c) => `${alias}.${quoteIdent(c)}`).join(', ')} FROM ${qTarget} ${alias} WHERE ${whereClause}${orderClause}${limitClause}`;
                 // For the json_build_object, reference the inner alias — only include resolved columns
-                const innerJsonPairs = targetColumns.map((col) => `'${targetMeta.reverseColumnMap[col] ?? snakeToCamel(col)}', ${innerAlias}.${quoteIdent(col)}`);
+                const innerJsonPairs = targetColumns.map((col) => `'${escSingleQuote(targetMeta.reverseColumnMap[col] ?? snakeToCamel(col))}', ${innerAlias}.${quoteIdent(col)}`);
                 // Re-add nested relation subqueries referencing innerAlias
                 if (spec !== true && spec.with) {
                     for (const [nestedRelName] of Object.entries(spec.with)) {
                         const nestedRelDef = targetMeta.relations[nestedRelName];
                         if (nestedRelDef) {
                             const nestedSub = this.buildRelationSubquery(nestedRelDef, spec.with[nestedRelName], params, innerAlias, aliasCounter);
-                            innerJsonPairs.push(`'${nestedRelName}', COALESCE((${nestedSub}), '[]'::json)`);
+                            innerJsonPairs.push(`'${escSingleQuote(nestedRelName)}', COALESCE((${nestedSub}), '[]'::json)`);
                         }
                     }
                 }
@@ -1452,10 +1445,10 @@ export class QueryInterface {
     /**
      * Get the Postgres type for a column (e.g. 'jsonb', 'text', '_int4').
      * Used to detect JSONB/array columns for specialized operators.
+     * Uses pre-computed Map for O(1) lookup instead of linear scan.
      */
     getColumnPgType(column) {
-        const col = this.tableMeta.columns.find((c) => c.name === column);
-        return col?.pgType ?? 'text';
+        return this.columnPgTypeMap.get(column) ?? 'text';
     }
     /**
      * Get the Postgres base element type for an array column.
@@ -1542,13 +1535,15 @@ export class QueryInterface {
         }
         return clauses;
     }
-    /** Get the Postgres array type for a column (used by UNNEST in createMany) */
+    /**
+     * Get the Postgres array type for a column (used by UNNEST in createMany).
+     * Uses pre-computed Map for O(1) lookup instead of linear scan.
+     */
     getColumnArrayType(column) {
-        // Find the column metadata
-        const col = this.tableMeta.columns.find((c) => c.name === column);
-        if (col)
-            return col.pgArrayType;
-        // Fallback heuristic
+        const arrayType = this.columnArrayTypeMap.get(column);
+        if (arrayType)
+            return arrayType;
+        // Fallback heuristic for unknown columns
         if (column === 'id' || column.endsWith('_id'))
             return 'bigint[]';
         if (column.endsWith('_at'))

package/dist/schema-builder.d.ts

@@ -1,5 +1,5 @@
 /**
- * turbine-orm — Schema Builder
+ * @batadata/turbine — Schema Builder
  *
  * TypeScript-first schema definition API. Define your database schema
  * as plain objects — no method chaining, no DSL. Fully type-checked,
@@ -7,7 +7,7 @@
  *
  * @example
  * ```ts
- * import { defineSchema } from 'turbine-orm';
+ * import { defineSchema } from '@batadata/turbine';
  *
  * export default defineSchema({
  *   users: {

package/dist/schema-builder.js

@@ -1,5 +1,5 @@
 /**
- * turbine-orm — Schema Builder
+ * @batadata/turbine — Schema Builder
  *
  * TypeScript-first schema definition API. Define your database schema
  * as plain objects — no method chaining, no DSL. Fully type-checked,
@@ -7,7 +7,7 @@
  *
  * @example
  * ```ts
- * import { defineSchema } from 'turbine-orm';
+ * import { defineSchema } from '@batadata/turbine';
  *
  * export default defineSchema({
  *   users: {

package/dist/schema-sql.d.ts

@@ -1,5 +1,5 @@
 /**
- * turbine-orm — Schema SQL Generator
+ * @batadata/turbine — Schema SQL Generator
  *
  * Converts a SchemaDef (from defineSchema) into executable DDL statements.
  * Also provides diff and push commands for syncing schema to a live database.