metal-orm 1.0.52 → 1.0.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.52",
+  "version": "1.0.53",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

package/src/core/ast/aggregate-functions.ts

@@ -45,6 +45,16 @@ export const min = buildAggregate('MIN');
  */
 export const max = buildAggregate('MAX');
 
+/**
+ * Creates a COUNT(*) function expression.
+ * @returns Function node with COUNT(*)
+ */
+export const countAll = (): FunctionNode => ({
+  type: 'Function',
+  name: 'COUNT',
+  args: []
+});
+
 type GroupConcatOrderByInput = {
   column: ColumnRef | ColumnNode;
   direction?: OrderDirection;

package/src/core/functions/standard-strategy.ts

@@ -16,7 +16,7 @@ export class StandardFunctionStrategy implements FunctionStrategy {
 
     protected registerStandard() {
         // Register ANSI standard implementations
-        this.add('COUNT', ({ compiledArgs }) => `COUNT(${compiledArgs.join(', ')})`);
+        this.add('COUNT', ({ compiledArgs }) => compiledArgs.length ? `COUNT(${compiledArgs.join(', ')})` : 'COUNT(*)');
         this.add('SUM', ({ compiledArgs }) => `SUM(${compiledArgs[0]})`);
         this.add('AVG', ({ compiledArgs }) => `AVG(${compiledArgs[0]})`);
         this.add('MIN', ({ compiledArgs }) => `MIN(${compiledArgs[0]})`);

package/src/orm/execute.ts

@@ -3,14 +3,14 @@ import { EntityInstance } from '../schema/types.js';
 import { hydrateRows } from './hydration.js';
 import { OrmSession } from './orm-session.ts';
 import { SelectQueryBuilder } from '../query-builder/select.js';
-import { createEntityProxy, createEntityFromRow } from './entity.js';
-import { EntityContext } from './entity-context.js';
-import { ExecutionContext } from './execution-context.js';
-import { HydrationContext } from './hydration-context.js';
+import { createEntityProxy, createEntityFromRow } from './entity.js';
+import { EntityContext } from './entity-context.js';
+import { ExecutionContext } from './execution-context.js';
+import { HydrationContext } from './hydration-context.js';
 
 type Row = Record<string, unknown>;
 
-const flattenResults = (results: { columns: string[]; values: unknown[][] }[]): Row[] => {
+const flattenResults = (results: { columns: string[]; values: unknown[][] }[]): Row[] => {
   const rows: Row[] = [];
   for (const result of results) {
     const { columns, values } = result;
@@ -23,20 +23,21 @@ const flattenResults = (results: { columns: string[]; values: unknown[][] }[]):
     }
   }
   return rows;
-};
-
-const executeWithEntityContext = async <TTable extends TableDef>(
-  entityCtx: EntityContext,
-  qb: SelectQueryBuilder<unknown, TTable>
-): Promise<EntityInstance<TTable>[]> => {
-  const ast = qb.getAST();
-  const compiled = entityCtx.dialect.compileSelect(ast);
-  const executed = await entityCtx.executor.executeSql(compiled.sql, compiled.params);
-  const rows = flattenResults(executed);
-
-  if (ast.setOps && ast.setOps.length > 0) {
-    return rows.map(row => createEntityProxy(entityCtx, qb.getTable(), row, qb.getLazyRelations()));
-  }
+};
+
+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);
+
+  if (ast.setOps && ast.setOps.length > 0) {
+    return rows.map(row => createEntityProxy(entityCtx, qb.getTable(), row, qb.getLazyRelations()));
+  }
 
   const hydrated = hydrateRows(rows, qb.getHydrationPlan());
   return hydrated.map(row => createEntityFromRow(entityCtx, qb.getTable(), row, qb.getLazyRelations()));
@@ -49,12 +50,12 @@ const executeWithEntityContext = 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 executeWithEntityContext(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 using execution and hydration contexts.
@@ -64,14 +65,14 @@ export async function executeHydrated<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 executeWithEntityContext(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);
+}

package/src/orm/save-graph-types.ts

@@ -27,12 +27,11 @@ type ColumnKeys<T> = Exclude<keyof T & string, FunctionKeys<T> | RelationKeys<T>
 export type SaveGraphJsonScalar<T> = T extends Date ? string : T;
 
 /**
- * Input scalar type that accepts JSON-friendly values for common runtime types.
- * Currently:
- * - Date fields accept `Date | string` (ISO string recommended)
+ * Input scalar type for `OrmSession.saveGraph` payloads.
+ *
+ * Note: runtime coercion is opt-in via `SaveGraphOptions.coerce`.
  */
-export type SaveGraphInputScalar<T> =
-  T extends Date ? Date | string : T;
+export type SaveGraphInputScalar<T> = T;
 
 type ColumnInput<TEntity> = {
   [K in ColumnKeys<TEntity>]?: SaveGraphInputScalar<TEntity[K]>;
@@ -52,6 +51,5 @@ type RelationInput<TEntity> = {
 /**
  * Typed payload accepted by `OrmSession.saveGraph`:
  * - Only entity scalar keys + relation keys are accepted.
- * - Scalars can use JSON-friendly values (e.g., Date fields accept ISO strings).
  */
 export type SaveGraphInputPayload<TEntity> = ColumnInput<TEntity> & RelationInput<TEntity>;

package/src/query-builder/delete.ts

@@ -127,10 +127,11 @@ export class DeleteQueryBuilder<T> {
    * @param session - The ORM session to execute the query with
    * @returns A promise that resolves to the query results
    */
-  async execute(session: OrmSession): Promise<QueryResult[]> {
-    const compiled = this.compile(session.dialect);
-    return session.executor.executeSql(compiled.sql, compiled.params);
-  }
+  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);
+  }
 
   /**
    * Returns the Abstract Syntax Tree (AST) representation of the query

package/src/query-builder/select.ts

@@ -533,16 +533,74 @@ export class SelectQueryBuilder<T = unknown, TTable extends TableDef = TableDef>
    * @param ctx - ORM session context
    * @returns Promise of entity instances
    */
-  async execute(ctx: OrmSession): Promise<EntityInstance<TTable>[]> {
-    return executeHydrated(ctx, this);
-  }
-
-  /**
-   * Executes the query with provided execution and hydration contexts
-   * @param execCtx - Execution context
-   * @param hydCtx - Hydration context
-   * @returns Promise of entity instances
-   */
+  async execute(ctx: OrmSession): Promise<EntityInstance<TTable>[]> {
+    return executeHydrated(ctx, this);
+  }
+
+  private withAst(ast: SelectQueryNode): SelectQueryBuilder<T, TTable> {
+    const nextState = new SelectQueryState(this.env.table as TTable, ast);
+    const nextContext: SelectQueryBuilderContext = {
+      ...this.context,
+      state: nextState
+    };
+    return this.clone(nextContext);
+  }
+
+  async count(session: OrmSession): Promise<number> {
+    const unpagedAst: SelectQueryNode = {
+      ...this.context.state.ast,
+      orderBy: undefined,
+      limit: undefined,
+      offset: undefined
+    };
+
+    const subAst = this.withAst(unpagedAst).getAST();
+
+    const countQuery: SelectQueryNode = {
+      type: 'SelectQuery',
+      from: derivedTable(subAst, '__metal_count'),
+      columns: [{ type: 'Function', name: 'COUNT', args: [], alias: 'total' } as FunctionNode],
+      joins: []
+    };
+
+    const execCtx = session.getExecutionContext();
+    const compiled = execCtx.dialect.compileSelect(countQuery);
+    const results = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
+    const value = results[0]?.values?.[0]?.[0];
+
+    if (typeof value === 'number') return value;
+    if (typeof value === 'bigint') return Number(value);
+    if (typeof value === 'string') return Number(value);
+    return value === null || value === undefined ? 0 : Number(value);
+  }
+
+  async executePaged(
+    session: OrmSession,
+    options: { page: number; pageSize: number }
+  ): Promise<{ items: EntityInstance<TTable>[]; totalItems: number }> {
+    const { page, pageSize } = options;
+    if (!Number.isInteger(page) || page < 1) {
+      throw new Error('executePaged: page must be an integer >= 1');
+    }
+    if (!Number.isInteger(pageSize) || pageSize < 1) {
+      throw new Error('executePaged: pageSize must be an integer >= 1');
+    }
+
+    const offset = (page - 1) * pageSize;
+    const [items, totalItems] = await Promise.all([
+      this.limit(pageSize).offset(offset).execute(session),
+      this.count(session)
+    ]);
+
+    return { items, totalItems };
+  }
+
+  /**
+   * Executes the query with provided execution and hydration contexts
+   * @param execCtx - Execution context
+   * @param hydCtx - Hydration context
+   * @returns Promise of entity instances
+   */
   async executeWithContexts(execCtx: ExecutionContext, hydCtx: HydrationContext): Promise<EntityInstance<TTable>[]> {
     return executeHydratedWithContexts(execCtx, hydCtx, this);
   }

package/src/query-builder/update.ts

@@ -137,10 +137,11 @@ export class UpdateQueryBuilder<T> {
    * @param session - The ORM session to execute the query with
    * @returns A promise that resolves to the query results
    */
-  async execute(session: OrmSession): Promise<QueryResult[]> {
-    const compiled = this.compile(session.dialect);
-    return session.executor.executeSql(compiled.sql, compiled.params);
-  }
+  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);
+  }
 
   /**
    * Returns the Abstract Syntax Tree (AST) representation of the query