metal-orm 1.0.64 → 1.0.65

package/src/orm/unit-of-work.ts

@@ -1,4 +1,5 @@
-import { ColumnNode, eq } from '../core/ast/expression.js';
+import { ColumnNode, eq } from '../core/ast/expression.js';
+import type { ValueOperandInput } from '../core/ast/expression.js';
 import type { Dialect, CompiledQuery } from '../core/dialect/abstract.js';
 import { InsertQueryBuilder } from '../query-builder/insert.js';
 import { UpdateQueryBuilder } from '../query-builder/update.js';
@@ -13,8 +14,8 @@ import type { TrackedEntity } from './runtime-types.js';
 /**
  * Unit of Work pattern implementation for tracking entity changes.
  */
-export class UnitOfWork {
-  private readonly trackedEntities = new Map<unknown, TrackedEntity>();
+export class UnitOfWork {
+  private readonly trackedEntities = new Map<object, TrackedEntity>();
 
   /**
    * Creates a new UnitOfWork instance.
@@ -51,9 +52,9 @@ export class UnitOfWork {
    * @param pk - The primary key value
    * @returns The entity or undefined if not found
    */
-  getEntity(table: TableDef, pk: string | number): unknown | undefined {
-    return this.identityMap.getEntity(table, pk);
-  }
+  getEntity(table: TableDef, pk: string | number): object | undefined {
+    return this.identityMap.getEntity(table, pk);
+  }
 
   /**
    * Gets all tracked entities for a specific table.
@@ -69,9 +70,9 @@ export class UnitOfWork {
    * @param entity - The entity to find
    * @returns The tracked entity or undefined if not found
    */
-  findTracked(entity: unknown): TrackedEntity | undefined {
-    return this.trackedEntities.get(entity);
-  }
+  findTracked(entity: object): TrackedEntity | undefined {
+    return this.trackedEntities.get(entity);
+  }
 
   /**
    * Sets an entity in the identity map.
@@ -79,9 +80,9 @@ export class UnitOfWork {
    * @param pk - The primary key value
    * @param entity - The entity instance
    */
-  setEntity(table: TableDef, pk: string | number, entity: unknown): void {
-    if (pk === null || pk === undefined) return;
-    let tracked = this.trackedEntities.get(entity);
+  setEntity(table: TableDef, pk: string | number, entity: object): void {
+    if (pk === null || pk === undefined) return;
+    let tracked = this.trackedEntities.get(entity);
     if (!tracked) {
       tracked = {
         table,
@@ -104,7 +105,7 @@ export class UnitOfWork {
    * @param entity - The entity instance
    * @param pk - Optional primary key value
    */
-  trackNew(table: TableDef, entity: unknown, pk?: string | number): void {
+  trackNew(table: TableDef, entity: object, pk?: string | number): void {
     const tracked: TrackedEntity = {
       table,
       entity,
@@ -124,7 +125,7 @@ export class UnitOfWork {
    * @param pk - The primary key value
    * @param entity - The entity instance
    */
-  trackManaged(table: TableDef, pk: string | number, entity: unknown): void {
+  trackManaged(table: TableDef, pk: string | number, entity: object): void {
     const tracked: TrackedEntity = {
       table,
       entity,
@@ -140,22 +141,22 @@ export class UnitOfWork {
    * Marks an entity as dirty (modified).
    * @param entity - The entity to mark as dirty
    */
-  markDirty(entity: unknown): void {
-    const tracked = this.trackedEntities.get(entity);
-    if (!tracked) return;
-    if (tracked.status === EntityStatus.New || tracked.status === EntityStatus.Removed) return;
-    tracked.status = EntityStatus.Dirty;
-  }
+  markDirty(entity: object): void {
+    const tracked = this.trackedEntities.get(entity);
+    if (!tracked) return;
+    if (tracked.status === EntityStatus.New || tracked.status === EntityStatus.Removed) return;
+    tracked.status = EntityStatus.Dirty;
+  }
 
   /**
    * Marks an entity as removed.
    * @param entity - The entity to mark as removed
    */
-  markRemoved(entity: unknown): void {
-    const tracked = this.trackedEntities.get(entity);
-    if (!tracked) return;
-    tracked.status = EntityStatus.Removed;
-  }
+  markRemoved(entity: object): void {
+    const tracked = this.trackedEntities.get(entity);
+    if (!tracked) return;
+    tracked.status = EntityStatus.Removed;
+  }
 
   /**
    * Flushes pending changes to the database.
@@ -194,8 +195,8 @@ export class UnitOfWork {
   private async flushInsert(tracked: TrackedEntity): Promise<void> {
     await this.runHook(tracked.table.hooks?.beforeInsert, tracked);
 
-    const payload = this.extractColumns(tracked.table, tracked.entity as Record<string, unknown>);
-    let builder = new InsertQueryBuilder(tracked.table).values(payload);
+    const payload = this.extractColumns(tracked.table, tracked.entity as Record<string, unknown>);
+    let builder = new InsertQueryBuilder(tracked.table).values(payload as Record<string, ValueOperandInput>);
     if (this.dialect.supportsReturning()) {
       builder = builder.returning(...this.getReturningColumns(tracked.table));
     }
@@ -287,16 +288,16 @@ export class UnitOfWork {
    * @param tracked - The tracked entity
    * @returns Object with changed column values
    */
-  private computeChanges(tracked: TrackedEntity): Record<string, unknown> {
-    const snapshot = tracked.original ?? {};
-    const changes: Record<string, unknown> = {};
-    for (const column of Object.keys(tracked.table.columns)) {
-      const current = tracked.entity[column];
-      if (snapshot[column] !== current) {
-        changes[column] = current;
-      }
-    }
-    return changes;
+  private computeChanges(tracked: TrackedEntity): Record<string, unknown> {
+    const snapshot = tracked.original ?? {};
+    const changes: Record<string, unknown> = {};
+    for (const column of Object.keys(tracked.table.columns)) {
+      const current = (tracked.entity as Record<string, unknown>)[column];
+      if (snapshot[column] !== current) {
+        changes[column] = current;
+      }
+    }
+    return changes;
   }
 
   /**
@@ -342,18 +343,18 @@ export class UnitOfWork {
    * @param tracked - The tracked entity
    * @param results - Query results
    */
-  private applyReturningResults(tracked: TrackedEntity, results: QueryResult[]): void {
-    if (!this.dialect.supportsReturning()) return;
-    const first = results[0];
-    if (!first || first.values.length === 0) return;
-
-    const row = first.values[0];
-    for (let i = 0; i < first.columns.length; i++) {
-      const columnName = this.normalizeColumnName(first.columns[i]);
-      if (!(columnName in tracked.table.columns)) continue;
-      tracked.entity[columnName] = row[i];
-    }
-  }
+  private applyReturningResults(tracked: TrackedEntity, results: QueryResult[]): void {
+    if (!this.dialect.supportsReturning()) return;
+    const first = results[0];
+    if (!first || first.values.length === 0) return;
+
+    const row = first.values[0];
+    for (let i = 0; i < first.columns.length; i++) {
+      const columnName = this.normalizeColumnName(first.columns[i]);
+      if (!(columnName in tracked.table.columns)) continue;
+      (tracked.entity as Record<string, unknown>)[columnName] = row[i];
+    }
+  }
 
   /**
    * Normalizes a column name by removing quotes and table prefixes.
@@ -394,10 +395,11 @@ export class UnitOfWork {
    * @param tracked - The tracked entity
    * @returns Primary key value or null
    */
-  private getPrimaryKeyValue(tracked: TrackedEntity): string | number | null {
-    const key = findPrimaryKey(tracked.table);
-    const val = tracked.entity[key];
-    if (val === undefined || val === null) return null;
-    return val;
-  }
-}
+  private getPrimaryKeyValue(tracked: TrackedEntity): string | number | null {
+    const key = findPrimaryKey(tracked.table);
+    const val = (tracked.entity as Record<string, unknown>)[key];
+    if (val === undefined || val === null) return null;
+    if (typeof val !== 'string' && typeof val !== 'number') return null;
+    return val;
+  }
+}

package/src/query-builder/insert-query-state.ts

@@ -1,161 +1,162 @@
-import { TableDef } from '../schema/table.js';
-import { InsertQueryNode, SelectQueryNode } from '../core/ast/query.js';
+import { TableDef } from '../schema/table.js';
+import { InsertQueryNode, SelectQueryNode } from '../core/ast/query.js';
 import {
   ColumnNode,
   OperandNode,
   isValueOperandInput,
   valueToOperand
 } from '../core/ast/expression.js';
-import {
-  buildColumnNodes,
-  createTableNode
-} from '../core/ast/builders.js';
-
-type InsertRows = Record<string, unknown>[];
-
-/**
- * Maintains immutable state for building INSERT queries
- */
-export class InsertQueryState {
-  public readonly table: TableDef;
-  public readonly ast: InsertQueryNode;
-
-  /**
-   * Creates a new InsertQueryState instance
-   * @param table - The table definition for the INSERT query
-   * @param ast - Optional initial AST node, defaults to a basic INSERT query
-   */
-  constructor(table: TableDef, ast?: InsertQueryNode) {
-    this.table = table;
-    this.ast = ast ?? {
-      type: 'InsertQuery',
-      into: createTableNode(table),
-      columns: [],
-      source: {
-        type: 'InsertValues',
-        rows: []
-      }
-    };
-  }
-
-  private clone(nextAst: InsertQueryNode): InsertQueryState {
-    return new InsertQueryState(this.table, nextAst);
-  }
-
-  private ensureColumnsFromRow(rows: InsertRows): ColumnNode[] {
-    if (this.ast.columns.length) return this.ast.columns;
-    return buildColumnNodes(this.table, Object.keys(rows[0]));
-  }
-
-  private appendValues(rows: OperandNode[][]): OperandNode[][] {
-    if (this.ast.source.type === 'InsertValues') {
-      return [...this.ast.source.rows, ...rows];
-    }
-    return rows;
-  }
-
-  private getTableColumns(): ColumnNode[] {
-    const names = Object.keys(this.table.columns);
-    if (!names.length) return [];
-    return buildColumnNodes(this.table, names);
-  }
-
-  /**
-   * Adds VALUES clause to the INSERT query
-   * @param rows - Array of row objects to insert
-   * @returns A new InsertQueryState with the VALUES clause added
-   * @throws Error if mixing VALUES with SELECT source
-   * @throws Error if invalid values are provided
-   */
-  withValues(rows: Record<string, unknown>[]): InsertQueryState {
-    if (!rows.length) return this;
-
-    if (this.ast.source.type === 'InsertSelect') {
-      throw new Error('Cannot mix INSERT ... VALUES with INSERT ... SELECT source.');
-    }
-
-    const definedColumns = this.ensureColumnsFromRow(rows);
-
-    const newRows: OperandNode[][] = rows.map((row, rowIndex) =>
-      definedColumns.map(column => {
-        const rawValue = row[column.name];
-
-        if (!isValueOperandInput(rawValue)) {
-          throw new Error(
-            `Invalid insert value for column "${column.name}" in row ${rowIndex}: only primitives, null, or OperandNodes are allowed`
-          );
-        }
-
-        return valueToOperand(rawValue);
-      })
-    );
-
-    return this.clone({
-      ...this.ast,
-      columns: definedColumns,
-      source: {
-        type: 'InsertValues',
-        rows: this.appendValues(newRows)
-      }
-    });
-  }
-
-  /**
-   * Sets the columns for the INSERT query
-   * @param columns - Column nodes to insert into
-   * @returns A new InsertQueryState with the specified columns
-   */
-  withColumns(columns: ColumnNode[]): InsertQueryState {
-    if (!columns.length) return this;
-    return this.clone({
-      ...this.ast,
-      columns: [...columns]
-    });
-  }
-
-  /**
-   * Adds SELECT source to the INSERT query
-   * @param query - The SELECT query to use as source
-   * @param columns - Target columns for the INSERT
-   * @returns A new InsertQueryState with the SELECT source
-   * @throws Error if mixing SELECT with VALUES source
-   * @throws Error if no destination columns specified
-   */
-  withSelect(query: SelectQueryNode, columns: ColumnNode[]): InsertQueryState {
-    const targetColumns =
-      columns.length
-        ? columns
-        : this.ast.columns.length
-          ? this.ast.columns
-          : this.getTableColumns();
-
-    if (!targetColumns.length) {
-      throw new Error('INSERT ... SELECT requires specifying destination columns.');
-    }
-
-    if (this.ast.source.type === 'InsertValues' && this.ast.source.rows.length) {
-      throw new Error('Cannot mix INSERT ... SELECT with INSERT ... VALUES source.');
-    }
-
-    return this.clone({
-      ...this.ast,
-      columns: [...targetColumns],
-      source: {
-        type: 'InsertSelect',
-        query
-      }
-    });
-  }
-
-  /**
-   * Adds a RETURNING clause to the INSERT query
-   * @param columns - Columns to return after insertion
-   * @returns A new InsertQueryState with the RETURNING clause added
-   */
-  withReturning(columns: ColumnNode[]): InsertQueryState {
-    return this.clone({
-      ...this.ast,
-      returning: [...columns]
-    });
-  }
-}
+import type { ValueOperandInput } from '../core/ast/expression.js';
+import {
+  buildColumnNodes,
+  createTableNode
+} from '../core/ast/builders.js';
+
+type InsertRows = Record<string, ValueOperandInput>[];
+
+/**
+ * Maintains immutable state for building INSERT queries
+ */
+export class InsertQueryState {
+  public readonly table: TableDef;
+  public readonly ast: InsertQueryNode;
+
+  /**
+   * Creates a new InsertQueryState instance
+   * @param table - The table definition for the INSERT query
+   * @param ast - Optional initial AST node, defaults to a basic INSERT query
+   */
+  constructor(table: TableDef, ast?: InsertQueryNode) {
+    this.table = table;
+    this.ast = ast ?? {
+      type: 'InsertQuery',
+      into: createTableNode(table),
+      columns: [],
+      source: {
+        type: 'InsertValues',
+        rows: []
+      }
+    };
+  }
+
+  private clone(nextAst: InsertQueryNode): InsertQueryState {
+    return new InsertQueryState(this.table, nextAst);
+  }
+
+  private ensureColumnsFromRow(rows: InsertRows): ColumnNode[] {
+    if (this.ast.columns.length) return this.ast.columns;
+    return buildColumnNodes(this.table, Object.keys(rows[0]));
+  }
+
+  private appendValues(rows: OperandNode[][]): OperandNode[][] {
+    if (this.ast.source.type === 'InsertValues') {
+      return [...this.ast.source.rows, ...rows];
+    }
+    return rows;
+  }
+
+  private getTableColumns(): ColumnNode[] {
+    const names = Object.keys(this.table.columns);
+    if (!names.length) return [];
+    return buildColumnNodes(this.table, names);
+  }
+
+  /**
+   * Adds VALUES clause to the INSERT query
+   * @param rows - Array of row objects to insert
+   * @returns A new InsertQueryState with the VALUES clause added
+   * @throws Error if mixing VALUES with SELECT source
+   * @throws Error if invalid values are provided
+   */
+  withValues(rows: InsertRows): InsertQueryState {
+    if (!rows.length) return this;
+
+    if (this.ast.source.type === 'InsertSelect') {
+      throw new Error('Cannot mix INSERT ... VALUES with INSERT ... SELECT source.');
+    }
+
+    const definedColumns = this.ensureColumnsFromRow(rows);
+
+    const newRows: OperandNode[][] = rows.map((row, rowIndex) =>
+      definedColumns.map(column => {
+        const rawValue = row[column.name];
+
+        if (!isValueOperandInput(rawValue)) {
+          throw new Error(
+            `Invalid insert value for column "${column.name}" in row ${rowIndex}: only primitives, null, or OperandNodes are allowed`
+          );
+        }
+
+        return valueToOperand(rawValue);
+      })
+    );
+
+    return this.clone({
+      ...this.ast,
+      columns: definedColumns,
+      source: {
+        type: 'InsertValues',
+        rows: this.appendValues(newRows)
+      }
+    });
+  }
+
+  /**
+   * Sets the columns for the INSERT query
+   * @param columns - Column nodes to insert into
+   * @returns A new InsertQueryState with the specified columns
+   */
+  withColumns(columns: ColumnNode[]): InsertQueryState {
+    if (!columns.length) return this;
+    return this.clone({
+      ...this.ast,
+      columns: [...columns]
+    });
+  }
+
+  /**
+   * Adds SELECT source to the INSERT query
+   * @param query - The SELECT query to use as source
+   * @param columns - Target columns for the INSERT
+   * @returns A new InsertQueryState with the SELECT source
+   * @throws Error if mixing SELECT with VALUES source
+   * @throws Error if no destination columns specified
+   */
+  withSelect(query: SelectQueryNode, columns: ColumnNode[]): InsertQueryState {
+    const targetColumns =
+      columns.length
+        ? columns
+        : this.ast.columns.length
+          ? this.ast.columns
+          : this.getTableColumns();
+
+    if (!targetColumns.length) {
+      throw new Error('INSERT ... SELECT requires specifying destination columns.');
+    }
+
+    if (this.ast.source.type === 'InsertValues' && this.ast.source.rows.length) {
+      throw new Error('Cannot mix INSERT ... SELECT with INSERT ... VALUES source.');
+    }
+
+    return this.clone({
+      ...this.ast,
+      columns: [...targetColumns],
+      source: {
+        type: 'InsertSelect',
+        query
+      }
+    });
+  }
+
+  /**
+   * Adds a RETURNING clause to the INSERT query
+   * @param columns - Columns to return after insertion
+   * @returns A new InsertQueryState with the RETURNING clause added
+   */
+  withReturning(columns: ColumnNode[]): InsertQueryState {
+    return this.clone({
+      ...this.ast,
+      returning: [...columns]
+    });
+  }
+}

package/src/query-builder/insert.ts

@@ -1,7 +1,8 @@
 import type { SelectQueryBuilder } from './select.js';
 import { TableDef } from '../schema/table.js';
 import { ColumnDef } from '../schema/column-types.js';
-import { ColumnNode } from '../core/ast/expression.js';
+import { ColumnNode } from '../core/ast/expression.js';
+import type { ValueOperandInput } from '../core/ast/expression.js';
 import { CompiledQuery, InsertCompiler, Dialect } from '../core/dialect/abstract.js';
 import { DialectKey, resolveDialectInput } from '../core/dialect/dialect-factory.js';
 import { InsertQueryNode, SelectQueryNode } from '../core/ast/query.js';
@@ -36,7 +37,9 @@ export class InsertQueryBuilder<T> {
    * @param rowOrRows - Single row object or array of row objects to insert
    * @returns A new InsertQueryBuilder with the VALUES clause added
    */
-  values(rowOrRows: Record<string, unknown> | Record<string, unknown>[]): InsertQueryBuilder<T> {
+  values(
+    rowOrRows: Record<string, ValueOperandInput> | Record<string, ValueOperandInput>[]
+  ): InsertQueryBuilder<T> {
     const rows = Array.isArray(rowOrRows) ? rowOrRows : [rowOrRows];
     if (!rows.length) return this;
     return this.clone(this.state.withValues(rows));