metal-orm 1.1.9 → 1.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.1.9",
+  "version": "1.1.11",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {
@@ -40,6 +40,7 @@
     "lint:fix": "node scripts/run-eslint.mjs --fix"
   },
   "peerDependencies": {
+    "better-sqlite3": "^11.0.0",
     "ioredis": "^5.0.0",
     "keyv": "^5.6.0",
     "mysql2": "^3.9.0",
@@ -48,6 +49,9 @@
     "tedious": "^19.0.0"
   },
   "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    },
     "mysql2": {
       "optional": true
     },
@@ -68,24 +72,25 @@
     }
   },
   "devDependencies": {
-    "@electric-sql/pglite": "^0.3.15",
-    "@typescript-eslint/eslint-plugin": "^8.54.0",
-    "@typescript-eslint/parser": "^8.54.0",
-    "@vitest/ui": "^4.0.18",
-    "eslint": "^9.39.2",
+    "@electric-sql/pglite": "^0.4.2",
+    "@typescript-eslint/eslint-plugin": "^8.58.0",
+    "@typescript-eslint/parser": "^8.58.0",
+    "@vitest/ui": "^4.1.2",
+    "better-sqlite3": "^12.8.0",
+    "eslint": "^10.1.0",
     "express": "^5.2.1",
-    "ioredis": "^5.6.1",
-    "ioredis-mock": "^8.9.0",
+    "ioredis": "^5.10.1",
+    "ioredis-mock": "^8.13.1",
     "keyv": "^5.6.0",
     "mysql-memory-server": "^1.14.1",
-    "mysql2": "^3.18.2",
-    "pg": "^8.19.0",
-    "sqlite3": "^5.1.7",
+    "mysql2": "^3.20.0",
+    "pg": "^8.20.0",
+    "sqlite3": "^6.0.1",
     "supertest": "^7.2.2",
     "tedious": "^19.2.1",
     "tsup": "^8.5.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
+    "vitest": "^4.1.2"
   }
 }

package/scripts/generate-entities/render.mjs

@@ -5,15 +5,20 @@ import { buildSchemaMetadata } from './schema.mjs';
 const escapeJsString = value => value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
 
 const sanitizePropertyName = columnName => {
-  if (!columnName) return '';
+  if (typeof columnName !== 'string' || !columnName) return '';
   return columnName
     .replace(/\s+/g, '_')
     .replace(/[^a-zA-Z0-9_$]/g, '_')
     .replace(/^[0-9]/, '_$&');
 };
 
+const normalizeColumns = columns =>
+  (Array.isArray(columns) ? columns : []).filter(
+    column => column && typeof column.name === 'string' && column.name.trim().length > 0
+  );
+
 const formatJsDoc = comment => {
-  if (!comment) return null;
+  if (typeof comment !== 'string') return null;
   const normalized = comment.replace(/\r\n?/g, '\n').trim();
   if (!normalized) return null;
   const lines = normalized.split('\n').map(line => line.replace(/\*\//g, '*\\/'));
@@ -152,7 +157,7 @@ const buildColumnRemarks = column => {
 
 const buildColumnDoc = column => {
   const entries = [];
-  if (column.comment) {
+  if (typeof column.comment === 'string' && column.comment) {
     entries.push(column.comment);
   }
   const defaultValue = formatDefaultValueForDoc(column.default);
@@ -190,12 +195,13 @@ const renderColumnExpression = (column, tablePk, tableSchema, defaultSchema, pro
           : `col.default(${expr}, ${def.code})`;
     }
   }
-  if (column.references) {
+  if (
+    column.references &&
+    typeof column.references.table === 'string' &&
+    typeof column.references.column === 'string'
+  ) {
     const refTable = normalizeReferenceTable(column.references.table, tableSchema, defaultSchema);
-    const refParts = [
-      `table: '${escapeJsString(refTable)}'`,
-      `column: '${escapeJsString(column.references.column)}'`
-    ];
+    const refParts = [`table: '${escapeJsString(refTable)}'`, `column: '${escapeJsString(column.references.column)}'`];
     if (column.references.onDelete) refParts.push(`onDelete: '${escapeJsString(column.references.onDelete)}'`);
     if (column.references.onUpdate) refParts.push(`onUpdate: '${escapeJsString(column.references.onUpdate)}'`);
     expr = `col.references(${expr}, { ${refParts.join(', ')} })`;
@@ -277,9 +283,10 @@ const renderEntityClassLines = ({ table, className, naming, relations, resolveCl
   lines.push(`@Entity(${entityOpts})`);
   lines.push(`export class ${className} {`);
 
-  const columnPropertyNames = new Set(table.columns.map(col => sanitizePropertyName(col.name)));
+  const tableColumns = normalizeColumns(table.columns);
+  const columnPropertyNames = new Set(tableColumns.map(col => sanitizePropertyName(col.name)));
 
-  for (const col of table.columns) {
+  for (const col of tableColumns) {
     const propertyName = sanitizePropertyName(col.name);
     const rendered = renderColumnExpression(col, table.primaryKey, table.schema, defaultSchema, propertyName);
     appendJsDoc(lines, rendered.comment, '  ');
@@ -414,7 +421,9 @@ const computeTableUsage = (table, relations, defaultSchema, treeConfig) => {
     needsTreeChildrenDecorator: false
   };
 
-  for (const col of table.columns) {
+  const tableColumns = normalizeColumns(table.columns);
+
+  for (const col of tableColumns) {
     usage.needsCol = true;
     const rendered = renderColumnExpression(col, table.primaryKey, table.schema, defaultSchema);
     if (rendered.decorator === 'PrimaryKey') {
@@ -552,7 +561,7 @@ export const renderEntityFile = (schema, options) => {
 
   // Views only need col and Column decorator
   for (const view of views) {
-    if (view.columns.length > 0) {
+    if (normalizeColumns(view.columns).length > 0) {
       aggregateUsage.needsCol = true;
       aggregateUsage.needsColumnDecorator = true;
     }

package/scripts/generate-entities/schema.mjs

@@ -1,33 +1,42 @@
-import { detectTreeTable, mapTreeTables } from './tree-detection.mjs';
-
-const normalizeName = name => (typeof name === 'string' && name.includes('.') ? name.split('.').pop() : name);
-
-export const mapRelations = (tables, naming) => {
-  const relationMap = new Map();
-  const relationKeys = new Map();
-  const fkIndex = new Map();
-  const uniqueSingleColumns = new Map();
-
-  for (const table of tables) {
-    relationMap.set(table.name, []);
-    relationKeys.set(table.name, new Set());
-    for (const col of table.columns) {
-      if (col.references) {
-        const list = fkIndex.get(table.name) || [];
-        list.push(col);
-        fkIndex.set(table.name, list);
-      }
+import { detectTreeTable, mapTreeTables } from './tree-detection.mjs';
+
+const normalizeName = name => (typeof name === 'string' && name.includes('.') ? name.split('.').pop() : name);
+const normalizeTableColumns = columns =>
+  (Array.isArray(columns) ? columns : []).filter(
+    col => col && typeof col.name === 'string' && col.name.trim().length > 0
+  );
+const normalizeTables = tables => (Array.isArray(tables) ? tables : []);
+
+export const mapRelations = (tables, naming) => {
+  const relationMap = new Map();
+  const relationKeys = new Map();
+  const fkIndex = new Map();
+  const uniqueSingleColumns = new Map();
+  const normalizedTables = normalizeTables(tables).filter(
+    table => table && typeof table.name === 'string' && table.name.trim().length > 0
+  );
+
+  for (const table of normalizedTables) {
+    const tableColumns = normalizeTableColumns(table.columns);
+    relationMap.set(table.name, []);
+    relationKeys.set(table.name, new Set());
+    for (const col of tableColumns) {
+      if (col.references) {
+        const list = fkIndex.get(table.name) || [];
+        list.push(col);
+        fkIndex.set(table.name, list);
+      }
     }
 
     const uniqueCols = new Set();
-    if (Array.isArray(table.primaryKey) && table.primaryKey.length === 1) {
-      uniqueCols.add(table.primaryKey[0]);
-    }
-    for (const col of table.columns) {
-      if (col.unique) uniqueCols.add(col.name);
-    }
-    for (const idx of table.indexes || []) {
-      if (!idx?.unique) continue;
+    if (Array.isArray(table.primaryKey) && table.primaryKey.length === 1) {
+      uniqueCols.add(table.primaryKey[0]);
+    }
+    for (const col of tableColumns) {
+      if (col.unique) uniqueCols.add(col.name);
+    }
+    for (const idx of table.indexes || []) {
+      if (!idx?.unique) continue;
       if (!Array.isArray(idx.columns) || idx.columns.length !== 1 || !idx.columns[0]?.column) continue;
       const columnName = idx.columns[0].column;
       if (idx.where) {
@@ -38,15 +47,15 @@ export const mapRelations = (tables, naming) => {
       uniqueCols.add(columnName);
     }
     uniqueSingleColumns.set(table.name, uniqueCols);
-  }
-
-  const findTable = name => {
-    const norm = normalizeName(name);
-    return tables.find(t => t.name === name || t.name === norm);
-  };
-
+  }
+
+  const findTable = name => {
+    const norm = normalizeName(name);
+    return normalizedTables.find(t => t.name === name || t.name === norm);
+  };
+
   const pivotTables = new Set();
-  for (const table of tables) {
+  for (const table of normalizedTables) {
     const fkCols = fkIndex.get(table.name) || [];
     const hasSelfReference = fkCols.some(c => normalizeName(c.references.table) === table.name);
     const distinctTargets = Array.from(new Set(fkCols.map(c => normalizeName(c.references.table))));
@@ -84,11 +93,11 @@ export const mapRelations = (tables, naming) => {
         }
       }
     }
-  }
-
-  for (const table of tables) {
-    const fkCols = fkIndex.get(table.name) || [];
-    for (const fk of fkCols) {
+  }
+
+  for (const table of normalizedTables) {
+    const fkCols = fkIndex.get(table.name) || [];
+    for (const fk of fkCols) {
       const targetTable = fk.references.table;
       const targetKey = normalizeName(targetTable);
       const belongsKey = relationKeys.get(table.name);
@@ -130,39 +139,44 @@ export const mapRelations = (tables, naming) => {
   return relationMap;
 };
 
-export const buildSchemaMetadata = (schema, naming) => {
-  const tables = schema.tables.map(t => {
-    const indexes = Array.isArray(t.indexes) ? t.indexes.map(idx => ({ ...idx })) : [];
-    const uniqueSingleColumns = new Set(
-      indexes
-        .filter(idx => idx?.unique && !idx?.where && Array.isArray(idx.columns) && idx.columns.length === 1)
-        .map(idx => idx.columns[0]?.column)
-        .filter(Boolean)
-    );
-
-    return {
-      name: t.name,
-      schema: t.schema,
-      columns: (t.columns || []).map(col => {
-        const unique = col.unique !== undefined ? col.unique : uniqueSingleColumns.has(col.name) ? true : undefined;
-        return { ...col, unique };
-      }),
-      primaryKey: t.primaryKey || [],
-      indexes,
-      isView: false
-    };
-  });
-
-  const views = (schema.views || []).map(v => ({
-    name: v.name,
-    schema: v.schema,
-    columns: (v.columns || []).map(col => ({ ...col })),
-    primaryKey: [],
-    indexes: [],
-    isView: true,
-    definition: v.definition,
-    comment: v.comment
-  }));
+export const buildSchemaMetadata = (schema, naming) => {
+  const tables = normalizeTables(schema?.tables)
+    .filter(t => t && typeof t.name === 'string' && t.name.trim().length > 0)
+    .map(t => {
+      const columns = normalizeTableColumns(t.columns).map(col => ({ ...col }));
+      const indexes = Array.isArray(t.indexes) ? t.indexes.map(idx => ({ ...idx })) : [];
+      const uniqueSingleColumns = new Set(
+        indexes
+          .filter(idx => idx?.unique && !idx?.where && Array.isArray(idx.columns) && idx.columns.length === 1)
+          .map(idx => idx.columns[0]?.column)
+          .filter(Boolean)
+      );
+
+      return {
+        name: t.name,
+        schema: t.schema,
+        columns: columns.map(col => {
+          const unique = col.unique !== undefined ? col.unique : uniqueSingleColumns.has(col.name) ? true : undefined;
+          return { ...col, unique };
+        }),
+        primaryKey: t.primaryKey || [],
+        indexes,
+        isView: false
+      };
+    });
+
+  const views = normalizeTables(schema?.views)
+    .filter(v => v && typeof v.name === 'string' && v.name.trim().length > 0)
+    .map(v => ({
+      name: v.name,
+      schema: v.schema,
+      columns: normalizeTableColumns(v.columns).map(col => ({ ...col })),
+      primaryKey: [],
+      indexes: [],
+      isView: true,
+      definition: v.definition,
+      comment: v.comment
+    }));
 
   const allEntities = [...tables, ...views];
 

package/scripts/generate-entities/tree-detection.mjs

@@ -16,38 +16,40 @@
  * @param {Object} naming - Naming strategy instance
  * @returns {Object|null} Tree configuration if detected, null otherwise
  */
-export const detectTreeTable = (table, naming) => {
-  const columns = table.columns || [];
-  const columnNames = new Set(columns.map(c => c.name));
-  
-  // Common patterns for tree columns
-  const parentPatterns = ['parentId', 'parent_id', 'parent'];
-  const leftPatterns = ['lft', 'left', 'leftValue', 'left_value'];
-  const rightPatterns = ['rght', 'right', 'rightValue', 'right_value'];
-  const depthPatterns = ['depth', 'level', 'treeLevel', 'tree_level', 'cod_nivel'];
-  
-  // Find matching columns
-  const parentCol = columns.find(c => 
-    parentPatterns.includes(c.name) || 
-    c.name.toLowerCase().includes('parent')
-  );
-  
-  const leftCol = columns.find(c => 
-    leftPatterns.includes(c.name) ||
-    c.name.toLowerCase().includes('left')
-  );
-  
-  const rightCol = columns.find(c => 
-    rightPatterns.includes(c.name) ||
-    c.name.toLowerCase().includes('right')
-  );
-  
-  const depthCol = columns.find(c => 
-    depthPatterns.includes(c.name) ||
-    c.name.toLowerCase().includes('depth') ||
-    c.name.toLowerCase().includes('level') ||
-    c.name.toLowerCase().includes('nivel')
-  );
+export const detectTreeTable = (table, naming) => {
+  const columns = Array.isArray(table?.columns) ? table.columns : [];
+  const getColumnName = column =>
+    column && typeof column.name === 'string' && column.name.trim().length > 0 ? column.name : undefined;
+  
+  // Common patterns for tree columns
+  const parentPatterns = ['parentId', 'parent_id', 'parent'];
+  const leftPatterns = ['lft', 'left', 'leftValue', 'left_value'];
+  const rightPatterns = ['rght', 'right', 'rightValue', 'right_value'];
+  const depthPatterns = ['depth', 'level', 'treeLevel', 'tree_level', 'cod_nivel'];
+
+  const matchesTreePattern = (column, patterns, term) => {
+    const name = getColumnName(column);
+    if (!name) return false;
+    return patterns.includes(name) || name.toLowerCase().includes(term);
+  };
+  
+  // Find matching columns
+  const parentCol = columns.find(c => matchesTreePattern(c, parentPatterns, 'parent'));
+  
+  const leftCol = columns.find(c => matchesTreePattern(c, leftPatterns, 'left'));
+  
+  const rightCol = columns.find(c => matchesTreePattern(c, rightPatterns, 'right'));
+  
+  const depthCol = columns.find(c => {
+    const name = getColumnName(c);
+    if (!name) return false;
+    return (
+      depthPatterns.includes(name) ||
+      name.toLowerCase().includes('depth') ||
+      name.toLowerCase().includes('level') ||
+      name.toLowerCase().includes('nivel')
+    );
+  });
   
   // Validate: must have parent, left, and right columns
   if (!parentCol || !leftCol || !rightCol) {
@@ -86,25 +88,29 @@ export const detectTreeTable = (table, naming) => {
     config.depthKey = depthCol.name;
   }
   
-  // Detect scope columns (columns that might be used for multi-tree scoping)
-  const scopeColumns = columns.filter(c => {
-    // Skip tree columns and primary key
-    if (c.name === config.parentKey || c.name === config.leftKey || 
-        c.name === config.rightKey || c.name === config.depthKey) {
-      return false;
-    }
-    // Skip if it's the primary key
-    if (table.primaryKey?.includes(c.name)) {
-      return false;
-    }
-    // Skip if it has a foreign key to another table
-    if (c.references && c.references.table !== table.name) {
-      return false;
-    }
-    // Look for columns that might be scope columns (e.g., tenantId, organizationId)
-    const scopePatterns = ['tenant', 'organization', 'company', 'site', 'workspace'];
-    return scopePatterns.some(pattern => c.name.toLowerCase().includes(pattern));
-  }).map(c => c.name);
+  // Detect scope columns (columns that might be used for multi-tree scoping)
+  const scopeColumns = columns.filter(c => {
+    const name = getColumnName(c);
+    if (!name) {
+      return false;
+    }
+    // Skip tree columns and primary key
+    if (name === config.parentKey || name === config.leftKey || 
+        name === config.rightKey || name === config.depthKey) {
+      return false;
+    }
+    // Skip if it's the primary key
+    if (table.primaryKey?.includes(name)) {
+      return false;
+    }
+    // Skip if it has a foreign key to another table
+    if (c.references && c.references.table !== table.name) {
+      return false;
+    }
+    // Look for columns that might be scope columns (e.g., tenantId, organizationId)
+    const scopePatterns = ['tenant', 'organization', 'company', 'site', 'workspace'];
+    return scopePatterns.some(pattern => name.toLowerCase().includes(pattern));
+  }).map(c => getColumnName(c)).filter(Boolean);
   
   if (scopeColumns.length > 0) {
     config.scope = scopeColumns;
@@ -119,15 +125,15 @@ export const detectTreeTable = (table, naming) => {
  * @param {Object} naming - Naming strategy instance
  * @returns {Map} Map of table name to tree configuration
  */
-export const mapTreeTables = (tables, naming) => {
-  const treeMap = new Map();
-  
-  for (const table of tables) {
-    const treeConfig = detectTreeTable(table, naming);
-    if (treeConfig) {
-      treeMap.set(table.name, treeConfig);
-    }
-  }
+export const mapTreeTables = (tables, naming) => {
+  const treeMap = new Map();
+  
+  for (const table of Array.isArray(tables) ? tables : []) {
+    const treeConfig = detectTreeTable(table, naming);
+    if (treeConfig && table && typeof table.name === 'string' && table.name.trim().length > 0) {
+      treeMap.set(table.name, treeConfig);
+    }
+  }
   
   return treeMap;
 };
@@ -150,4 +156,4 @@ export const getTreeConfig = (tableName, treeMap) => {
  */
 export const isTreeTable = (tableName, treeMap) => {
   return treeMap.has(tableName);
-};
+};

package/src/bulk/bulk-context.ts

@@ -0,0 +1,83 @@
+import type { OrmSession } from '../orm/orm-session.js';
+import type { ExecutionContext } from '../orm/execution-context.js';
+import type { Dialect, CompiledQuery } from '../core/dialect/abstract.js';
+import type { ColumnNode } from '../core/ast/expression.js';
+import type { TableDef } from '../schema/table.js';
+import type { ColumnDef } from '../schema/column-types.js';
+import type { QueryResult } from '../core/execution/db-executor.js';
+
+export interface BulkExecutionContext {
+  readonly session: OrmSession;
+  readonly executionContext: ExecutionContext;
+  readonly dialect: Dialect;
+  readonly supportsReturning: boolean;
+}
+
+export function createBulkExecutionContext(session: OrmSession): BulkExecutionContext {
+  const executionContext = session.getExecutionContext();
+  return {
+    session,
+    executionContext,
+    dialect: executionContext.dialect,
+    supportsReturning: executionContext.dialect.supportsDmlReturningClause(),
+  };
+}
+
+export async function executeCompiled(
+  ctx: BulkExecutionContext,
+  compiled: CompiledQuery
+): Promise<QueryResult[]> {
+  const payload = await ctx.executionContext.interceptors.run(
+    { sql: compiled.sql, params: compiled.params },
+    ctx.executionContext.executor
+  );
+  return extractResultSets(payload);
+}
+
+export function extractResultSets(payload: unknown): QueryResult[] {
+  const result = payload as { resultSets?: QueryResult[] };
+  if (result.resultSets) {
+    return result.resultSets;
+  }
+  return [];
+}
+
+export function flattenQueryResults(resultSets: QueryResult[]): Record<string, unknown>[] {
+  const rows: Record<string, unknown>[] = [];
+  for (const rs of resultSets) {
+    for (const valueRow of rs.values) {
+      const obj: Record<string, unknown> = {};
+      rs.columns.forEach((col, idx) => {
+        const bare = col.split('.').pop()!.replace(/^["`[\]]+|["`[\]]+$/g, '');
+        obj[bare] = valueRow[idx];
+      });
+      rows.push(obj);
+    }
+  }
+  return rows;
+}
+
+export function resolveReturningColumns(
+  ctx: BulkExecutionContext,
+  table: TableDef,
+  returning: boolean | ColumnDef[] | undefined
+): ColumnNode[] | undefined {
+  if (!returning) return undefined;
+  if (!ctx.supportsReturning) return undefined;
+
+  if (returning === true) {
+    return Object.values(table.columns).map(col => ({
+      type: 'Column' as const,
+      table: table.name,
+      name: col.name,
+      alias: col.name,
+    }));
+  }
+
+  return returning.map(col => ({
+    type: 'Column' as const,
+    table: table.name,
+    name: col.name,
+    alias: col.name,
+  }));
+}

package/src/bulk/bulk-delete-executor.ts

@@ -0,0 +1,87 @@
+import { DeleteQueryBuilder } from '../query-builder/delete.js';
+import { findPrimaryKey } from '../query-builder/hydration-planner.js';
+import { and, inList } from '../core/ast/expression-builders.js';
+import type { TableDef } from '../schema/table.js';
+import type { OrmSession } from '../orm/orm-session.js';
+import type { BulkDeleteOptions, ChunkOutcome } from './bulk-types.js';
+import type { ValueOperandInput } from '../core/ast/expression.js';
+import type { ExpressionNode } from '../core/ast/expression-nodes.js';
+import { BulkBaseExecutor, type BulkExecutorOptions } from './bulk-executor.base.js';
+import { createBulkExecutionContext, executeCompiled } from './bulk-context.js';
+import { maybeTransaction } from './bulk-utils.js';
+
+interface DeleteExecutorOptions extends BulkExecutorOptions {
+  by?: string;
+  where?: ExpressionNode;
+}
+
+export class BulkDeleteExecutor extends BulkBaseExecutor<DeleteExecutorOptions> {
+  private readonly byColumnName: string;
+
+  constructor(
+    session: OrmSession,
+    table: TableDef,
+    ids: ValueOperandInput[],
+    options: BulkDeleteOptions = {}
+  ) {
+    super(session, table, ids, options);
+    this.byColumnName = options.by ?? findPrimaryKey(table);
+  }
+
+  protected async executeChunk(chunk: ValueOperandInput[], _chunkIndex: number): Promise<ChunkOutcome> {
+    const byColumn = this.table.columns[this.byColumnName];
+    if (!byColumn) {
+      throw new Error(
+        `bulkDelete: column "${this.byColumnName}" not found in table "${this.table.name}"`
+      );
+    }
+
+    const extraWhere = this.options.where;
+    const inExpr = inList(byColumn, chunk as unknown as Parameters<typeof inList>[1]);
+    const finalWhere = extraWhere ? and(inExpr, extraWhere) : inExpr;
+
+    const builder = new DeleteQueryBuilder(this.table).where(finalWhere as ExpressionNode);
+    const compiled = builder.compile(this.ctx.dialect);
+    await executeCompiled(this.ctx, compiled);
+
+    return {
+      processedRows: chunk.length,
+      returning: [],
+      elapsedMs: 0,
+    };
+  }
+}
+
+export async function bulkDelete<TTable extends TableDef>(
+  session: OrmSession,
+  table: TTable,
+  ids: ValueOperandInput[],
+  options: BulkDeleteOptions = {}
+): Promise<import('./bulk-types.js').BulkResult> {
+  if (!ids.length) {
+    return { processedRows: 0, chunksExecuted: 0, returning: [] };
+  }
+
+  const executor = new BulkDeleteExecutor(session, table, ids, options);
+  return executor.execute();
+}
+
+export async function bulkDeleteWhere<TTable extends TableDef>(
+  session: OrmSession,
+  table: TTable,
+  where: ExpressionNode,
+  options: Pick<BulkDeleteOptions, 'transactional'> = {}
+): Promise<import('./bulk-types.js').BulkResult> {
+  const { transactional = false } = options;
+
+  const ctx = createBulkExecutionContext(session);
+  const builder = new DeleteQueryBuilder(table).where(where);
+  const compiled = builder.compile(ctx.dialect);
+
+  const execute = async (): Promise<import('./bulk-types.js').BulkResult> => {
+    await executeCompiled(ctx, compiled);
+    return { processedRows: 0, chunksExecuted: 1, returning: [] };
+  };
+
+  return maybeTransaction(session, transactional, execute);
+}