metal-orm 1.1.10 → 1.1.16

package/src/orm/orm.ts

@@ -9,7 +9,7 @@ import type { QueryCacheManager } from '../cache/query-cache-manager.js';
 import type { Duration, CacheProvider, CacheStrategy } from '../cache/index.js';
 import { QueryCacheManager as QueryCacheManagerImpl } from '../cache/query-cache-manager.js';
 import { DefaultCacheStrategy } from '../cache/strategies/default-cache-strategy.js';
-
+
 /**
  * Options for creating an ORM instance.
  */
@@ -37,29 +37,29 @@ export interface OrmCacheOptions {
   /** Default TTL for cached queries (e.g., '1h', '30m') */
   defaultTtl?: Duration;
 }
-
-/**
- * Database executor factory interface.
- */
-export interface DbExecutorFactory {
-  /**
-   * Creates a database executor.
-   * @returns The database executor
-   */
-  createExecutor(): DbExecutor;
-
-  /**
-   * Creates a transactional database executor.
-   * @returns The transactional database executor
-   */
-  createTransactionalExecutor(): DbExecutor;
-
-  /**
-   * Disposes any underlying resources (connection pools, background timers, etc).
-   */
-  dispose(): Promise<void>;
-}
-
+
+/**
+ * Database executor factory interface.
+ */
+export interface DbExecutorFactory {
+  /**
+   * Creates a database executor.
+   * @returns The database executor
+   */
+  createExecutor(): DbExecutor;
+
+  /**
+   * Creates a transactional database executor.
+   * @returns The transactional database executor
+   */
+  createTransactionalExecutor(): DbExecutor;
+
+  /**
+   * Disposes any underlying resources (connection pools, background timers, etc).
+   */
+  dispose(): Promise<void>;
+}
+
 /**
  * ORM (Object-Relational Mapping) main class.
  * @template E - The domain event type
@@ -94,7 +94,7 @@ export class Orm<E extends DomainEvent = OrmDomainEvent> {
       );
     }
   }
-
+
   /**
    * Creates a new ORM session.
    * @param options - Optional session options (e.g., tenantId for multi-tenancy)
@@ -110,7 +110,7 @@ export class Orm<E extends DomainEvent = OrmDomainEvent> {
       tenantId: options?.tenantId
     });
   }
-
+
   /**
    * Executes a function within a transaction.
    * @template T - The return type
@@ -132,11 +132,11 @@ export class Orm<E extends DomainEvent = OrmDomainEvent> {
       await session.dispose();
     }
   }
-
-  /**
-   * Shuts down the ORM and releases underlying resources (pools, timers).
-   */
-  async dispose(): Promise<void> {
-    await this.executorFactory.dispose();
-  }
-}
+
+  /**
+   * Shuts down the ORM and releases underlying resources (pools, timers).
+   */
+  async dispose(): Promise<void> {
+    await this.executorFactory.dispose();
+  }
+}

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

@@ -1,20 +1,20 @@
-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';
-
+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>>
-      | Array<Array<Record<string, unknown>>>
-      | QueryResult[]
-    >;
-
+    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>;
@@ -22,32 +22,32 @@ export interface PooledConnectionAdapter<TConn> {
     releaseSavepoint?(conn: TConn, name: string): Promise<void>;
     rollbackToSavepoint?(conn: TConn, name: string): Promise<void>;
 }
-
-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.
- *
- * Design goals:
- * - No leaks by default: pool leases are always released in `finally`.
- * - Correct transactions: one leased connection per transaction.
- * - Session-friendly: createExecutor() supports transactions without permanently leasing a connection.
- */
-export function createPooledExecutorFactory<TConn>(
-    opts: PooledExecutorFactoryOptions<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.
+ *
+ * Design goals:
+ * - No leaks by default: pool leases are always released in `finally`.
+ * - Correct transactions: one leased connection per transaction.
+ * - Session-friendly: createExecutor() supports transactions without permanently leasing a connection.
+ */
+export function createPooledExecutorFactory<TConn>(
+    opts: PooledExecutorFactoryOptions<TConn>
 ): DbExecutorFactory {
     const { pool, adapter } = opts;
     const supportsSavepoints =
@@ -57,24 +57,24 @@ export function createPooledExecutorFactory<TConn>(
 
     const makeExecutor = (mode: 'session' | 'sticky'): DbExecutor => {
         let lease: Awaited<ReturnType<typeof pool.acquire>> | null = null;
-
-        const getLease = async () => {
-            if (lease) return lease;
-            lease = await pool.acquire();
-            return lease;
-        };
-
+
+        const getLease = async () => {
+            if (lease) return lease;
+            lease = await pool.acquire();
+            return lease;
+        };
+
         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)));
+        ) => {
+            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>>)]);
         };
@@ -91,56 +91,56 @@ export function createPooledExecutorFactory<TConn>(
                 transactions: true,
                 ...(supportsSavepoints ? { savepoints: true } : {}),
             },
-
-            async executeSql(sql, params) {
-                // Sticky mode: always reuse a leased connection.
-                if (mode === 'sticky') {
-                    const l = await getLease();
-                    return executeWithConn(l.resource, sql, params);
-                }
-
-                // Session mode: use the leased connection if we're currently in a transaction;
-                // otherwise acquire/release per call.
-                if (lease) {
-                    return executeWithConn(lease.resource, sql, params);
-                }
-
-                const l = await pool.acquire();
-                try {
-                    return await executeWithConn(l.resource, sql, params);
-                } finally {
-                    await l.release();
-                }
-            },
-
-            async beginTransaction() {
-                const l = await getLease();
-                await adapter.beginTransaction(l.resource);
-            },
-
-            async commitTransaction() {
-                if (!lease) {
-                    throw new Error('commitTransaction called without an active transaction');
-                }
-                const l = lease;
-                try {
-                    await adapter.commitTransaction(l.resource);
-                } finally {
-                    lease = null;
-                    await l.release();
-                }
-            },
-
+
+            async executeSql(sql, params) {
+                // Sticky mode: always reuse a leased connection.
+                if (mode === 'sticky') {
+                    const l = await getLease();
+                    return executeWithConn(l.resource, sql, params);
+                }
+
+                // Session mode: use the leased connection if we're currently in a transaction;
+                // otherwise acquire/release per call.
+                if (lease) {
+                    return executeWithConn(lease.resource, sql, params);
+                }
+
+                const l = await pool.acquire();
+                try {
+                    return await executeWithConn(l.resource, sql, params);
+                } finally {
+                    await l.release();
+                }
+            },
+
+            async beginTransaction() {
+                const l = await getLease();
+                await adapter.beginTransaction(l.resource);
+            },
+
+            async commitTransaction() {
+                if (!lease) {
+                    throw new Error('commitTransaction called without an active transaction');
+                }
+                const l = lease;
+                try {
+                    await adapter.commitTransaction(l.resource);
+                } finally {
+                    lease = null;
+                    await l.release();
+                }
+            },
+
             async rollbackTransaction() {
                 if (!lease) {
                     // Nothing to rollback; keep idempotent semantics.
                     return;
                 }
-                const l = lease;
-                try {
-                    await adapter.rollbackTransaction(l.resource);
-                } finally {
-                    lease = null;
+                const l = lease;
+                try {
+                    await adapter.rollbackTransaction(l.resource);
+                } finally {
+                    lease = null;
                     await l.release();
                 }
             },
@@ -171,23 +171,23 @@ export function createPooledExecutorFactory<TConn>(
 
             async dispose() {
                 if (!lease) return;
-                const l = lease;
-                lease = null;
-                await l.release();
-            },
-        };
-    };
-
-    return {
-        createExecutor() {
-            return makeExecutor('session');
-        },
-        createTransactionalExecutor() {
-            return makeExecutor('sticky');
-        },
-        async dispose() {
-            await pool.destroy();
-        },
-    };
-}
-
+                const l = lease;
+                lease = null;
+                await l.release();
+            },
+        };
+    };
+
+    return {
+        createExecutor() {
+            return makeExecutor('session');
+        },
+        createTransactionalExecutor() {
+            return makeExecutor('sticky');
+        },
+        async dispose() {
+            await pool.destroy();
+        },
+    };
+}
+

package/src/orm/query-logger.ts

@@ -1,40 +1,40 @@
-import type { DbExecutor } from '../core/execution/db-executor.js';
-
-/**
- * Represents a single SQL query log entry
- */
-export interface QueryLogEntry {
-  /** The SQL query that was executed */
-  sql: string;
-  /** Parameters used in the query */
-  params?: unknown[];
-}
-
-/**
- * Function type for query logging callbacks
- * @param entry - The query log entry to process
- */
-export type QueryLogger = (entry: QueryLogEntry) => void;
-
-/**
- * Creates a wrapped database executor that logs all SQL queries
- * @param executor - Original database executor to wrap
- * @param logger - Optional logger function to receive query log entries
- * @returns Wrapped executor that logs queries before execution
- */
-export const createQueryLoggingExecutor = (
-  executor: DbExecutor,
-  logger?: QueryLogger
-): DbExecutor => {
-  if (!logger) {
-    return executor;
-  }
-
-  const wrapped: DbExecutor = {
-    capabilities: executor.capabilities,
-    async executeSql(sql, params) {
-      logger({ sql, params });
-      return executor.executeSql(sql, params);
+import type { DbExecutor } from '../core/execution/db-executor.js';
+
+/**
+ * Represents a single SQL query log entry
+ */
+export interface QueryLogEntry {
+  /** The SQL query that was executed */
+  sql: string;
+  /** Parameters used in the query */
+  params?: unknown[];
+}
+
+/**
+ * Function type for query logging callbacks
+ * @param entry - The query log entry to process
+ */
+export type QueryLogger = (entry: QueryLogEntry) => void;
+
+/**
+ * Creates a wrapped database executor that logs all SQL queries
+ * @param executor - Original database executor to wrap
+ * @param logger - Optional logger function to receive query log entries
+ * @returns Wrapped executor that logs queries before execution
+ */
+export const createQueryLoggingExecutor = (
+  executor: DbExecutor,
+  logger?: QueryLogger
+): DbExecutor => {
+  if (!logger) {
+    return executor;
+  }
+
+  const wrapped: DbExecutor = {
+    capabilities: executor.capabilities,
+    async executeSql(sql, params) {
+      logger({ sql, params });
+      return executor.executeSql(sql, params);
     }
     ,
     beginTransaction: () => executor.beginTransaction(),
@@ -51,6 +51,6 @@ export const createQueryLoggingExecutor = (
       : undefined,
     dispose: () => executor.dispose(),
   };
-
-  return wrapped;
-};
+
+  return wrapped;
+};