metal-orm 1.1.3 → 1.1.5

package/src/orm/execute.ts

@@ -12,19 +12,20 @@ import {
 import { EntityContext } from './entity-context.js';
 import { ExecutionContext } from './execution-context.js';
 import { HydrationContext } from './hydration-context.js';
-import { RelationIncludeOptions } from '../query-builder/relation-types.js';
-import { getEntityMeta, RelationKey } from './entity-meta.js';
-import { preloadRelationIncludes } from './relation-preload.js';
-import {
-  loadHasManyRelation,
-  loadHasOneRelation,
-  loadBelongsToRelation,
-  loadBelongsToManyRelation
-} from './lazy-batch.js';
-
-type Row = Record<string, unknown>;
-
-const flattenResults = (results: { columns: string[]; values: unknown[][] }[]): Row[] => {
+import { RelationIncludeOptions } from '../query-builder/relation-types.js';
+import { getEntityMeta, RelationKey } from './entity-meta.js';
+import { preloadRelationIncludes } from './relation-preload.js';
+import {
+  loadHasManyRelation,
+  loadHasOneRelation,
+  loadBelongsToRelation,
+  loadBelongsToManyRelation
+} from './lazy-batch.js';
+import { payloadResultSets } from '../core/execution/db-executor.js';
+
+type Row = Record<string, unknown>;
+
+const flattenResults = (results: { columns: string[]; values: unknown[][] }[]): Row[] => {
   const rows: Row[] = [];
   for (const result of results) {
     const { columns, values } = result;
@@ -39,41 +40,41 @@ const flattenResults = (results: { columns: string[]; values: unknown[][] }[]):
   return rows;
 };
 
-const executeWithContexts = async <TTable extends TableDef>(
-  execCtx: ExecutionContext,
-  entityCtx: EntityContext,
-  qb: SelectQueryBuilder<unknown, TTable>
-): Promise<EntityInstance<TTable>[]> => {
-  const ast = qb.getAST();
+const executeWithContexts = async <TTable extends TableDef>(
+  execCtx: ExecutionContext,
+  entityCtx: EntityContext,
+  qb: SelectQueryBuilder<unknown, TTable>
+): Promise<EntityInstance<TTable>[]> => {
+  const ast = qb.getAST();
   const compiled = execCtx.dialect.compileSelect(ast);
   const executed = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
-  const rows = flattenResults(executed);
-  const lazyRelations = qb.getLazyRelations() as RelationKey<TTable>[];
-  const lazyRelationOptions = qb.getLazyRelationOptions();
-  const includeTree = qb.getIncludeTree();
-
-  if (ast.setOps && ast.setOps.length > 0) {
-    const proxies = rows.map(row => createEntityProxy(entityCtx, qb.getTable(), row, lazyRelations, lazyRelationOptions));
-    await loadLazyRelationsForTable(entityCtx, qb.getTable(), lazyRelations, lazyRelationOptions);
-    await preloadRelationIncludes(proxies as Record<string, unknown>[], includeTree);
-    return proxies;
-  }
-
-  const hydrated = hydrateRows(rows, qb.getHydrationPlan());
-  const entities = hydrated.map(row => createEntityFromRow(entityCtx, qb.getTable(), row, lazyRelations, lazyRelationOptions));
-  await loadLazyRelationsForTable(entityCtx, qb.getTable(), lazyRelations, lazyRelationOptions);
-  await preloadRelationIncludes(entities as Record<string, unknown>[], includeTree);
-  return entities;
-};
-
-const executePlainWithContexts = async <TTable extends TableDef>(
-  execCtx: ExecutionContext,
-  qb: SelectQueryBuilder<unknown, TTable>
-): Promise<Record<string, unknown>[]> => {
-  const ast = qb.getAST();
+  const rows = flattenResults(payloadResultSets(executed));
+  const lazyRelations = qb.getLazyRelations() as RelationKey<TTable>[];
+  const lazyRelationOptions = qb.getLazyRelationOptions();
+  const includeTree = qb.getIncludeTree();
+
+  if (ast.setOps && ast.setOps.length > 0) {
+    const proxies = rows.map(row => createEntityProxy(entityCtx, qb.getTable(), row, lazyRelations, lazyRelationOptions));
+    await loadLazyRelationsForTable(entityCtx, qb.getTable(), lazyRelations, lazyRelationOptions);
+    await preloadRelationIncludes(proxies as Record<string, unknown>[], includeTree);
+    return proxies;
+  }
+
+  const hydrated = hydrateRows(rows, qb.getHydrationPlan());
+  const entities = hydrated.map(row => createEntityFromRow(entityCtx, qb.getTable(), row, lazyRelations, lazyRelationOptions));
+  await loadLazyRelationsForTable(entityCtx, qb.getTable(), lazyRelations, lazyRelationOptions);
+  await preloadRelationIncludes(entities as Record<string, unknown>[], includeTree);
+  return entities;
+};
+
+const executePlainWithContexts = async <TTable extends TableDef>(
+  execCtx: ExecutionContext,
+  qb: SelectQueryBuilder<unknown, TTable>
+): Promise<Record<string, unknown>[]> => {
+  const ast = qb.getAST();
   const compiled = execCtx.dialect.compileSelect(ast);
   const executed = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
-  const rows = flattenResults(executed);
+  const rows = flattenResults(payloadResultSets(executed));
 
   if (ast.setOps && ast.setOps.length > 0) {
     return rows;
@@ -89,12 +90,12 @@ const executePlainWithContexts = async <TTable extends TableDef>(
  * @param qb - The select query builder
  * @returns Promise resolving to array of entity instances
  */
-export async function executeHydrated<TTable extends TableDef>(
-  session: OrmSession,
-  qb: SelectQueryBuilder<unknown, TTable>
-): Promise<EntityInstance<TTable>[]> {
-  return executeWithContexts(session.getExecutionContext(), session, qb);
-}
+export async function executeHydrated<TTable extends TableDef>(
+  session: OrmSession,
+  qb: SelectQueryBuilder<unknown, TTable>
+): Promise<EntityInstance<TTable>[]> {
+  return executeWithContexts(session.getExecutionContext(), session, qb);
+}
 
 /**
  * Executes a hydrated query and returns plain row objects (no entity proxies).
@@ -103,12 +104,12 @@ export async function executeHydrated<TTable extends TableDef>(
  * @param qb - The select query builder
  * @returns Promise resolving to array of plain row objects
  */
-export async function executeHydratedPlain<TTable extends TableDef>(
-  session: OrmSession,
-  qb: SelectQueryBuilder<unknown, TTable>
-): Promise<Record<string, unknown>[]> {
-  return executePlainWithContexts(session.getExecutionContext(), qb);
-}
+export async function executeHydratedPlain<TTable extends TableDef>(
+  session: OrmSession,
+  qb: SelectQueryBuilder<unknown, TTable>
+): Promise<Record<string, unknown>[]> {
+  return executePlainWithContexts(session.getExecutionContext(), qb);
+}
 
 /**
  * Executes a hydrated query using execution and hydration contexts.
@@ -118,17 +119,17 @@ export async function executeHydratedPlain<TTable extends TableDef>(
  * @param qb - The select query builder
  * @returns Promise resolving to array of entity instances
  */
-export async function executeHydratedWithContexts<TTable extends TableDef>(
-  execCtx: ExecutionContext,
-  hydCtx: HydrationContext,
-  qb: SelectQueryBuilder<unknown, TTable>
-): Promise<EntityInstance<TTable>[]> {
-  const entityCtx = hydCtx.entityContext;
-  if (!entityCtx) {
-    throw new Error('Hydration context is missing an EntityContext');
-  }
-  return executeWithContexts(execCtx, entityCtx, qb);
-}
+export async function executeHydratedWithContexts<TTable extends TableDef>(
+  execCtx: ExecutionContext,
+  hydCtx: HydrationContext,
+  qb: SelectQueryBuilder<unknown, TTable>
+): Promise<EntityInstance<TTable>[]> {
+  const entityCtx = hydCtx.entityContext;
+  if (!entityCtx) {
+    throw new Error('Hydration context is missing an EntityContext');
+  }
+  return executeWithContexts(execCtx, entityCtx, qb);
+}
 
 /**
  * Executes a hydrated query using execution context and returns plain row objects.
@@ -137,12 +138,12 @@ export async function executeHydratedWithContexts<TTable extends TableDef>(
  * @param qb - The select query builder
  * @returns Promise resolving to array of plain row objects
  */
-export async function executeHydratedPlainWithContexts<TTable extends TableDef>(
-  execCtx: ExecutionContext,
-  qb: SelectQueryBuilder<unknown, TTable>
-): Promise<Record<string, unknown>[]> {
-  return executePlainWithContexts(execCtx, qb);
-}
+export async function executeHydratedPlainWithContexts<TTable extends TableDef>(
+  execCtx: ExecutionContext,
+  qb: SelectQueryBuilder<unknown, TTable>
+): Promise<Record<string, unknown>[]> {
+  return executePlainWithContexts(execCtx, qb);
+}
 
 const loadLazyRelationsForTable = async <TTable extends TableDef>(
   ctx: EntityContext,

package/src/orm/interceptor-pipeline.ts

@@ -1,12 +1,16 @@
-import type { DbExecutor, QueryResult } from '../core/execution/db-executor.js';
+import type { DbExecutor, ExecutionPayload } from '../core/execution/db-executor.js';
+import { toExecutionPayload } from '../core/execution/db-executor.js';
 
-export interface QueryContext {
+export interface QueryContext {
   sql: string;
   params: unknown[];
   // maybe metadata like entity type, operation type, etc.
-}
-
-export type QueryInterceptor = (ctx: QueryContext, next: () => Promise<QueryResult[]>) => Promise<QueryResult[]>;
+}
+
+export type QueryInterceptor = (
+  ctx: QueryContext,
+  next: () => Promise<ExecutionPayload>
+) => Promise<ExecutionPayload>;
 
 /**
  * Pipeline for query interceptors.
@@ -19,15 +23,15 @@ export class InterceptorPipeline {
     this.interceptors.push(interceptor);
   }
 
-  async run(ctx: QueryContext, executor: DbExecutor): Promise<QueryResult[]> {
-    let i = 0;
-    const dispatch = async (): Promise<QueryResult[]> => {
-      const interceptor = this.interceptors[i++];
-      if (!interceptor) {
-        return executor.executeSql(ctx.sql, ctx.params);
-      }
-      return interceptor(ctx, dispatch);
-    };
-    return dispatch();
-  }
-}
+  async run(ctx: QueryContext, executor: DbExecutor): Promise<ExecutionPayload> {
+    let i = 0;
+    const dispatch = async (): Promise<ExecutionPayload> => {
+      const interceptor = this.interceptors[i++];
+      if (!interceptor) {
+        return toExecutionPayload(await executor.executeSql(ctx.sql, ctx.params));
+      }
+      return toExecutionPayload(await interceptor(ctx, dispatch));
+    };
+    return dispatch();
+  }
+}

package/src/orm/pooled-executor-factory.ts

@@ -1,24 +1,39 @@
-import type { DbExecutor, QueryResult } from '../core/execution/db-executor.js';
-import { rowsToQueryResult } from '../core/execution/db-executor.js';
+import type { DbExecutor, QueryResult } from '../core/execution/db-executor.js';
+import { toExecutionPayload } from '../core/execution/db-executor.js';
+import { rowsToQueryResult } from '../core/execution/db-executor.js';
 import type { Pool } from '../core/execution/pooling/pool.js';
 import type { DbExecutorFactory } from './orm.js';
 
-export interface PooledConnectionAdapter<TConn> {
-    query(
-        conn: TConn,
-        sql: string,
-        params?: unknown[]
-    ): Promise<Array<Record<string, unknown>>>;
+export interface PooledConnectionAdapter<TConn> {
+    query(
+        conn: TConn,
+        sql: string,
+        params?: unknown[]
+    ): Promise<
+      | Array<Record<string, unknown>>
+      | Array<Array<Record<string, unknown>>>
+      | QueryResult[]
+    >;
 
     beginTransaction(conn: TConn): Promise<void>;
     commitTransaction(conn: TConn): Promise<void>;
     rollbackTransaction(conn: TConn): Promise<void>;
 }
 
-type PooledExecutorFactoryOptions<TConn> = {
-    pool: Pool<TConn>;
-    adapter: PooledConnectionAdapter<TConn>;
-};
+type PooledExecutorFactoryOptions<TConn> = {
+    pool: Pool<TConn>;
+    adapter: PooledConnectionAdapter<TConn>;
+};
+
+const isQueryResult = (value: unknown): value is QueryResult =>
+  typeof value === 'object' &&
+  value !== null &&
+  Array.isArray((value as QueryResult).columns) &&
+  Array.isArray((value as QueryResult).values);
+
+const isRowArray = (value: unknown): value is Array<Record<string, unknown>> =>
+  Array.isArray(value) &&
+  value.every(item => typeof item === 'object' && item !== null && !Array.isArray(item));
 
 /**
  * Creates a first-class DbExecutorFactory backed by MetalORM's Pool.
@@ -42,14 +57,20 @@ export function createPooledExecutorFactory<TConn>(
             return lease;
         };
 
-        const executeWithConn = async (
-            conn: TConn,
-            sql: string,
-            params?: unknown[]
-        ): Promise<QueryResult[]> => {
-            const rows = await adapter.query(conn, sql, params);
-            return [rowsToQueryResult(rows)];
-        };
+        const executeWithConn = async (
+            conn: TConn,
+            sql: string,
+            params?: unknown[]
+        ) => {
+            const rows = await adapter.query(conn, sql, params);
+            if (Array.isArray(rows) && rows.length > 0 && rows.every(isQueryResult)) {
+              return toExecutionPayload(rows);
+            }
+            if (Array.isArray(rows) && rows.length > 0 && rows.every(isRowArray)) {
+              return toExecutionPayload(rows.map(set => rowsToQueryResult(set)));
+            }
+            return toExecutionPayload([rowsToQueryResult(rows as Array<Record<string, unknown>>)]);
+        };
 
         return {
             capabilities: { transactions: true },

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

@@ -6,7 +6,8 @@ import { UpdateQueryBuilder } from '../query-builder/update.js';
 import { DeleteQueryBuilder } from '../query-builder/delete.js';
 import { findPrimaryKey } from '../query-builder/hydration-planner.js';
 import type { TableDef, TableHooks } from '../schema/table.js';
-import type { DbExecutor, QueryResult } from '../core/execution/db-executor.js';
+import { payloadResultSets } from '../core/execution/db-executor.js';
+import type { DbExecutor, QueryResult } from '../core/execution/db-executor.js';
 import { IdentityMap } from './identity-map.js';
 import { EntityStatus } from './runtime-types.js';
 import type { TrackedEntity } from './runtime-types.js';
@@ -322,9 +323,10 @@ export class UnitOfWork {
    * @param compiled - The compiled query
    * @returns Query results
    */
-  private async executeCompiled(compiled: CompiledQuery): Promise<QueryResult[]> {
-    return this.executor.executeSql(compiled.sql, compiled.params);
-  }
+  private async executeCompiled(compiled: CompiledQuery): Promise<QueryResult[]> {
+    const payload = await this.executor.executeSql(compiled.sql, compiled.params);
+    return payloadResultSets(payload);
+  }
 
   /**
    * Gets columns for RETURNING clause.

package/src/query/index.ts

@@ -2,7 +2,8 @@ import { TableDef } from '../schema/table.js';
 import { SelectQueryBuilder } from '../query-builder/select.js';
 import { InsertQueryBuilder } from '../query-builder/insert.js';
 import { UpdateQueryBuilder } from '../query-builder/update.js';
-import { DeleteQueryBuilder } from '../query-builder/delete.js';
+import { DeleteQueryBuilder } from '../query-builder/delete.js';
+import { callProcedure } from '../query-builder/procedure-call.js';
 import { QueryTarget, resolveTable } from './target.js';
 
 /**
@@ -68,7 +69,9 @@ export const update = <TTable extends TableDef>(target: QueryTarget<TTable>): Up
  * const query = deleteFrom(UserTable).where(eq(UserTable.id, 1));
  * ```
  */
-export const deleteFrom = <TTable extends TableDef>(target: QueryTarget<TTable>): DeleteQueryBuilder<unknown> => {
-    const table = resolveTable(target);
-    return new DeleteQueryBuilder(table);
-};
+export const deleteFrom = <TTable extends TableDef>(target: QueryTarget<TTable>): DeleteQueryBuilder<unknown> => {
+    const table = resolveTable(target);
+    return new DeleteQueryBuilder(table);
+};
+
+export { callProcedure };

package/src/query-builder/delete.ts

@@ -9,7 +9,7 @@ import { DeleteQueryState } from './delete-query-state.js';
 import { createJoinNode } from '../core/ast/join-node.js';
 import { buildColumnNode } from '../core/ast/builders.js';
 import { OrmSession } from '../orm/orm-session.js';
-import { QueryResult } from '../core/execution/db-executor.js';
+import { payloadResultSets, QueryResult } from '../core/execution/db-executor.js';
 
 type DeleteDialectInput = Dialect | DialectKey;
 
@@ -130,7 +130,8 @@ export class DeleteQueryBuilder<T> {
   async execute(session: OrmSession): Promise<QueryResult[]> {
     const execCtx = session.getExecutionContext();
     const compiled = this.compile(execCtx.dialect);
-    return execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
+    const payload = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
+    return payloadResultSets(payload);
   }
 
   /**

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

@@ -1,18 +1,18 @@
-import { TableDef } from '../schema/table.js';
-import { InsertQueryNode, SelectQueryNode } from '../core/ast/query.js';
+import { TableDef } from '../schema/table.js';
+import { InsertQueryNode, SelectQueryNode, UpsertClause } from '../core/ast/query.js';
 import {
   ColumnNode,
   OperandNode,
   isValueOperandInput,
-  valueToOperand
-} from '../core/ast/expression.js';
-import type { ValueOperandInput } from '../core/ast/expression.js';
+  valueToOperand
+} from '../core/ast/expression.js';
+import type { ValueOperandInput } from '../core/ast/expression.js';
 import {
   buildColumnNodes,
   createTableNode
 } from '../core/ast/builders.js';
 
-type InsertRows = Record<string, ValueOperandInput>[];
+type InsertRows = Record<string, ValueOperandInput>[];
 
 /**
  * Maintains immutable state for building INSERT queries
@@ -68,7 +68,7 @@ export class InsertQueryState {
    * @throws Error if mixing VALUES with SELECT source
    * @throws Error if invalid values are provided
    */
-  withValues(rows: InsertRows): InsertQueryState {
+  withValues(rows: InsertRows): InsertQueryState {
     if (!rows.length) return this;
 
     if (this.ast.source.type === 'InsertSelect') {
@@ -81,11 +81,11 @@ export class InsertQueryState {
       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 string, number, boolean, Date, Buffer, null, or OperandNodes are allowed`
-          );
-        }
+        if (!isValueOperandInput(rawValue)) {
+          throw new Error(
+            `Invalid insert value for column "${column.name}" in row ${rowIndex}: only string, number, boolean, Date, Buffer, null, or OperandNodes are allowed`
+          );
+        }
 
         return valueToOperand(rawValue);
       })
@@ -153,10 +153,38 @@ export class InsertQueryState {
    * @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]
-    });
-  }
-}
+  withReturning(columns: ColumnNode[]): InsertQueryState {
+    return this.clone({
+      ...this.ast,
+      returning: [...columns]
+    });
+  }
+
+  /**
+   * Adds an UPSERT conflict clause to the INSERT query
+   * @param clause - Conflict clause and action
+   * @returns A new InsertQueryState with conflict handling configured
+   */
+  withOnConflict(clause: UpsertClause): InsertQueryState {
+    return this.clone({
+      ...this.ast,
+      onConflict: {
+        target: {
+          columns: [...clause.target.columns],
+          constraint: clause.target.constraint
+        },
+        action:
+          clause.action.type === 'DoUpdate'
+            ? {
+                type: 'DoUpdate',
+                set: clause.action.set.map(assignment => ({
+                  column: { ...assignment.column },
+                  value: assignment.value
+                })),
+                where: clause.action.where
+              }
+            : { type: 'DoNothing' }
+      }
+    });
+  }
+}