turbine-orm 0.74.0 → 0.75.0

package/dist/cjs/powdb.d.ts

@@ -54,6 +54,7 @@
  */
 import { type PgCompatPool, type PgCompatPoolClient, TurbineClient, type TurbineConfig } from './client.js';
 import { type Dialect } from './dialect.js';
+import type { EngineClientConfig } from './engine-config.js';
 import type { PowdbExec } from './powdb-introspect.js';
 import { type ColumnMetadata, type SchemaMetadata, type TableMetadata } from './schema.js';
 /**
@@ -932,8 +933,22 @@ export declare class PowdbEmbeddedPool implements PgCompatPool {
 }
 export { introspectPowdbDatabase, type PowdbExec, type PowdbIntrospectOptions, } from './powdb-introspect.js';
 export { PowqlInterface } from './powql.js';
-/** Options for {@link turbinePowDB}. */
-export interface TurbinePowdbOptions extends Pick<TurbineConfig, 'logging' | 'defaultLimit' | 'warnOnUnlimited' | 'relationLoadStrategy'> {
+/**
+ * Options for {@link turbinePowDB}.
+ *
+ * Extends {@link EngineClientConfig}, the same inverted default the SQL engine
+ * factories use: every `TurbineConfig` option reaches the client unless it is one
+ * of the transport keys declared below, which {@link turbinePowDB} destructures
+ * out before spreading. This used to be a four-key `Pick`, so `globalFilters`,
+ * `stableRelationOrder`, `errorMessages` and everything else added after PowDB
+ * landed were accepted by the type and then dropped on the floor. A tenant filter
+ * that silently does not apply is the worst shape that class of bug can take.
+ *
+ * Options that PowDB cannot honour by CAPABILITY (rather than by plumbing) still
+ * throw a typed `UnsupportedFeatureError` (E017) at the point of use, which is a
+ * better answer than an option the type system claims does not exist.
+ */
+export interface TurbinePowdbOptions extends EngineClientConfig {
     /**
      * Client-level default `with`-relation load strategy. On PowDB the default is
      * the batched N+1 loaders; setting `'join'` opts INTO native PowQL server-side

package/dist/cjs/powdb.js

@@ -2408,14 +2408,16 @@ async function turbinePowDB(target, schema, options = {}) {
     // The PowQL generator is loaded here to keep client.ts free of any PowDB import.
     const { PowqlInterface } = await Promise.resolve().then(() => __importStar(require('./powql.js')));
     const queryInterfaceFactory = (p, table, sch, middlewares, opts) => new PowqlInterface(p, table, sch, middlewares, opts);
+    // Forward every client-level option EXCEPT the ones this factory owns (they
+    // configure the pool / transport above, and TurbineClient warns on a config
+    // key it does not recognize). Destructured rather than hand-listed on the way
+    // IN: an allowlist is how `globalFilters` came to be accepted and ignored.
+    const { connectionLimit: _connectionLimit, transactionQueueTimeoutMs: _transactionQueueTimeoutMs, retryStaleReads: _retryStaleReads, assumeEngineVersion: _assumeEngineVersion, readonly: _readonly, powdbClientModule: _powdbClientModule, powdbEmbeddedModule: _powdbEmbeddedModule, ...clientConfig } = options;
     const client = new client_js_1.TurbineClient({
+        ...clientConfig,
         pool,
         preparedStatements: false,
         dialect: exports.powdbDialect,
-        logging: options.logging,
-        defaultLimit: options.defaultLimit,
-        warnOnUnlimited: options.warnOnUnlimited,
-        relationLoadStrategy: options.relationLoadStrategy,
         queryInterfaceFactory,
     }, schema);
     if (owns) {

package/dist/cjs/powql.js

@@ -3113,17 +3113,56 @@ class PowqlInterface {
             const aggOrderExprs = new Map();
             const aggInner = new Map();
             let aggN = 0;
-            // Parity with the SQL builder (query/builder.ts): `_count` is selected by
-            // DEFAULT unless the caller explicitly opts out with `_count: false`, so
-            // every groupBy row carries `_count` and `orderBy: { _count }` works
-            // without requesting it (the alias is seeded into `aggOrderExprs`).
-            const countSelected = args._count === true || args._count === undefined;
-            if (countSelected) {
+            // `_count` has the same two shapes as the SQL groupBy (query/aggregates.ts),
+            // and the record form is why this is not a one-liner:
+            //   - `true` / omitted → scalar `_count` (row count). Selected by DEFAULT
+            //     unless the caller opts out with `_count: false`, so every groupBy row
+            //     carries `_count` and `orderBy: { _count }` works without requesting it.
+            //   - record form → `_all` is the row count and each field is that column's
+            //     NON-NULL count, result `_count: { _all, field }`.
+            // The record form used to fall through both branches here, so PowDB answered
+            // `groupBy({ _count: { id: true } })` with the group keys and NO `_count` key
+            // at all while every SQL engine returned the counts. Accepted and ignored is
+            // the one outcome an aggregate must never have: the caller reads
+            // `g._count.id` off a row that never carried it.
+            const countArg = args._count;
+            const scalarCount = countArg === true || countArg === undefined;
+            const countIsRecord = !scalarCount && countArg !== false && typeof countArg === 'object';
+            if (scalarCount) {
                 const alias = `agg_${aggN++}`;
                 proj.push(`${alias}: count(*)`);
                 aggReaders.push({ alias, outKey: '_count', numeric: true });
                 aggOrderExprs.set('_count', `.${alias}`);
             }
+            else if (countIsRecord) {
+                for (const [field, enabled] of Object.entries(countArg)) {
+                    if (!enabled)
+                        continue;
+                    const alias = `agg_${aggN++}`;
+                    if (field === '_all') {
+                        // Double underscore in the output key, collision-proof against a
+                        // real column named `all`, exactly as the SQL builder aliases it.
+                        claim('_count__all', '_count `_all`');
+                        proj.push(`${alias}: count(*)`);
+                        aggReaders.push({ alias, outKey: '_count:_all', numeric: true });
+                        // COUNT(*) is orderable whenever it is selected: the scalar form
+                        // above, or the record form containing `_all`. Same rule as SQL.
+                        aggOrderExprs.set('_count', `.${alias}`);
+                    }
+                    else {
+                        // Per-field count is the NON-NULL count, which the engine only
+                        // honours from the version `projectedCountSupported` gates on; below
+                        // it the projection was ignored and the ROW count came back. Same
+                        // per-column gate `aggregate()` applies, for the same reason.
+                        const col = this.column(field);
+                        this.assertProjectedCountSupported(field);
+                        claim(`_count_${col.name}`, `_count of column "${col.name}"`);
+                        const inner = this.colRefName(col.name);
+                        proj.push(`${alias}: count(${inner})`);
+                        aggReaders.push({ alias, outKey: `_count:${col.field}`, numeric: true });
+                    }
+                }
+            }
             for (const fn of ['_sum', '_avg', '_min', '_max']) {
                 const spec = args[fn];
                 if (!spec)

package/dist/cjs/serverless.d.ts

@@ -82,11 +82,23 @@ import { type PgCompatPool, TurbineClient, type TurbineConfig } from './client.j
 import type { SchemaMetadata } from './schema.js';
 export type { PgCompatPool, PgCompatPoolClient, PgCompatQueryResult } from './client.js';
 /**
- * Options for `turbineHttp()`. Mirrors the fields of `TurbineConfig`
- * that are relevant for externally-managed pools.
+ * Options for `turbineHttp()`: everything a `TurbineClient` takes except the
+ * pool, which is this function's first argument.
+ *
+ * This used to be a three-key `Pick` (`logging` / `defaultLimit` /
+ * `warnOnUnlimited`), which made the accepted set an ALLOWLIST that stopped
+ * being maintained the day it was written. The runtime already spread the whole
+ * object through, so the effect was purely at the type level: a serverless
+ * caller passing `globalFilters` (or `errorMessages`, or `relationLoadStrategy`)
+ * got an excess-property error on an option that would have worked. That is a
+ * kinder failure than PowDB's silent drop, but the same allowlist, and it lands
+ * on the edge deployments where a tenant filter matters most.
+ *
+ * Deliberately `Omit<TurbineConfig, 'pool'>` rather than `EngineClientConfig`:
+ * unlike the SQL engine factories, this one binds no dialect and pins no
+ * prepared-statement mode, so it has no business narrowing those away.
  */
-export interface TurbineHttpOptions extends Pick<TurbineConfig, 'logging' | 'defaultLimit' | 'warnOnUnlimited'> {
-}
+export type TurbineHttpOptions = Omit<TurbineConfig, 'pool'>;
 /**
  * Create a TurbineClient bound to an external pg-compatible pool.
  *

package/dist/powdb.d.ts

@@ -54,6 +54,7 @@
  */
 import { type PgCompatPool, type PgCompatPoolClient, TurbineClient, type TurbineConfig } from './client.js';
 import { type Dialect } from './dialect.js';
+import type { EngineClientConfig } from './engine-config.js';
 import type { PowdbExec } from './powdb-introspect.js';
 import { type ColumnMetadata, type SchemaMetadata, type TableMetadata } from './schema.js';
 /**
@@ -932,8 +933,22 @@ export declare class PowdbEmbeddedPool implements PgCompatPool {
 }
 export { introspectPowdbDatabase, type PowdbExec, type PowdbIntrospectOptions, } from './powdb-introspect.js';
 export { PowqlInterface } from './powql.js';
-/** Options for {@link turbinePowDB}. */
-export interface TurbinePowdbOptions extends Pick<TurbineConfig, 'logging' | 'defaultLimit' | 'warnOnUnlimited' | 'relationLoadStrategy'> {
+/**
+ * Options for {@link turbinePowDB}.
+ *
+ * Extends {@link EngineClientConfig}, the same inverted default the SQL engine
+ * factories use: every `TurbineConfig` option reaches the client unless it is one
+ * of the transport keys declared below, which {@link turbinePowDB} destructures
+ * out before spreading. This used to be a four-key `Pick`, so `globalFilters`,
+ * `stableRelationOrder`, `errorMessages` and everything else added after PowDB
+ * landed were accepted by the type and then dropped on the floor. A tenant filter
+ * that silently does not apply is the worst shape that class of bug can take.
+ *
+ * Options that PowDB cannot honour by CAPABILITY (rather than by plumbing) still
+ * throw a typed `UnsupportedFeatureError` (E017) at the point of use, which is a
+ * better answer than an option the type system claims does not exist.
+ */
+export interface TurbinePowdbOptions extends EngineClientConfig {
     /**
      * Client-level default `with`-relation load strategy. On PowDB the default is
      * the batched N+1 loaders; setting `'join'` opts INTO native PowQL server-side

package/dist/powdb.js

@@ -2342,14 +2342,16 @@ export async function turbinePowDB(target, schema, options = {}) {
     // The PowQL generator is loaded here to keep client.ts free of any PowDB import.
     const { PowqlInterface } = await import('./powql.js');
     const queryInterfaceFactory = (p, table, sch, middlewares, opts) => new PowqlInterface(p, table, sch, middlewares, opts);
+    // Forward every client-level option EXCEPT the ones this factory owns (they
+    // configure the pool / transport above, and TurbineClient warns on a config
+    // key it does not recognize). Destructured rather than hand-listed on the way
+    // IN: an allowlist is how `globalFilters` came to be accepted and ignored.
+    const { connectionLimit: _connectionLimit, transactionQueueTimeoutMs: _transactionQueueTimeoutMs, retryStaleReads: _retryStaleReads, assumeEngineVersion: _assumeEngineVersion, readonly: _readonly, powdbClientModule: _powdbClientModule, powdbEmbeddedModule: _powdbEmbeddedModule, ...clientConfig } = options;
     const client = new TurbineClient({
+        ...clientConfig,
         pool,
         preparedStatements: false,
         dialect: powdbDialect,
-        logging: options.logging,
-        defaultLimit: options.defaultLimit,
-        warnOnUnlimited: options.warnOnUnlimited,
-        relationLoadStrategy: options.relationLoadStrategy,
         queryInterfaceFactory,
     }, schema);
     if (owns) {

package/dist/powql.js

@@ -3077,17 +3077,56 @@ export class PowqlInterface {
             const aggOrderExprs = new Map();
             const aggInner = new Map();
             let aggN = 0;
-            // Parity with the SQL builder (query/builder.ts): `_count` is selected by
-            // DEFAULT unless the caller explicitly opts out with `_count: false`, so
-            // every groupBy row carries `_count` and `orderBy: { _count }` works
-            // without requesting it (the alias is seeded into `aggOrderExprs`).
-            const countSelected = args._count === true || args._count === undefined;
-            if (countSelected) {
+            // `_count` has the same two shapes as the SQL groupBy (query/aggregates.ts),
+            // and the record form is why this is not a one-liner:
+            //   - `true` / omitted → scalar `_count` (row count). Selected by DEFAULT
+            //     unless the caller opts out with `_count: false`, so every groupBy row
+            //     carries `_count` and `orderBy: { _count }` works without requesting it.
+            //   - record form → `_all` is the row count and each field is that column's
+            //     NON-NULL count, result `_count: { _all, field }`.
+            // The record form used to fall through both branches here, so PowDB answered
+            // `groupBy({ _count: { id: true } })` with the group keys and NO `_count` key
+            // at all while every SQL engine returned the counts. Accepted and ignored is
+            // the one outcome an aggregate must never have: the caller reads
+            // `g._count.id` off a row that never carried it.
+            const countArg = args._count;
+            const scalarCount = countArg === true || countArg === undefined;
+            const countIsRecord = !scalarCount && countArg !== false && typeof countArg === 'object';
+            if (scalarCount) {
                 const alias = `agg_${aggN++}`;
                 proj.push(`${alias}: count(*)`);
                 aggReaders.push({ alias, outKey: '_count', numeric: true });
                 aggOrderExprs.set('_count', `.${alias}`);
             }
+            else if (countIsRecord) {
+                for (const [field, enabled] of Object.entries(countArg)) {
+                    if (!enabled)
+                        continue;
+                    const alias = `agg_${aggN++}`;
+                    if (field === '_all') {
+                        // Double underscore in the output key, collision-proof against a
+                        // real column named `all`, exactly as the SQL builder aliases it.
+                        claim('_count__all', '_count `_all`');
+                        proj.push(`${alias}: count(*)`);
+                        aggReaders.push({ alias, outKey: '_count:_all', numeric: true });
+                        // COUNT(*) is orderable whenever it is selected: the scalar form
+                        // above, or the record form containing `_all`. Same rule as SQL.
+                        aggOrderExprs.set('_count', `.${alias}`);
+                    }
+                    else {
+                        // Per-field count is the NON-NULL count, which the engine only
+                        // honours from the version `projectedCountSupported` gates on; below
+                        // it the projection was ignored and the ROW count came back. Same
+                        // per-column gate `aggregate()` applies, for the same reason.
+                        const col = this.column(field);
+                        this.assertProjectedCountSupported(field);
+                        claim(`_count_${col.name}`, `_count of column "${col.name}"`);
+                        const inner = this.colRefName(col.name);
+                        proj.push(`${alias}: count(${inner})`);
+                        aggReaders.push({ alias, outKey: `_count:${col.field}`, numeric: true });
+                    }
+                }
+            }
             for (const fn of ['_sum', '_avg', '_min', '_max']) {
                 const spec = args[fn];
                 if (!spec)

package/dist/serverless.d.ts

@@ -82,11 +82,23 @@ import { type PgCompatPool, TurbineClient, type TurbineConfig } from './client.j
 import type { SchemaMetadata } from './schema.js';
 export type { PgCompatPool, PgCompatPoolClient, PgCompatQueryResult } from './client.js';
 /**
- * Options for `turbineHttp()`. Mirrors the fields of `TurbineConfig`
- * that are relevant for externally-managed pools.
+ * Options for `turbineHttp()`: everything a `TurbineClient` takes except the
+ * pool, which is this function's first argument.
+ *
+ * This used to be a three-key `Pick` (`logging` / `defaultLimit` /
+ * `warnOnUnlimited`), which made the accepted set an ALLOWLIST that stopped
+ * being maintained the day it was written. The runtime already spread the whole
+ * object through, so the effect was purely at the type level: a serverless
+ * caller passing `globalFilters` (or `errorMessages`, or `relationLoadStrategy`)
+ * got an excess-property error on an option that would have worked. That is a
+ * kinder failure than PowDB's silent drop, but the same allowlist, and it lands
+ * on the edge deployments where a tenant filter matters most.
+ *
+ * Deliberately `Omit<TurbineConfig, 'pool'>` rather than `EngineClientConfig`:
+ * unlike the SQL engine factories, this one binds no dialect and pins no
+ * prepared-statement mode, so it has no business narrowing those away.
  */
-export interface TurbineHttpOptions extends Pick<TurbineConfig, 'logging' | 'defaultLimit' | 'warnOnUnlimited'> {
-}
+export type TurbineHttpOptions = Omit<TurbineConfig, 'pool'>;
 /**
  * Create a TurbineClient bound to an external pg-compatible pool.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.74.0",
+  "version": "0.75.0",
   "description": "Postgres-native TypeScript ORM, runs on Neon, Vercel Postgres, Cloudflare, Supabase. Streaming cursors, typed errors, single-query nested relations. One dependency, no WASM engine",
   "type": "module",
   "//exports": "Each subpath declares its types PER CONDITION. A single shared top-level \"types\" resolves to the ESM declarations for `require` too, which is TS1479 (\"is an ES module ... cannot be require()d\") for any CJS consumer on moduleResolution node16/nodenext. The require condition points at dist/cjs, which ships its own {\"type\":\"commonjs\"} package.json, so those declarations are CJS declarations. Gated in CI by publint + @arethetypeswrong/cli + a real .cts consumer typecheck (see the package-types job in ci.yml).",