metal-orm 1.1.10 → 1.1.16

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);
     }
 

package/src/codegen/naming-strategy.ts

@@ -1,32 +1,32 @@
 import type { TableNode, FunctionTableNode, DerivedTableNode, TableSourceNode } from '../core/ast/query.js';
-import type { ColumnNode } from '../core/ast/expression.js';
-
-/**
- * Strategy interface for converting database names to TypeScript identifiers
- */
-export interface NamingStrategy {
-  /**
-   * Converts a table name to a TypeScript symbol name
+import type { ColumnNode } from '../core/ast/expression.js';
+
+/**
+ * Strategy interface for converting database names to TypeScript identifiers
+ */
+export interface NamingStrategy {
+  /**
+   * Converts a table name to a TypeScript symbol name
    * @param table - Table node, function table node, or name
    * @returns Valid TypeScript identifier
    */
   tableToSymbol(table: TableSourceNode | string): string;
-
-  /**
-   * Converts a column reference to a property name
-   * @param column - Column node
-   * @returns Valid TypeScript property name
-   */
-  columnToProperty(column: ColumnNode): string;
-}
-
-/**
- * Default naming strategy that maintains backward compatibility
- * with the original capitalize() behavior
- */
-export class DefaultNamingStrategy implements NamingStrategy {
-  /**
-   * Converts table names to TypeScript symbols
+
+  /**
+   * Converts a column reference to a property name
+   * @param column - Column node
+   * @returns Valid TypeScript property name
+   */
+  columnToProperty(column: ColumnNode): string;
+}
+
+/**
+ * Default naming strategy that maintains backward compatibility
+ * with the original capitalize() behavior
+ */
+export class DefaultNamingStrategy implements NamingStrategy {
+  /**
+   * Converts table names to TypeScript symbols
    * @param table - Table node, function table node, or string name
    * @returns Capitalized table name (handles schema-qualified names)
    */
@@ -39,33 +39,33 @@ export class DefaultNamingStrategy implements NamingStrategy {
           : table.type === 'FunctionTable'
             ? table.alias ?? table.name
             : table.name;
-
-    // Handle schema-qualified names (e.g., "auth.user" → "AuthUser")
-    if (tableName.includes('.')) {
-      return tableName.split('.')
-        .map(part => this.capitalize(part))
-        .join('');
-    }
-
-    return this.capitalize(tableName);
-  }
-
-  /**
-   * Converts column references to property names
-   * @param column - Column node
-   * @returns Column name as-is (for backward compatibility)
-   */
-  columnToProperty(column: ColumnNode): string {
-    return column.name;
-  }
-
-  /**
-   * Capitalizes the first letter of a string
-   * @param s - String to capitalize
-   * @returns Capitalized string
-   */
-  private capitalize(s: string): string {
-    if (!s) return s;
-    return s.charAt(0).toUpperCase() + s.slice(1);
-  }
-}
+
+    // Handle schema-qualified names (e.g., "auth.user" → "AuthUser")
+    if (tableName.includes('.')) {
+      return tableName.split('.')
+        .map(part => this.capitalize(part))
+        .join('');
+    }
+
+    return this.capitalize(tableName);
+  }
+
+  /**
+   * Converts column references to property names
+   * @param column - Column node
+   * @returns Column name as-is (for backward compatibility)
+   */
+  columnToProperty(column: ColumnNode): string {
+    return column.name;
+  }
+
+  /**
+   * Capitalizes the first letter of a string
+   * @param s - String to capitalize
+   * @returns Capitalized string
+   */
+  private capitalize(s: string): string {
+    if (!s) return s;
+    return s.charAt(0).toUpperCase() + s.slice(1);
+  }
+}