metal-orm 1.0.96 → 1.0.98

package/src/orm/lazy-batch/shared.ts

@@ -1,125 +1,125 @@
-import { TableDef } from '../../schema/table.js';
-import { SelectQueryBuilder } from '../../query-builder/select.js';
-import { ExpressionNode, inList, LiteralNode } from '../../core/ast/expression.js';
-import type { QueryResult } from '../../core/execution/db-executor.js';
-import { ColumnDef } from '../../schema/column-types.js';
-import { EntityContext } from '../entity-context.js';
-
-/**
- * An array of database rows, each represented as a record of string keys to unknown values.
- */
-export type Rows = Record<string, unknown>[];
-
-/**
- * Represents a single tracked entity from the EntityContext for a table.
- */
-export type EntityTracker = ReturnType<EntityContext['getEntitiesForTable']>[number];
-
-export const hasColumns = (columns?: readonly string[]): columns is readonly string[] =>
-  Boolean(columns && columns.length > 0);
-
-export const buildColumnSelection = (
-  table: TableDef,
-  columns: string[],
-  missingMsg: (col: string) => string
-): Record<string, ColumnDef> => {
-  return columns.reduce((acc, column) => {
-    const def = table.columns[column];
-    if (!def) {
-      throw new Error(missingMsg(column));
-    }
-    acc[column] = def;
-    return acc;
-  }, {} as Record<string, ColumnDef>);
-};
-
-export const filterRow = (row: Record<string, unknown>, columns: Set<string>): Record<string, unknown> => {
-  const filtered: Record<string, unknown> = {};
-  for (const column of columns) {
-    if (column in row) {
-      filtered[column] = row[column];
-    }
-  }
-  return filtered;
-};
-
-export const filterRows = (rows: Rows, columns: Set<string>): Rows => rows.map(row => filterRow(row, columns));
-
-const rowsFromResults = (results: QueryResult[]): Rows => {
-  const rows: Rows = [];
-  for (const result of results) {
-    const { columns, values } = result;
-    for (const valueRow of values) {
-      const row: Record<string, unknown> = {};
-      columns.forEach((column, idx) => {
-        row[column] = valueRow[idx];
-      });
-      rows.push(row);
-    }
-  }
-  return rows;
-};
-
-const executeQuery = async (ctx: EntityContext, qb: SelectQueryBuilder<unknown, TableDef>): Promise<Rows> => {
-  const compiled = ctx.dialect.compileSelect(qb.getAST());
-  const results = await ctx.executor.executeSql(compiled.sql, compiled.params);
-  return rowsFromResults(results);
-};
-
-export const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
-
-export const collectKeysFromRoots = (roots: EntityTracker[], key: string): Set<unknown> => {
-  const collected = new Set<unknown>();
-  for (const tracked of roots) {
-    const value = (tracked.entity as Record<string, unknown>)[key];
-    if (value !== null && value !== undefined) {
-      collected.add(value);
-    }
-  }
-  return collected;
-};
-
-const buildInListValues = (keys: Set<unknown>): (string | number | LiteralNode)[] =>
-  Array.from(keys) as (string | number | LiteralNode)[];
-
-export const fetchRowsForKeys = async (
-  ctx: EntityContext,
-  table: TableDef,
-  column: ColumnDef,
-  keys: Set<unknown>,
-  selection: Record<string, ColumnDef>,
-  filter?: ExpressionNode
-): Promise<Rows> => {
-  let qb = new SelectQueryBuilder(table).select(selection);
-  qb = qb.where(inList(column, buildInListValues(keys)));
-  if (filter) {
-    qb = qb.where(filter);
-  }
-  return executeQuery(ctx, qb);
-};
-
-export const groupRowsByMany = (rows: Rows, keyColumn: string): Map<string, Rows> => {
-  const grouped = new Map<string, Rows>();
-  for (const row of rows) {
-    const value = row[keyColumn];
-    if (value === null || value === undefined) continue;
-    const key = toKey(value);
-    const bucket = grouped.get(key) ?? [];
-    bucket.push(row);
-    grouped.set(key, bucket);
-  }
-  return grouped;
-};
-
-export const groupRowsByUnique = (rows: Rows, keyColumn: string): Map<string, Record<string, unknown>> => {
-  const lookup = new Map<string, Record<string, unknown>>();
-  for (const row of rows) {
-    const value = row[keyColumn];
-    if (value === null || value === undefined) continue;
-    const key = toKey(value);
-    if (!lookup.has(key)) {
-      lookup.set(key, row);
-    }
-  }
-  return lookup;
-};
+import { TableDef } from '../../schema/table.js';
+import { SelectQueryBuilder } from '../../query-builder/select.js';
+import { ExpressionNode, inList, LiteralNode } from '../../core/ast/expression.js';
+import type { QueryResult } from '../../core/execution/db-executor.js';
+import { ColumnDef } from '../../schema/column-types.js';
+import { EntityContext } from '../entity-context.js';
+
+/**
+ * An array of database rows, each represented as a record of string keys to unknown values.
+ */
+export type Rows = Record<string, unknown>[];
+
+/**
+ * Represents a single tracked entity from the EntityContext for a table.
+ */
+export type EntityTracker = ReturnType<EntityContext['getEntitiesForTable']>[number];
+
+export const hasColumns = (columns?: readonly string[]): columns is readonly string[] =>
+  Boolean(columns && columns.length > 0);
+
+export const buildColumnSelection = (
+  table: TableDef,
+  columns: string[],
+  missingMsg: (col: string) => string
+): Record<string, ColumnDef> => {
+  return columns.reduce((acc, column) => {
+    const def = table.columns[column];
+    if (!def) {
+      throw new Error(missingMsg(column));
+    }
+    acc[column] = def;
+    return acc;
+  }, {} as Record<string, ColumnDef>);
+};
+
+export const filterRow = (row: Record<string, unknown>, columns: Set<string>): Record<string, unknown> => {
+  const filtered: Record<string, unknown> = {};
+  for (const column of columns) {
+    if (column in row) {
+      filtered[column] = row[column];
+    }
+  }
+  return filtered;
+};
+
+export const filterRows = (rows: Rows, columns: Set<string>): Rows => rows.map(row => filterRow(row, columns));
+
+const rowsFromResults = (results: QueryResult[]): Rows => {
+  const rows: Rows = [];
+  for (const result of results) {
+    const { columns, values } = result;
+    for (const valueRow of values) {
+      const row: Record<string, unknown> = {};
+      columns.forEach((column, idx) => {
+        row[column] = valueRow[idx];
+      });
+      rows.push(row);
+    }
+  }
+  return rows;
+};
+
+const executeQuery = async (ctx: EntityContext, qb: SelectQueryBuilder<unknown, TableDef>): Promise<Rows> => {
+  const compiled = ctx.dialect.compileSelect(qb.getAST());
+  const results = await ctx.executor.executeSql(compiled.sql, compiled.params);
+  return rowsFromResults(results);
+};
+
+export const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
+
+export const collectKeysFromRoots = (roots: EntityTracker[], key: string): Set<unknown> => {
+  const collected = new Set<unknown>();
+  for (const tracked of roots) {
+    const value = (tracked.entity as Record<string, unknown>)[key];
+    if (value !== null && value !== undefined) {
+      collected.add(value);
+    }
+  }
+  return collected;
+};
+
+const buildInListValues = (keys: Set<unknown>): (string | number | LiteralNode)[] =>
+  Array.from(keys) as (string | number | LiteralNode)[];
+
+export const fetchRowsForKeys = async (
+  ctx: EntityContext,
+  table: TableDef,
+  column: ColumnDef,
+  keys: Set<unknown>,
+  selection: Record<string, ColumnDef>,
+  filter?: ExpressionNode
+): Promise<Rows> => {
+  let qb = new SelectQueryBuilder(table).select(selection);
+  qb = qb.where(inList(column, buildInListValues(keys)));
+  if (filter) {
+    qb = qb.where(filter);
+  }
+  return executeQuery(ctx, qb);
+};
+
+export const groupRowsByMany = (rows: Rows, keyColumn: string): Map<string, Rows> => {
+  const grouped = new Map<string, Rows>();
+  for (const row of rows) {
+    const value = row[keyColumn];
+    if (value === null || value === undefined) continue;
+    const key = toKey(value);
+    const bucket = grouped.get(key) ?? [];
+    bucket.push(row);
+    grouped.set(key, bucket);
+  }
+  return grouped;
+};
+
+export const groupRowsByUnique = (rows: Rows, keyColumn: string): Map<string, Record<string, unknown>> => {
+  const lookup = new Map<string, Record<string, unknown>>();
+  for (const row of rows) {
+    const value = row[keyColumn];
+    if (value === null || value === undefined) continue;
+    const key = toKey(value);
+    if (!lookup.has(key)) {
+      lookup.set(key, row);
+    }
+  }
+  return lookup;
+};

package/src/orm/save-graph.ts

@@ -28,14 +28,14 @@ import type { PrimaryKey } from './entity-context.js';
 export interface SaveGraphOptions {
   /** Remove existing collection members that are not present in the payload */
   pruneMissing?: boolean;
-  /**
-   * Coerce JSON-friendly input values into DB-friendly primitives.
-   * Currently:
-   * - `json`: Date -> ISO string (for DATE/DATETIME/TIMESTAMP/TIMESTAMPTZ columns)
-   * - `json-in`: string/number -> Date (for DATE/DATETIME/TIMESTAMP/TIMESTAMPTZ columns)
-   */
-  coerce?: 'json' | 'json-in';
-}
+  /**
+   * Coerce JSON-friendly input values into DB-friendly primitives.
+   * Currently:
+   * - `json`: Date -> ISO string (for DATE/DATETIME/TIMESTAMP/TIMESTAMPTZ columns)
+   * - `json-in`: string/number -> Date (for DATE/DATETIME/TIMESTAMP/TIMESTAMPTZ columns)
+   */
+  coerce?: 'json' | 'json-in';
+}
 
 /** Represents an entity object with arbitrary properties. */
 type AnyEntity = Record<string, unknown>;
@@ -52,49 +52,49 @@ type AnyEntity = Record<string, unknown>;
 
 const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
 
-const coerceColumnValue = (
-  table: TableDef,
-  columnName: string,
-  value: unknown,
-  options: SaveGraphOptions
-): unknown => {
-  if (value === null || value === undefined) return value;
-
-  const column = table.columns[columnName] as unknown as ColumnDef | undefined;
-  if (!column) return value;
+const coerceColumnValue = (
+  table: TableDef,
+  columnName: string,
+  value: unknown,
+  options: SaveGraphOptions
+): unknown => {
+  if (value === null || value === undefined) return value;
+
+  const column = table.columns[columnName] as unknown as ColumnDef | undefined;
+  if (!column) return value;
 
   const normalized = normalizeColumnType(column.type);
 
-  const isDateLikeColumn =
-    normalized === 'date' ||
-    normalized === 'datetime' ||
-    normalized === 'timestamp' ||
-    normalized === 'timestamptz';
-
-  if (!isDateLikeColumn) return value;
-
-  if (options.coerce === 'json') {
-    if (value instanceof Date) {
-      return value.toISOString();
-    }
-    return value;
-  }
-
-  if (options.coerce === 'json-in') {
-    if (value instanceof Date) return value;
-    if (typeof value === 'string' || typeof value === 'number') {
-      const date = new Date(value);
-      if (Number.isNaN(date.getTime())) {
-        throw new Error(`Invalid date value for column "${columnName}"`);
-      }
-      return date;
-    }
-    return value;
-  }
-
-  // Future coercions can be added here based on `normalized`.
-  return value;
-};
+  const isDateLikeColumn =
+    normalized === 'date' ||
+    normalized === 'datetime' ||
+    normalized === 'timestamp' ||
+    normalized === 'timestamptz';
+
+  if (!isDateLikeColumn) return value;
+
+  if (options.coerce === 'json') {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    return value;
+  }
+
+  if (options.coerce === 'json-in') {
+    if (value instanceof Date) return value;
+    if (typeof value === 'string' || typeof value === 'number') {
+      const date = new Date(value);
+      if (Number.isNaN(date.getTime())) {
+        throw new Error(`Invalid date value for column "${columnName}"`);
+      }
+      return date;
+    }
+    return value;
+  }
+
+  // Future coercions can be added here based on `normalized`.
+  return value;
+};
 
 const pickColumns = (table: TableDef, payload: AnyEntity, options: SaveGraphOptions): Record<string, unknown> => {
   const columns: Record<string, unknown> = {};

package/src/query-builder/column-selector.ts

@@ -69,13 +69,13 @@ export class ColumnSelector {
    * @param columns - Columns to make distinct
    * @returns Updated query context with DISTINCT clause
    */
-  distinct(context: SelectQueryBuilderContext, columns: (ColumnDef | ColumnNode)[]): SelectQueryBuilderContext {
-    const from = context.state.ast.from;
-    const tableRef = from.type === 'Table' && from.alias ? { ...this.env.table, alias: from.alias } : this.env.table;
-    const nodes = columns.map(col => buildColumnNode(tableRef, col));
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const nextState = astService.withDistinct(nodes);
-    return { state: nextState, hydration: context.hydration };
-  }
-}
+  distinct(context: SelectQueryBuilderContext, columns: (ColumnDef | ColumnNode)[]): SelectQueryBuilderContext {
+    const from = context.state.ast.from;
+    const tableRef = from.type === 'Table' && from.alias ? { ...this.env.table, alias: from.alias } : this.env.table;
+    const nodes = columns.map(col => buildColumnNode(tableRef, col));
+    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
+    const nextState = astService.withDistinct(nodes);
+    return { state: nextState, hydration: context.hydration };
+  }
+}