metal-orm 1.1.10 → 1.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.1.10",
+  "version": "1.1.11",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

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-delete-executor.ts

@@ -8,9 +8,7 @@ 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 { splitIntoChunks, runWithConcurrency, runChunk, maybeTransaction, aggregateOutcomes, aggregateOutcomesWithTimings } from './bulk-utils.js';
-
-const DEFAULT_CHUNK_SIZE = 1000;
+import { maybeTransaction } from './bulk-utils.js';
 
 interface DeleteExecutorOptions extends BulkExecutorOptions {
   by?: string;
@@ -30,7 +28,7 @@ export class BulkDeleteExecutor extends BulkBaseExecutor<DeleteExecutorOptions>
     this.byColumnName = options.by ?? findPrimaryKey(table);
   }
 
-  protected async executeChunk(chunk: ValueOperandInput[], chunkIndex: number): Promise<ChunkOutcome> {
+  protected async executeChunk(chunk: ValueOperandInput[], _chunkIndex: number): Promise<ChunkOutcome> {
     const byColumn = this.table.columns[this.byColumnName];
     if (!byColumn) {
       throw new Error(
@@ -39,7 +37,7 @@ export class BulkDeleteExecutor extends BulkBaseExecutor<DeleteExecutorOptions>
     }
 
     const extraWhere = this.options.where;
-    const inExpr = inList(byColumn, chunk as any);
+    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);

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

@@ -4,6 +4,7 @@ import type { OrmSession } from '../orm/orm-session.js';
 import type { BulkInsertOptions, ChunkOutcome, InsertRow } from './bulk-types.js';
 import { BulkBaseExecutor, type BulkExecutorOptions } from './bulk-executor.base.js';
 import { resolveReturningColumns, flattenQueryResults, executeCompiled } from './bulk-context.js';
+import type { ValueOperandInput } from '../core/ast/expression.js';
 
 interface InsertExecutorOptions extends BulkExecutorOptions {
   returning?: boolean | import('../schema/column-types.js').ColumnDef[];
@@ -20,25 +21,24 @@ export class BulkInsertExecutor extends BulkBaseExecutor<InsertExecutorOptions>
     super(session, table, rows, options);
   }
 
-  protected async executeChunk(chunk: InsertRow[], chunkIndex: number): Promise<ChunkOutcome> {
+  protected async executeChunk(chunk: InsertRow[], _chunkIndex: number): Promise<ChunkOutcome> {
     const returningColumns = resolveReturningColumns(this.ctx, this.table, this.options.returning);
 
-    let builder: InsertQueryBuilder<unknown> | ConflictBuilder<unknown> = 
-      new InsertQueryBuilder(this.table).values(chunk);
+    let builder: InsertQueryBuilder<unknown> | ConflictBuilder<unknown> = new InsertQueryBuilder(this.table).values(chunk);
 
     if (this.options.onConflict) {
       const conflictColumns = this.options.onConflict.target?.columns ?? [];
-      builder = (builder as InsertQueryBuilder<unknown>).onConflict(conflictColumns as any);
+      const conflictBuilder = (builder as InsertQueryBuilder<unknown>).onConflict(conflictColumns);
       
       if (this.options.onConflict.action.type === 'DoNothing') {
-        builder = (builder as ConflictBuilder<unknown>).doNothing();
+        builder = conflictBuilder.doNothing();
       } else if (this.options.onConflict.action.type === 'DoUpdate' && this.options.onConflict.action.set) {
-        const setMap: Record<string, unknown> = {};
+        const setMap: Record<string, ValueOperandInput> = {};
         for (const assignment of this.options.onConflict.action.set) {
           const colName = typeof assignment.column === 'object' ? assignment.column.name : assignment.column;
           setMap[colName] = assignment.value;
         }
-        builder = (builder as ConflictBuilder<unknown>).doUpdate(setMap as any);
+        builder = conflictBuilder.doUpdate(setMap);
       }
     }
 

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

@@ -34,7 +34,7 @@ export class BulkUpdateExecutor extends BulkBaseExecutor<UpdateExecutorOptions>
     this.byColumns = resolveByColumns(table, options.by);
   }
 
-  protected async executeChunk(chunk: UpdateRow[], chunkIndex: number): Promise<ChunkOutcome> {
+  protected async executeChunk(chunk: UpdateRow[], _chunkIndex: number): Promise<ChunkOutcome> {
     const allReturning: Record<string, unknown>[] = [];
     const returningColumns = resolveReturningColumns(this.ctx, this.table, this.options.returning);
     const extraWhere = this.options.where;
@@ -152,7 +152,7 @@ export async function bulkUpdateWhere<TTable extends TableDef>(
   const buildTask = (chunk: ValueOperandInput[], chunkIndex: number) => async (): Promise<ChunkOutcome> => {
     return runChunk(
       async () => {
-        const inExpr = inList(byColumn, chunk as any);
+        const inExpr = inList(byColumn, chunk as unknown as Parameters<typeof inList>[1]);
         const finalWhere = extraWhere ? and(inExpr, extraWhere) : inExpr;
 
         let builder = new UpdateQueryBuilder(table).set(set as Record<string, unknown>).where(finalWhere);

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

@@ -3,12 +3,10 @@ import { findPrimaryKey } from '../query-builder/hydration-planner.js';
 import type { TableDef } from '../schema/table.js';
 import type { OrmSession } from '../orm/orm-session.js';
 import type { BulkUpsertOptions, ChunkOutcome, InsertRow } from './bulk-types.js';
-import type { UpsertClause } from '../core/ast/query.js';
 import type { ValueOperandInput } from '../core/ast/expression.js';
 import type { ColumnNode } from '../core/ast/expression.js';
 import { BulkBaseExecutor, type BulkExecutorOptions } from './bulk-executor.base.js';
-import { resolveReturningColumns, flattenQueryResults, executeCompiled, createBulkExecutionContext } from './bulk-context.js';
-import { splitIntoChunks, runWithConcurrency, runChunk, maybeTransaction, aggregateOutcomes, aggregateOutcomesWithTimings } from './bulk-utils.js';
+import { resolveReturningColumns, flattenQueryResults, executeCompiled } from './bulk-context.js';
 
 interface UpsertExecutorOptions extends BulkExecutorOptions {
   conflictColumns?: string[];
@@ -44,22 +42,22 @@ export class BulkUpsertExecutor extends BulkBaseExecutor<UpsertExecutorOptions>
       Object.keys(rows[0] ?? {}).filter(col => !conflictSet.has(col) && col in table.columns);
   }
 
-  protected async executeChunk(chunk: InsertRow[], chunkIndex: number): Promise<ChunkOutcome> {
+  protected async executeChunk(chunk: InsertRow[], _chunkIndex: number): Promise<ChunkOutcome> {
     const returningColumns = resolveReturningColumns(this.ctx, this.table, this.options.returning);
 
     const set: Record<string, ValueOperandInput> = {};
     for (const col of this.updateColumns) {
-      set[col] = { type: 'ExcludedColumn', name: col } as any;
+      set[col] = { type: 'ExcludedColumn', name: col } as unknown as ValueOperandInput;
     }
 
     let builder: InsertQueryBuilder<unknown>;
 
     if (this.updateColumns.length === 0) {
-      builder = new InsertQueryBuilder(this.table).values(chunk).onConflict(this.conflictTargetNodes as any).doNothing();
+      builder = new InsertQueryBuilder(this.table).values(chunk).onConflict(this.conflictTargetNodes).doNothing();
     } else {
       builder = new InsertQueryBuilder(this.table)
         .values(chunk)
-        .onConflict(this.conflictTargetNodes as any)
+        .onConflict(this.conflictTargetNodes)
         .doUpdate(set);
     }