metal-orm 1.0.52 → 1.0.54

package/README.md

@@ -250,7 +250,9 @@ console.log(rows);
 // ]
 ```
 
-That’s it: schema, query, SQL, done.
+That’s it: schema, query, SQL, done.
+
+If you are using the Level 2 runtime (`OrmSession`), `SelectQueryBuilder` also provides `count(session)` and `executePaged(session, { page, pageSize })` for common pagination patterns.
 
 #### Column pickers (preferred selection helpers)
 

package/dist/index.cjs

@@ -101,6 +101,7 @@ __export(index_exports, {
   cos: () => cos,
   cot: () => cot,
   count: () => count,
+  countAll: () => countAll,
   createEntityFromRow: () => createEntityFromRow,
   createEntityProxy: () => createEntityProxy,
   createExecutorFromQueryRunner: () => createExecutorFromQueryRunner,
@@ -874,6 +875,11 @@ var sum = buildAggregate("SUM");
 var avg = buildAggregate("AVG");
 var min = buildAggregate("MIN");
 var max = buildAggregate("MAX");
+var countAll = () => ({
+  type: "Function",
+  name: "COUNT",
+  args: []
+});
 var toOrderByNode = (order) => ({
   type: "OrderBy",
   term: columnOperand(order.column),
@@ -1076,7 +1082,7 @@ var StandardFunctionStrategy = class _StandardFunctionStrategy {
     this.registerStandard();
   }
   registerStandard() {
-    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]})`);
@@ -2571,9 +2577,9 @@ var SqlServerDialect = class extends SqlDialectBase {
       return expr;
     }).join(", ");
     const distinct = ast.distinct ? "DISTINCT " : "";
-    const from = this.compileTableSource(ast.from);
+    const from = this.compileFrom(ast.from, ctx);
     const joins = ast.joins.map((j) => {
-      const table = this.compileTableSource(j.table);
+      const table = this.compileFrom(j.table, ctx);
       const cond = this.compileExpression(j.condition, ctx);
       return `${j.kind} JOIN ${table} ON ${cond}`;
     }).join(" ");
@@ -5002,10 +5008,10 @@ var flattenResults = (results) => {
   }
   return rows;
 };
-var executeWithEntityContext = async (entityCtx, qb) => {
+var executeWithContexts = async (execCtx, entityCtx, qb) => {
   const ast = qb.getAST();
-  const compiled = entityCtx.dialect.compileSelect(ast);
-  const executed = await entityCtx.executor.executeSql(compiled.sql, compiled.params);
+  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()));
@@ -5014,14 +5020,14 @@ var executeWithEntityContext = async (entityCtx, qb) => {
   return hydrated.map((row) => createEntityFromRow(entityCtx, qb.getTable(), row, qb.getLazyRelations()));
 };
 async function executeHydrated(session, qb) {
-  return executeWithEntityContext(session, qb);
+  return executeWithContexts(session.getExecutionContext(), session, qb);
 }
-async function executeHydratedWithContexts(_execCtx, hydCtx, qb) {
+async function executeHydratedWithContexts(execCtx, hydCtx, qb) {
   const entityCtx = hydCtx.entityContext;
   if (!entityCtx) {
     throw new Error("Hydration context is missing an EntityContext");
   }
-  return executeWithEntityContext(entityCtx, qb);
+  return executeWithContexts(execCtx, entityCtx, qb);
 }
 
 // src/query-builder/query-resolution.ts
@@ -5375,6 +5381,52 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
   async execute(ctx) {
     return executeHydrated(ctx, this);
   }
+  withAst(ast) {
+    const nextState = new SelectQueryState(this.env.table, ast);
+    const nextContext = {
+      ...this.context,
+      state: nextState
+    };
+    return this.clone(nextContext);
+  }
+  async count(session) {
+    const unpagedAst = {
+      ...this.context.state.ast,
+      orderBy: void 0,
+      limit: void 0,
+      offset: void 0
+    };
+    const subAst = this.withAst(unpagedAst).getAST();
+    const countQuery = {
+      type: "SelectQuery",
+      from: derivedTable(subAst, "__metal_count"),
+      columns: [{ type: "Function", name: "COUNT", args: [], alias: "total" }],
+      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 === void 0 ? 0 : Number(value);
+  }
+  async executePaged(session, options) {
+    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
@@ -6224,8 +6276,9 @@ var UpdateQueryBuilder = class _UpdateQueryBuilder {
    * @returns A promise that resolves to the query results
    */
   async execute(session) {
-    const compiled = this.compile(session.dialect);
-    return session.executor.executeSql(compiled.sql, compiled.params);
+    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
@@ -6409,8 +6462,9 @@ var DeleteQueryBuilder = class _DeleteQueryBuilder {
    * @returns A promise that resolves to the query results
    */
   async execute(session) {
-    const compiled = this.compile(session.dialect);
-    return session.executor.executeSql(compiled.sql, compiled.params);
+    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
@@ -10923,6 +10977,7 @@ function createPooledExecutorFactory(opts) {
   cos,
   cot,
   count,
+  countAll,
   createEntityFromRow,
   createEntityProxy,
   createExecutorFromQueryRunner,