turbine-orm 0.9.0 → 0.9.2

package/dist/cjs/query/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * turbine-orm — Query builder barrel
+ *
+ * Re-exports every public symbol from the query submodules so that
+ * `import { … } from './query/index.js'` is a drop-in replacement for the
+ * former monolithic `import { … } from './query.js'`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryInterface = exports.sqlToPreparedName = exports.quoteIdent = exports.OPERATOR_KEYS = exports.LRUCache = exports.fnv1a64Hex = exports.escSingleQuote = exports.escapeLike = void 0;
+var utils_js_1 = require("./utils.js");
+Object.defineProperty(exports, "escapeLike", { enumerable: true, get: function () { return utils_js_1.escapeLike; } });
+Object.defineProperty(exports, "escSingleQuote", { enumerable: true, get: function () { return utils_js_1.escSingleQuote; } });
+Object.defineProperty(exports, "fnv1a64Hex", { enumerable: true, get: function () { return utils_js_1.fnv1a64Hex; } });
+Object.defineProperty(exports, "LRUCache", { enumerable: true, get: function () { return utils_js_1.LRUCache; } });
+Object.defineProperty(exports, "OPERATOR_KEYS", { enumerable: true, get: function () { return utils_js_1.OPERATOR_KEYS; } });
+Object.defineProperty(exports, "quoteIdent", { enumerable: true, get: function () { return utils_js_1.quoteIdent; } });
+Object.defineProperty(exports, "sqlToPreparedName", { enumerable: true, get: function () { return utils_js_1.sqlToPreparedName; } });
+var builder_js_1 = require("./builder.js");
+Object.defineProperty(exports, "QueryInterface", { enumerable: true, get: function () { return builder_js_1.QueryInterface; } });

package/dist/cjs/query/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * turbine-orm — Query builder types
+ *
+ * All exported type and interface definitions for the query builder module.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/query/utils.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * turbine-orm — Query builder utilities
+ *
+ * Standalone utility functions and classes used by the query builder.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPERATOR_KEYS = exports.LRUCache = void 0;
+exports.quoteIdent = quoteIdent;
+exports.escSingleQuote = escSingleQuote;
+exports.escapeLike = escapeLike;
+exports.fnv1a64Hex = fnv1a64Hex;
+exports.sqlToPreparedName = sqlToPreparedName;
+// ---------------------------------------------------------------------------
+// Identifier quoting — prevents SQL injection via table/column names
+// ---------------------------------------------------------------------------
+/**
+ * Quote a SQL identifier (table name, column name) using Postgres double-quote
+ * rules: wrap in double quotes, escape internal double quotes by doubling them.
+ *
+ * @example
+ *   quoteIdent('users')       → '"users"'
+ *   quoteIdent('my"table')    → '"my""table"'
+ *   quoteIdent('user name')   → '"user name"'
+ */
+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.
+ */
+function escapeLike(value) {
+    return value.replace(/\\/g, '\\\\').replace(/%/g, '\\%').replace(/_/g, '\\_');
+}
+// ---------------------------------------------------------------------------
+// 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;
+    }
+}
+exports.LRUCache = LRUCache;
+/**
+ * FNV-1a 64-bit hash returning 16 lowercase hex chars.
+ * Single-loop string iteration. Uses BigInt for 64-bit math.
+ *
+ * @internal Exported for testing only.
+ */
+function fnv1a64Hex(s) {
+    // FNV-1a offset basis and prime for 64-bit
+    let hash = 0xcbf29ce484222325n;
+    const prime = 0x100000001b3n;
+    const mask = 0xffffffffffffffffn; // 64-bit mask
+    for (let i = 0; i < s.length; i++) {
+        hash ^= BigInt(s.charCodeAt(i));
+        hash = (hash * prime) & mask;
+    }
+    return hash.toString(16).padStart(16, '0');
+}
+/**
+ * Derive a prepared-statement name from a SQL string.
+ * Format: `t_<16hex>` — always 18 chars, well under NAMEDATALEN (63).
+ *
+ * @internal Exported for testing only.
+ */
+function sqlToPreparedName(sql) {
+    return `t_${fnv1a64Hex(sql)}`;
+}
+/** Known operator keys — used to detect operator objects vs plain values */
+exports.OPERATOR_KEYS = new Set([
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'not',
+    'in',
+    'notIn',
+    'contains',
+    'startsWith',
+    'endsWith',
+    'mode',
+]);

package/dist/cjs/schema-sql.js

@@ -14,7 +14,7 @@ exports.schemaDiff = schemaDiff;
 exports.schemaPush = schemaPush;
 exports.schemaToSQLString = schemaToSQLString;
 const pg_1 = __importDefault(require("pg"));
-const query_js_1 = require("./query.js");
+const index_js_1 = require("./query/index.js");
 const schema_js_1 = require("./schema.js");
 // ---------------------------------------------------------------------------
 // SQL Generation — SchemaDef → CREATE TABLE statements
@@ -143,18 +143,18 @@ function generateCreateTable(table, resolveRef) {
     }
     // Append a table-level PRIMARY KEY constraint when a composite PK is set.
     if (compositePk) {
-        const cols = compositePk.map((c) => (0, query_js_1.quoteIdent)((0, schema_js_1.camelToSnake)(c))).join(', ');
+        const cols = compositePk.map((c) => (0, index_js_1.quoteIdent)((0, schema_js_1.camelToSnake)(c))).join(', ');
         columnDefs.push(`PRIMARY KEY (${cols})`);
     }
     const body = columnDefs.map((d) => `    ${d}`).join(',\n');
-    return `CREATE TABLE ${(0, query_js_1.quoteIdent)(tableName)} (\n${body}\n);`;
+    return `CREATE TABLE ${(0, index_js_1.quoteIdent)(tableName)} (\n${body}\n);`;
 }
 /**
  * Generate a single column definition line (e.g. "id BIGSERIAL PRIMARY KEY").
  */
 function generateColumnDef(fieldName, config, resolveRef) {
     const snakeName = (0, schema_js_1.camelToSnake)(fieldName);
-    const parts = [(0, query_js_1.quoteIdent)(snakeName)];
+    const parts = [(0, index_js_1.quoteIdent)(snakeName)];
     // Type
     if (config.type === 'VARCHAR' && config.maxLength != null) {
         parts.push(`VARCHAR(${config.maxLength})`);
@@ -193,7 +193,7 @@ function generateColumnDef(fieldName, config, resolveRef) {
         if (refParts.length === 2) {
             const rawTable = refParts[0];
             const refTable = resolveRef ? resolveRef(rawTable) : rawTable;
-            parts.push(`REFERENCES ${(0, query_js_1.quoteIdent)(refTable)}(${(0, query_js_1.quoteIdent)(refParts[1])})`);
+            parts.push(`REFERENCES ${(0, index_js_1.quoteIdent)(refTable)}(${(0, index_js_1.quoteIdent)(refParts[1])})`);
         }
     }
     return parts.join(' ');
@@ -242,7 +242,7 @@ function generateForeignKeyIndexes(table) {
         if (config.referencesTarget) {
             const snakeName = (0, schema_js_1.camelToSnake)(fieldName);
             const indexName = `idx_${table.name}_${snakeName}`;
-            indexes.push(`CREATE INDEX ${(0, query_js_1.quoteIdent)(indexName)} ON ${(0, query_js_1.quoteIdent)(table.name)}(${(0, query_js_1.quoteIdent)(snakeName)});`);
+            indexes.push(`CREATE INDEX ${(0, index_js_1.quoteIdent)(indexName)} ON ${(0, index_js_1.quoteIdent)(table.name)}(${(0, index_js_1.quoteIdent)(snakeName)});`);
         }
     }
     return indexes;
@@ -317,7 +317,7 @@ async function schemaDiff(schema, connectionString) {
                 const fkIndexes = generateForeignKeyIndexes(tableDef);
                 result.statements.push(...fkIndexes);
                 // Reverse: DROP TABLE (with indexes — they drop automatically)
-                result.reverseStatements.unshift(`DROP TABLE IF EXISTS ${(0, query_js_1.quoteIdent)(ddlName)} CASCADE;`);
+                result.reverseStatements.unshift(`DROP TABLE IF EXISTS ${(0, index_js_1.quoteIdent)(ddlName)} CASCADE;`);
             }
         }
         // Tables to drop (in DB but not in schema)
@@ -342,8 +342,8 @@ async function schemaDiff(schema, connectionString) {
                 if (!dbCol) {
                     // Column exists in schema but not in DB — ADD COLUMN
                     const colDef = generateColumnDef(fieldName, config, resolveRef);
-                    const sql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ADD COLUMN ${colDef};`;
-                    const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} DROP COLUMN ${(0, query_js_1.quoteIdent)(snakeName)};`;
+                    const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ADD COLUMN ${colDef};`;
+                    const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} DROP COLUMN ${(0, index_js_1.quoteIdent)(snakeName)};`;
                     alterDef.columns.push({ column: snakeName, action: 'add', sql, reverseSql });
                     result.statements.push(sql);
                     result.reverseStatements.unshift(reverseSql);
@@ -354,8 +354,8 @@ async function schemaDiff(schema, connectionString) {
                 if (expectedUdt && dbCol.udtName !== expectedUdt) {
                     const sqlType = config.type === 'VARCHAR' && config.maxLength ? `VARCHAR(${config.maxLength})` : config.type;
                     const oldSqlType = udtToSqlType(dbCol.udtName, dbCol.maxLength);
-                    const sql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} TYPE ${sqlType} USING ${(0, query_js_1.quoteIdent)(snakeName)}::${sqlType};`;
-                    const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} TYPE ${oldSqlType} USING ${(0, query_js_1.quoteIdent)(snakeName)}::${oldSqlType};`;
+                    const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} TYPE ${sqlType} USING ${(0, index_js_1.quoteIdent)(snakeName)}::${sqlType};`;
+                    const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} TYPE ${oldSqlType} USING ${(0, index_js_1.quoteIdent)(snakeName)}::${oldSqlType};`;
                     alterDef.columns.push({ column: snakeName, action: 'alter_type', sql, reverseSql });
                     result.statements.push(sql);
                     result.reverseStatements.unshift(reverseSql);
@@ -364,15 +364,15 @@ async function schemaDiff(schema, connectionString) {
                 const shouldBeNotNull = config.isNotNull || config.isPrimaryKey || config.type === 'BIGSERIAL';
                 const isCurrentlyNullable = dbCol.isNullable;
                 if (shouldBeNotNull && isCurrentlyNullable && !config.isNullable) {
-                    const sql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} SET NOT NULL;`;
-                    const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} DROP NOT NULL;`;
+                    const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} SET NOT NULL;`;
+                    const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} DROP NOT NULL;`;
                     alterDef.columns.push({ column: snakeName, action: 'set_not_null', sql, reverseSql });
                     result.statements.push(sql);
                     result.reverseStatements.unshift(reverseSql);
                 }
                 else if (!shouldBeNotNull && !isCurrentlyNullable && config.isNullable) {
-                    const sql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} DROP NOT NULL;`;
-                    const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} SET NOT NULL;`;
+                    const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} DROP NOT NULL;`;
+                    const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} SET NOT NULL;`;
                     alterDef.columns.push({ column: snakeName, action: 'drop_not_null', sql, reverseSql });
                     result.statements.push(sql);
                     result.reverseStatements.unshift(reverseSql);
@@ -384,16 +384,16 @@ async function schemaDiff(schema, connectionString) {
                     const dbDefault = dbCol.columnDefault;
                     if (schemaDefault && !dbDefault) {
                         // Schema has default, DB doesn't
-                        const sql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} SET DEFAULT ${schemaDefault};`;
-                        const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} DROP DEFAULT;`;
+                        const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} SET DEFAULT ${schemaDefault};`;
+                        const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} DROP DEFAULT;`;
                         alterDef.columns.push({ column: snakeName, action: 'set_default', sql, reverseSql });
                         result.statements.push(sql);
                         result.reverseStatements.unshift(reverseSql);
                     }
                     else if (!schemaDefault && dbDefault && !isSequenceDefault(dbDefault)) {
                         // DB has a non-sequence default, schema doesn't
-                        const sql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} DROP DEFAULT;`;
-                        const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} SET DEFAULT ${dbDefault};`;
+                        const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} DROP DEFAULT;`;
+                        const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} SET DEFAULT ${dbDefault};`;
                         alterDef.columns.push({ column: snakeName, action: 'drop_default', sql, reverseSql });
                         result.statements.push(sql);
                         result.reverseStatements.unshift(reverseSql);
@@ -403,8 +403,8 @@ async function schemaDiff(schema, connectionString) {
                         !isSequenceDefault(dbDefault) &&
                         !defaultsMatch(schemaDefault, dbDefault)) {
                         // Both have defaults but they differ
-                        const sql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} SET DEFAULT ${schemaDefault};`;
-                        const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} SET DEFAULT ${dbDefault};`;
+                        const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} SET DEFAULT ${schemaDefault};`;
+                        const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} SET DEFAULT ${dbDefault};`;
                         alterDef.columns.push({ column: snakeName, action: 'set_default', sql, reverseSql });
                         result.statements.push(sql);
                         result.reverseStatements.unshift(reverseSql);
@@ -416,16 +416,16 @@ async function schemaDiff(schema, connectionString) {
                     const wantsUnique = config.isUnique === true;
                     if (wantsUnique && !hasDbUnique) {
                         const constraintName = `${tableName}_${snakeName}_key`;
-                        const sql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ADD CONSTRAINT ${(0, query_js_1.quoteIdent)(constraintName)} UNIQUE (${(0, query_js_1.quoteIdent)(snakeName)});`;
-                        const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} DROP CONSTRAINT ${(0, query_js_1.quoteIdent)(constraintName)};`;
+                        const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ADD CONSTRAINT ${(0, index_js_1.quoteIdent)(constraintName)} UNIQUE (${(0, index_js_1.quoteIdent)(snakeName)});`;
+                        const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} DROP CONSTRAINT ${(0, index_js_1.quoteIdent)(constraintName)};`;
                         alterDef.columns.push({ column: snakeName, action: 'add_unique', sql, reverseSql });
                         result.statements.push(sql);
                         result.reverseStatements.unshift(reverseSql);
                     }
                     else if (!wantsUnique && hasDbUnique) {
                         const constraintName = tableUniques[snakeName];
-                        const sql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} DROP CONSTRAINT ${(0, query_js_1.quoteIdent)(constraintName)};`;
-                        const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ADD CONSTRAINT ${(0, query_js_1.quoteIdent)(constraintName)} UNIQUE (${(0, query_js_1.quoteIdent)(snakeName)});`;
+                        const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} DROP CONSTRAINT ${(0, index_js_1.quoteIdent)(constraintName)};`;
+                        const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ADD CONSTRAINT ${(0, index_js_1.quoteIdent)(constraintName)} UNIQUE (${(0, index_js_1.quoteIdent)(snakeName)});`;
                         alterDef.columns.push({ column: snakeName, action: 'drop_unique', sql, reverseSql });
                         result.statements.push(sql);
                         result.reverseStatements.unshift(reverseSql);
@@ -436,7 +436,7 @@ async function schemaDiff(schema, connectionString) {
             for (const dbColName of Object.keys(dbCols)) {
                 const hasField = Object.entries(tableDef.columns).some(([fieldName]) => (0, schema_js_1.camelToSnake)(fieldName) === dbColName);
                 if (!hasField) {
-                    const sql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} DROP COLUMN ${(0, query_js_1.quoteIdent)(dbColName)};`;
+                    const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} DROP COLUMN ${(0, index_js_1.quoteIdent)(dbColName)};`;
                     const reverseSql = `-- Cannot auto-reverse DROP COLUMN for "${dbColName}" — add it back manually`;
                     alterDef.columns.push({ column: dbColName, action: 'drop', sql, reverseSql });
                     // Don't auto-add drops to statements for safety — user must opt in

package/dist/cli/migrate.js

@@ -16,7 +16,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from
 import { join } from 'node:path';
 import pg from 'pg';
 import { MigrationError } from '../errors.js';
-import { quoteIdent } from '../query.js';
+import { quoteIdent } from '../query/index.js';
 // ---------------------------------------------------------------------------
 // Tracking table management
 // ---------------------------------------------------------------------------

package/dist/cli/studio.js

@@ -23,7 +23,7 @@ import { platform } from 'node:os';
 import { dirname, resolve as pathResolve } from 'node:path';
 import pg from 'pg';
 import { introspect } from '../introspect.js';
-import { QueryInterface, quoteIdent } from '../query.js';
+import { QueryInterface, quoteIdent } from '../query/index.js';
 import { STUDIO_HTML } from './studio-ui.generated.js';
 // ---------------------------------------------------------------------------
 // Main entry point

package/dist/client.d.ts

@@ -24,7 +24,7 @@
 import pg from 'pg';
 import { type ErrorMessageMode } from './errors.js';
 import { type PipelineOptions, type PipelineResults } from './pipeline.js';
-import { type DeferredQuery, QueryInterface, type QueryInterfaceOptions } from './query.js';
+import { type DeferredQuery, QueryInterface, type QueryInterfaceOptions } from './query/index.js';
 import type { SchemaMetadata } from './schema.js';
 /**
  * Minimal pg-compatible query result.

package/dist/client.js

@@ -24,7 +24,7 @@
 import pg from 'pg';
 import { setErrorMessageMode, TimeoutError, wrapPgError } from './errors.js';
 import { executePipeline, pipelineSupported } from './pipeline.js';
-import { QueryInterface } from './query.js';
+import { QueryInterface } from './query/index.js';
 /** Maps isolation level names to SQL */
 const ISOLATION_LEVELS = {
     ReadUncommitted: 'READ UNCOMMITTED',

package/dist/index.d.ts

@@ -37,7 +37,7 @@ export { CheckConstraintError, CircularRelationError, ConnectionError, DeadlockE
 export { type GenerateOptions, generate } from './generate.js';
 export { type IntrospectOptions, introspect } from './introspect.js';
 export { executePipeline, type PipelineOptions, type PipelineResults, pipelineSupported } from './pipeline.js';
-export { type AggregateArgs, type AggregateResult, type ArrayFilter, type CountArgs, type CreateArgs, type CreateManyArgs, type DeferredQuery, type DeleteArgs, type DeleteManyArgs, type FindManyArgs, type FindManyStreamArgs, type FindUniqueArgs, type GroupByArgs, type JsonFilter, type OrderDirection, QueryInterface, type RelationDescriptor, type RelationFilter, type TypedWithClause, type UpdateArgs, type UpdateInput, type UpdateManyArgs, type UpdateOperatorInput, type UpsertArgs, type WithClause, type WithOptions, type WithResult, } from './query.js';
+export { type AggregateArgs, type AggregateResult, type ArrayFilter, type CountArgs, type CreateArgs, type CreateManyArgs, type DeferredQuery, type DeleteArgs, type DeleteManyArgs, type FindManyArgs, type FindManyStreamArgs, type FindUniqueArgs, type GroupByArgs, type JsonFilter, type OrderDirection, QueryInterface, type RelationDescriptor, type RelationFilter, type TypedWithClause, type UpdateArgs, type UpdateInput, type UpdateManyArgs, type UpdateOperatorInput, type UpsertArgs, type WithClause, type WithOptions, type WithResult, } from './query/index.js';
 export type { ColumnMetadata, IndexMetadata, RelationDef, SchemaMetadata, TableMetadata, } from './schema.js';
 export { camelToSnake, isDateType, pgArrayType, pgTypeToTs, singularize, snakeToCamel, snakeToPascal, } from './schema.js';
 export { ColumnBuilder, type ColumnConfig, type ColumnDef, type ColumnType, type ColumnTypeName, column, defineSchema, type SchemaDef, type TableDef, table, } from './schema-builder.js';

package/dist/index.js

@@ -43,7 +43,7 @@ export { introspect } from './introspect.js';
 // Pipeline
 export { executePipeline, pipelineSupported } from './pipeline.js';
 // Query builder
-export { QueryInterface, } from './query.js';
+export { QueryInterface, } from './query/index.js';
 // Schema utilities
 export { camelToSnake, isDateType, pgArrayType, pgTypeToTs, singularize, snakeToCamel, snakeToPascal, } from './schema.js';
 // Schema builder — define schemas in TypeScript

package/dist/pipeline-submittable.d.ts

@@ -17,7 +17,7 @@
  * to handle N queries in a single pipeline.
  */
 import type { EventEmitter } from 'node:events';
-import type { DeferredQuery } from './query.js';
+import type { DeferredQuery } from './query/index.js';
 /** The pg Connection object — an EventEmitter with wire-protocol methods */
 export interface PgConnection extends EventEmitter {
     stream: {

package/dist/pipeline.d.ts

@@ -19,7 +19,7 @@
  * Hyperdrive), mock pools in tests, and any pool that doesn't expose pg internals.
  */
 import type pg from 'pg';
-import type { DeferredQuery } from './query.js';
+import type { DeferredQuery } from './query/index.js';
 export interface PipelineOptions {
     /**
      * Whether to wrap the pipeline in a transaction (default: true).