fastify-auto-sqlapi 0.1.14 → 0.2.1

package/dist/lib/condition-methods.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"condition-methods.d.ts","sourceRoot":"","sources":["../../src/lib/condition-methods.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,oBAAoB,wNAKvB,CAAC;AAEX,eAAO,MAAM,eAAe,wCAAyC,CAAC;AACtE,eAAO,MAAM,UAAU,8BAA+B,CAAC;AACvD,eAAO,MAAM,YAAY,kCAAmC,CAAC;AAE7D,eAAO,MAAM,eAAe,+RAElB,CAAC;AAGX,eAAO,MAAM,gBAAgB,aAAwC,CAAC;AACtE,eAAO,MAAM,WAAW,aAAmC,CAAC;AAC5D,eAAO,MAAM,MAAM,aAA8B,CAAC;AAClD,eAAO,MAAM,QAAQ,aAAgC,CAAC;AACtD,eAAO,MAAM,WAAW,aAAmC,CAAC"}
+{"version":3,"file":"condition-methods.d.ts","sourceRoot":"","sources":["../../src/lib/condition-methods.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,eAAe,+RAElB,CAAC;AAGX,eAAO,MAAM,gBAAgB,aAAwC,CAAC;AACtE,eAAO,MAAM,WAAW,aAAmC,CAAC;AAC5D,eAAO,MAAM,MAAM,aAA8B,CAAC;AAClD,eAAO,MAAM,QAAQ,aAAgC,CAAC;AACtD,eAAO,MAAM,WAAW,aAAmC,CAAC;AAE5D;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,MAAM,CAAC;AAElC,yFAAyF;AACzF,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAErC,+FAA+F;AAC/F,eAAO,MAAM,mBAAmB,OAAO,CAAC"}

package/dist/lib/condition-methods.js

@@ -1,14 +1,14 @@
 // Allowed ConditionBuilder methods for the `conditions` search API.
 // Single source of truth for both schema validation (Swagger) and runtime whitelist.
-export const SINGLE_VALUE_METHODS = [
+const SINGLE_VALUE_METHODS = [
     'isEqual', 'isNotEqual',
     'isGreater', 'isNotGreater', 'isGreaterOrEqual', 'isNotGreaterOrEqual',
     'isLess', 'isNotLess', 'isLessOrEqual', 'isNotLessOrEqual',
     'isLike', 'isNotLike', 'isILike', 'isNotILike',
 ];
-export const BETWEEN_METHODS = ['isBetween', 'isNotBetween'];
-export const IN_METHODS = ['isIn', 'isNotIn'];
-export const NULL_METHODS = ['isNull', 'isNotNull'];
+const BETWEEN_METHODS = ['isBetween', 'isNotBetween'];
+const IN_METHODS = ['isIn', 'isNotIn'];
+const NULL_METHODS = ['isNull', 'isNotNull'];
 export const ALLOWED_METHODS = [
     ...SINGLE_VALUE_METHODS, ...BETWEEN_METHODS, ...IN_METHODS, ...NULL_METHODS,
 ];
@@ -18,3 +18,17 @@ export const BETWEEN_SET = new Set(BETWEEN_METHODS);
 export const IN_SET = new Set(IN_METHODS);
 export const NULL_SET = new Set(NULL_METHODS);
 export const ALLOWED_SET = new Set(ALLOWED_METHODS);
+/**
+ * Caps on how much work one search request may ask for.
+ *
+ * Every dotted condition and every 3-part `orderBy` token becomes its own correlated subquery,
+ * so an uncapped list turns a single request into arbitrarily many — `maxItemsPerPage` bounds
+ * the rows returned, not the work done to find them. They live here, in the data module both
+ * the engine and the TypeBox schema builders already share, so the request schema advertises
+ * exactly the limit the engine enforces.
+ */
+export const MAX_CONDITIONS = 100;
+/** Token cap the engine applies to `orderBy`, counted over its comma-separated parts. */
+export const MAX_ORDER_BY_PARTS = 20;
+/** Character cap the request schema applies to `orderBy` — generous for MAX_ORDER_BY_PARTS. */
+export const MAX_ORDER_BY_LENGTH = 1024;

package/dist/lib/db.d.ts

@@ -37,9 +37,14 @@ export declare class QueryClient {
     insert(table: string, record: DbRecord, pkCol: string | string[]): Promise<Record<string, unknown>>;
     insertOrUpdate(table: string, record: DbRecord, conflictKeys: string[], pkCol: string | string[]): Promise<Record<string, unknown>>;
     bulkInsert(table: string, records: DbRecord[], pkCol: string | string[], chunkSize?: number): Promise<Record<string, unknown>[]>;
-    bulkInsertOrUpdate(table: string, records: DbRecord[], conflictKeys: string[], pkCol: string | string[], chunkSize?: number): Promise<Record<string, unknown>[]>;
+    /**
+     * `immutableCols` are written when the row is inserted but left untouched when the statement
+     * lands on an existing row — like the conflict keys, which are never in the update set either.
+     * Used by tenant isolation to keep an upsert from re-assigning a row's owner.
+     */
+    bulkInsertOrUpdate(table: string, records: DbRecord[], conflictKeys: string[], pkCol: string | string[], chunkSize?: number, immutableCols?: string[]): Promise<Record<string, unknown>[]>;
     update(table: string, record: DbRecord, where: DbRecord, extraCondition?: ConditionBuilder): Promise<number>;
-    delete(table: string, where: DbRecord): Promise<number>;
+    delete(table: string, where: DbRecord, extraCondition?: ConditionBuilder): Promise<number>;
     select<T = Record<string, unknown>>({ tableName, columns, where, values, limit, orderBy, joins, distinct, }: SelectOptions): Promise<T[]>;
 }
 export declare function createQueryClient(pool: Queryable, dialectName?: string): QueryClient;

package/dist/lib/db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/lib/db.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/lib/db.ts"],"names":[],"mappings":"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"}

package/dist/lib/db.js

@@ -195,11 +195,17 @@ export class QueryClient {
         }
         return results;
     }
-    async bulkInsertOrUpdate(table, records, conflictKeys, pkCol, chunkSize = DEFAULT_CHUNK_SIZE) {
+    /**
+     * `immutableCols` are written when the row is inserted but left untouched when the statement
+     * lands on an existing row — like the conflict keys, which are never in the update set either.
+     * Used by tenant isolation to keep an upsert from re-assigning a row's owner.
+     */
+    async bulkInsertOrUpdate(table, records, conflictKeys, pkCol, chunkSize = DEFAULT_CHUNK_SIZE, immutableCols = []) {
         if (!records.length)
             return [];
         const fields = Object.keys(records[0]);
-        const upsertClause = this.dialect.upsertSql(this.#q(conflictKeys), this.dialect.upsertUpdateSet(fields, conflictKeys));
+        const keepAsIs = immutableCols.length ? [...conflictKeys, ...immutableCols] : conflictKeys;
+        const upsertClause = this.dialect.upsertSql(this.#q(conflictKeys), this.dialect.upsertUpdateSet(fields, keepAsIs));
         const returning = this.dialect.returningPk(this.#quotedPkCols(pkCol));
         const results = [];
         for (let i = 0; i < records.length; i += chunkSize) {
@@ -221,16 +227,28 @@ export class QueryClient {
             extraWhere = ` AND ${extraCondition.build(values.length + 1, this.dialect.ph)}`;
             values.push(...extraCondition.getValues());
         }
+        const setClause = setF.map((f, i) => `${this.dialect.qi(f)} = ${setP[i]}`).join(', ');
+        const whereClause = whereF
+            .map((f, i) => `${this.dialect.qi(f)} = ${whereP[i]}`)
+            .join(' AND ');
         const result = await this.query(`UPDATE ${this.dialect.qi(table)}
-       SET ${setF.map((f, i) => `${this.dialect.qi(f)} = ${setP[i]}`).join(', ')}
-       WHERE ${whereF.map((f, i) => `${this.dialect.qi(f)} = ${whereP[i]}`).join(' AND ')}${extraWhere}`, values);
+       SET ${setClause}
+       WHERE ${whereClause}${extraWhere}`, values);
         return result.affectedRows;
     }
-    async delete(table, where) {
+    async delete(table, where, extraCondition) {
         const values = [];
         const { fields, placeholders } = this.#params(where, values);
+        let extraWhere = '';
+        if (extraCondition) {
+            extraWhere = ` AND ${extraCondition.build(values.length + 1, this.dialect.ph)}`;
+            values.push(...extraCondition.getValues());
+        }
+        const whereClause = fields
+            .map((f, i) => `${this.dialect.qi(f)} = ${placeholders[i]}`)
+            .join(' AND ');
         const result = await this.query(`DELETE FROM ${this.dialect.qi(table)}
-       WHERE ${fields.map((f, i) => `${this.dialect.qi(f)} = ${placeholders[i]}`).join(' AND ')}`, values);
+       WHERE ${whereClause}${extraWhere}`, values);
         return result.affectedRows;
     }
     async select({ tableName, columns = '*', where, values, limit = null, orderBy = '', joins = [], distinct = false, }) {

package/dist/lib/dialect.d.ts

@@ -1,5 +1,5 @@
 export type DialectName = 'postgres' | 'mysql' | 'mariadb';
-export type TruncateUnit = 'year' | 'quarter' | 'month' | 'day' | 'hour';
+type TruncateUnit = 'year' | 'quarter' | 'month' | 'day' | 'hour';
 export interface SqlDialect {
     name: DialectName;
     /** Quote identifier: "id" (postgres) or `id` (mysql/mariadb) */
@@ -31,4 +31,5 @@ export interface SqlDialect {
     dateTrunc(unit: TruncateUnit, qualifiedCol: string): string;
 }
 export declare function getDialect(name: DialectName): SqlDialect;
+export {};
 //# sourceMappingURL=dialect.d.ts.map

package/dist/lib/dialect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dialect.d.ts","sourceRoot":"","sources":["../../src/lib/dialect.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,OAAO,GAAG,SAAS,CAAC;AAE3D,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;AAEzE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,WAAW,CAAC;IAClB,gEAAgE;IAChE,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,sDAAsD;IACtD,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B,oCAAoC;IACpC,SAAS,EAAE,UAAU,GAAG,OAAO,CAAC;IAChC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,4CAA4C;IAC5C,SAAS,CAAC,kBAAkB,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAAC;IACvE,8CAA8C;IAC9C,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IACzC;;;;;;OAMG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IAClE;;;;;;OAMG;IACH,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;CAC7D;AAqFD,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,CAIxD"}
+{"version":3,"file":"dialect.d.ts","sourceRoot":"","sources":["../../src/lib/dialect.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,OAAO,GAAG,SAAS,CAAC;AAE3D,KAAK,YAAY,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;AAElE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,WAAW,CAAC;IAClB,gEAAgE;IAChE,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,sDAAsD;IACtD,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B,oCAAoC;IACpC,SAAS,EAAE,UAAU,GAAG,OAAO,CAAC;IAChC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,4CAA4C;IAC5C,SAAS,CAAC,kBAAkB,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAAC;IACvE,8CAA8C;IAC9C,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IACzC;;;;;;OAMG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IAClE;;;;;;OAMG;IACH,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;CAC7D;AAqFD,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,CAIxD"}

package/dist/lib/engine/bulk/bulk-upsert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bulk-upsert.d.ts","sourceRoot":"","sources":["../../../../src/lib/engine/bulk/bulk-upsert.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAEjB,MAAM,mBAAmB,CAAC;AAE3B,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAoF5F"}
+{"version":3,"file":"bulk-upsert.d.ts","sourceRoot":"","sources":["../../../../src/lib/engine/bulk/bulk-upsert.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAEV,gBAAgB,EAChB,gBAAgB,EAEjB,MAAM,mBAAmB,CAAC;AA+D3B,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA0C5F"}

package/dist/lib/engine/bulk/bulk-upsert.js

@@ -1,10 +1,48 @@
 import { camelcaseObject } from '../../naming.js';
 import { processSecondaries, processDeletions, prepareInsertRecord } from '../write-helpers.js';
-import { enforceTenantOnWrites, assertTenantOwnsConflicts } from '../../tenant.js';
+import { enforceTenantOnWrites, assertTenantOwnsConflicts, tenantImmutableColumns, } from '../../tenant.js';
 import { runBulkValidation } from '../validate.js';
 import { primaryAsCols } from '../../../types.js';
+/** One bulk statement for every main row, returning the PKs only. */
+function upsertMains(params, preparedMains, pkCol) {
+    const { db, tableConf, tenant } = params;
+    const schema = tableConf.Schema;
+    const upsertKeys = tableConf.upsertMap?.get(schema);
+    if (!upsertKeys) {
+        return db.bulkInsert(schema.tableName, preparedMains, pkCol);
+    }
+    const conflictCols = upsertKeys.map((k) => schema.col(k));
+    // Tenant isolation: a conflicting upsert must not overwrite rows owned by another tenant, nor
+    // re-assign the owner of a row it legitimately updates.
+    return assertTenantOwnsConflicts(db, tenant, schema.tableName, conflictCols, preparedMains)
+        .then(() => db.bulkInsertOrUpdate(schema.tableName, preparedMains, conflictCols, pkCol, undefined, tenantImmutableColumns(tenant)));
+}
+/** Secondaries, deletions and the afterInsert hook for one upserted item. */
+async function finalizeUpsertedItem(params, item, inputMain, pkRow) {
+    const { db, tableConf, dbTables, request, tenant } = params;
+    // pkRow comes from SQL RETURNING or mysql insertId synthesis — keys are DB column names;
+    // camelcaseObject maps them back to schema fields (full composite PK).
+    const mainPkCamel = camelcaseObject(pkRow, tableConf.Schema);
+    const result = { main: mainPkCamel };
+    // FK auto-fill: input camelCase + generated PK
+    const mainForFK = { ...inputMain, ...mainPkCamel };
+    if (item.secondaries && Object.keys(item.secondaries).length > 0) {
+        const sec = await processSecondaries({ db, tableConf, dbTables, mainRecord: mainForFK, tenant }, item.secondaries);
+        if (Object.keys(sec).length > 0)
+            result.secondaries = sec;
+    }
+    if (item.deletions && Object.keys(item.deletions).length > 0) {
+        const del = await processDeletions({ db, tableConf, dbTables, mainRecord: mainForFK, tenant }, item.deletions);
+        if (Object.keys(del).length > 0)
+            result.deletions = del;
+    }
+    if (tableConf.afterInsert) {
+        await tableConf.afterInsert(db, request, mainForFK, result.secondaries);
+    }
+    return result;
+}
 export async function bulkUpsertEngine(params) {
-    const { db, tableConf, dbTables, request, items, tenant } = params;
+    const { db, tableConf, request, items, tenant } = params;
     if (!items.length)
         return [];
     const schema = tableConf.Schema;
@@ -22,42 +60,12 @@ export async function bulkUpsertEngine(params) {
     // 3. Tenant: inject (direct) or batch-validate FK (indirect) — enforced after user mutations
     await enforceTenantOnWrites(db, tenant, preparedMains);
     // 4. Bulk upsert all mains in one query → returns PK-only
-    const upsertKeys = tableConf.upsertMap?.get(schema);
-    let pkRows;
-    if (upsertKeys) {
-        const conflictCols = upsertKeys.map((k) => schema.col(k));
-        // Tenant isolation: a conflicting upsert must not overwrite rows owned by another tenant.
-        await assertTenantOwnsConflicts(db, tenant, schema.tableName, conflictCols, preparedMains);
-        pkRows = await db.bulkInsertOrUpdate(schema.tableName, preparedMains, conflictCols, pkCol);
-    }
-    else {
-        pkRows = await db.bulkInsert(schema.tableName, preparedMains, pkCol);
-    }
-    // 5. Process secondaries, deletions, afterInsert per item (all camelCase)
+    const pkRows = await upsertMains(params, preparedMains, pkCol);
+    // 5-6. Secondaries, deletions and afterInsert per item — sequential on purpose, so hooks
+    //      observe the same order the caller sent, and errors surface on the first bad item.
     const results = [];
     for (let i = 0; i < items.length; i++) {
-        const item = items[i];
-        // pkRows entries come from SQL RETURNING or mysql insertId synthesis — keys are DB
-        // column names; camelcaseObject maps them back to schema fields (full composite PK).
-        const mainPkCamel = camelcaseObject(pkRows[i], schema);
-        const result = { main: mainPkCamel };
-        // FK auto-fill: input camelCase + generated PK
-        const mainForFK = { ...inputMains[i], ...mainPkCamel };
-        if (item.secondaries && Object.keys(item.secondaries).length > 0) {
-            const sec = await processSecondaries(db, tableConf, dbTables, mainForFK, item.secondaries);
-            if (Object.keys(sec).length > 0)
-                result.secondaries = sec;
-        }
-        if (item.deletions && Object.keys(item.deletions).length > 0) {
-            const del = await processDeletions(db, tableConf, mainForFK, item.deletions);
-            if (Object.keys(del).length > 0)
-                result.deletions = del;
-        }
-        // 6. afterInsert hook per item (camelCase)
-        if (tableConf.afterInsert) {
-            await tableConf.afterInsert(db, request, mainForFK, result.secondaries);
-        }
-        results.push(result);
+        results.push(await finalizeUpsertedItem(params, items[i], inputMains[i], pkRows[i]));
     }
     return results;
 }

package/dist/lib/engine/rest/delete.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../../src/lib/engine/rest/delete.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAY,MAAM,mBAAmB,CAAC;AAE9E,wBAAsB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAuC9E"}
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../../src/lib/engine/rest/delete.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEpE,wBAAsB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAuC9E"}

package/dist/lib/engine/rest/get.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../../src/lib/engine/rest/get.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAuB,MAAM,mBAAmB,CAAC;AAEnF,wBAAsB,SAAS,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC,CAsCrE"}
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../../src/lib/engine/rest/get.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9D,wBAAsB,SAAS,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC,CAuCrE"}

package/dist/lib/engine/rest/get.js

@@ -15,10 +15,11 @@ export async function getEngine(params) {
     // shared with the through table would be ambiguous.
     cb.isEqual(`${db.qi(tableConf.Schema.tableName)}.${db.qi(pkCol)}`, id);
     const joins = [];
-    if (tenant) {
-        cb.append(buildTenantCondition(db, tenant.scope, tenant.ids, tableConf.Schema.tableName));
-        if ('through' in tenant.scope) {
-            joins.push(buildTenantJoin(db, tenant.scope, tableConf.Schema.tableName));
+    if (tenant?.scope) {
+        const scope = tenant.scope;
+        cb.append(buildTenantCondition(db, scope, tenant.ids, tableConf.Schema.tableName));
+        if ('through' in scope) {
+            joins.push(buildTenantJoin(db, scope, tableConf.Schema.tableName));
         }
     }
     const where = cb.build(1, db.ph);

package/dist/lib/engine/rest/insert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../../../../src/lib/engine/rest/insert.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EAEb,MAAM,mBAAmB,CAAC;AAE3B,wBAAsB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAiE9E"}
+{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../../../../src/lib/engine/rest/insert.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EAEb,MAAM,mBAAmB,CAAC;AAE3B,wBAAsB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAmE9E"}

package/dist/lib/engine/rest/insert.js

@@ -32,7 +32,7 @@ export async function insertEngine(params) {
         let secondaryResults;
         if (secondaries && Object.keys(secondaries).length > 0) {
             const mainForFK = { ...inputRecord, ...mainPkCamel };
-            secondaryResults = await processSecondaries(tx, tableConf, dbTables, mainForFK, secondaries);
+            secondaryResults = await processSecondaries({ db: tx, tableConf, dbTables, mainRecord: mainForFK, tenant }, secondaries);
         }
         // 5. afterInsert hook (camelCase — input merged with generated PK)
         if (tableConf.afterInsert) {

package/dist/lib/engine/rest/update.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../../src/lib/engine/rest/update.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EAEb,MAAM,mBAAmB,CAAC;AAE3B,wBAAsB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAwH9E"}
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../../src/lib/engine/rest/update.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EAEb,MAAM,mBAAmB,CAAC;AAiC3B,wBAAsB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CA2G9E"}

package/dist/lib/engine/rest/update.js

@@ -3,6 +3,28 @@ import { processSecondaries, processDeletions } from '../write-helpers.js';
 import { stripTenantColumn, assertTenantOwnership, buildTenantUpdateExtra, enforceTenantFKOnUpdate, } from '../../tenant.js';
 import { runValidation } from '../validate.js';
 import { httpError } from '../../errors.js';
+/**
+ * Confirm the row exists — and is visible to this tenant — when the request carries no
+ * updatable fields. Secondaries and deletions still need the main row to be there, and a
+ * missing one must be a 404 rather than a silent success.
+ */
+async function assertRecordExists(tx, tableName, pkCols, pkValues, extraCondition) {
+    const whereParts = pkCols.map((c, i) => `${tx.qi(tableName)}.${tx.qi(c)} = ${tx.ph(i + 1)}`);
+    let whereSql = whereParts.join(' AND ');
+    const whereValues = [...pkValues];
+    if (extraCondition) {
+        whereSql += ` AND ${extraCondition.build(pkCols.length + 1, tx.ph)}`;
+        whereValues.push(...extraCondition.getValues());
+    }
+    const rows = await tx.select({
+        tableName,
+        where: whereSql,
+        values: whereValues,
+        limit: '1',
+    });
+    if (rows.length === 0)
+        throw httpError(404, `Record not found`);
+}
 export async function updateEngine(params) {
     const { db, tableConf, dbTables, request, record, secondaries, deletions, tenant } = params;
     const schema = tableConf.Schema;
@@ -32,7 +54,7 @@ export async function updateEngine(params) {
     // 6. Strip tenant column (user cannot change tenant of an existing record).
     //    For indirect scopes the tenant link is the through-FK (localField): it may be changed,
     //    but only to another value the caller owns — re-validate the new FK against the tenant.
-    if (tenant) {
+    if (tenant?.scope) {
         stripTenantColumn(updateFields, tenant.scope);
         await enforceTenantFKOnUpdate(db, tenant, updateFields);
     }
@@ -50,22 +72,7 @@ export async function updateEngine(params) {
                 throw httpError(404, `Record not found`);
         }
         else {
-            // No fields to update: verify the record exists (for secondaries/deletions)
-            const whereParts = pkCols.map((c, i) => `${tx.qi(schema.tableName)}.${tx.qi(c)} = ${tx.ph(i + 1)}`);
-            let whereSql = whereParts.join(' AND ');
-            const whereValues = [...pkValues];
-            if (extraCondition) {
-                whereSql += ` AND ${extraCondition.build(pkCols.length + 1, tx.ph)}`;
-                whereValues.push(...extraCondition.getValues());
-            }
-            const rows = await tx.select({
-                tableName: schema.tableName,
-                where: whereSql,
-                values: whereValues,
-                limit: '1',
-            });
-            if (rows.length === 0)
-                throw httpError(404, `Record not found`);
+            await assertRecordExists(tx, schema.tableName, pkCols, pkValues, extraCondition);
         }
         // Build the main response (PK-only — every PK field)
         const mainResult = Object.fromEntries(pkFields.map((f, i) => [f, pkValues[i]]));
@@ -73,13 +80,13 @@ export async function updateEngine(params) {
         let secondaryResults;
         if (secondaries && Object.keys(secondaries).length > 0) {
             const mainForFK = { ...inputRecord };
-            secondaryResults = await processSecondaries(tx, tableConf, dbTables, mainForFK, secondaries);
+            secondaryResults = await processSecondaries({ db: tx, tableConf, dbTables, mainRecord: mainForFK, tenant }, secondaries);
         }
         // 9. Deletions (FK auto-fill from main like secondaries)
         let deletionResults;
         if (deletions && Object.keys(deletions).length > 0) {
             const mainForFK = { ...inputRecord };
-            deletionResults = await processDeletions(tx, tableConf, mainForFK, deletions);
+            deletionResults = await processDeletions({ db: tx, tableConf, dbTables, mainRecord: mainForFK, tenant }, deletions);
         }
         // 10. afterUpdate hook (inside the transaction: throwing rolls everything back)
         if (tableConf.afterUpdate) {

package/dist/lib/engine/search/aggregations.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Correlated aggregate subqueries — the machinery behind `<alias>.<fn>.<field>` in both
+ * `orderBy` and `conditions` (HAVING-style).
+ *
+ * Kept separate from ./conditions.ts on purpose: an aggregate embeds a join-reference
+ * condition, while a dotted condition embeds an aggregate. Holding both in one module would
+ * be fine, but splitting them the other way round (aggregates with orderBy) would make
+ * order-by and conditions import each other.
+ */
+import { Expression } from 'node-condition-builder';
+import type { QueryClient } from '../../db.js';
+import type { QueryParams } from '../query-params.js';
+import type { DbTables, ITable, JoinGroupRequest, SearchCondition, TenantContext } from '../../../types.js';
+export interface AggFn {
+    sql: string;
+    distinct: boolean;
+}
+export declare const AGG_FN: Record<string, AggFn>;
+export declare function aggExpr(fn: AggFn, qualifiedCol: string): string;
+/**
+ * Correlated aggregate subquery for `<alias>.<fn>.<field>`, as an Expression carrying the
+ * values of its optional filter. Markers are `?`, so whoever embeds it — a ConditionBuilder
+ * or an ORDER BY list — decides the placeholder positions.
+ *
+ * The subquery carries the join table's own tenant scope, exactly as `executeJoinGroup` does
+ * for the aggregations it returns. Without it, ordering and HAVING-style filtering would count
+ * child rows of other tenants, disagreeing with the scoped `result.joinGroup` for the same
+ * alias and leaking their existence.
+ */
+export declare function buildAggOrderExpr(db: QueryClient, dbTables: DbTables, tableConf: ITable, alias: string, fn: string, field: string, joinGroup: Record<string, JoinGroupRequest> | undefined, tenant?: TenantContext): Expression;
+/** HAVING-style conditions: the dotted `<alias>.<fn>.<field>` entries of `conditions`. */
+export declare function appendAggConditions(params: QueryParams, conditions: SearchCondition[], db: QueryClient, dbTables: DbTables, tableConf: ITable, joinGroup: Record<string, JoinGroupRequest> | undefined, tenant?: TenantContext): string;
+//# sourceMappingURL=aggregations.d.ts.map

package/dist/lib/engine/search/aggregations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregations.d.ts","sourceRoot":"","sources":["../../../../src/lib/engine/search/aggregations.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAoB,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAMtD,OAAO,KAAK,EACV,QAAQ,EACR,MAAM,EACN,gBAAgB,EAChB,eAAe,EACf,aAAa,EACd,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,KAAK;IAAG,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE;AAEzD,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAOxC,CAAC;AAEF,wBAAgB,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,WAAW,EACf,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,SAAS,EACvD,MAAM,CAAC,EAAE,aAAa,GACrB,UAAU,CAgEZ;AAED,0FAA0F;AAC1F,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,eAAe,EAAE,EAC7B,EAAE,EAAE,WAAW,EACf,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,SAAS,EACvD,MAAM,CAAC,EAAE,aAAa,GACrB,MAAM,CAyBR"}

package/dist/lib/engine/search/aggregations.js

@@ -0,0 +1,109 @@
+/**
+ * Correlated aggregate subqueries — the machinery behind `<alias>.<fn>.<field>` in both
+ * `orderBy` and `conditions` (HAVING-style).
+ *
+ * Kept separate from ./conditions.ts on purpose: an aggregate embeds a join-reference
+ * condition, while a dotted condition embeds an aggregate. Holding both in one module would
+ * be fine, but splitting them the other way round (aggregates with orderBy) would make
+ * order-by and conditions import each other.
+ */
+import { ConditionBuilder, Expression } from 'node-condition-builder';
+import { ALLOWED_SET } from '../../condition-methods.js';
+import { tenantForTable, buildTenantRowGuard } from '../../tenant.js';
+import { err400, validateSchemaField } from './fields.js';
+import { requireJoin, extractJoinRefs, subqueryAlias } from './joins.js';
+import { buildJoinRefCondition, dispatchConditionMethod } from './conditions.js';
+export const AGG_FN = {
+    sum: { sql: 'SUM', distinct: false },
+    min: { sql: 'MIN', distinct: false },
+    max: { sql: 'MAX', distinct: false },
+    avg: { sql: 'AVG', distinct: false },
+    count: { sql: 'COUNT', distinct: false },
+    distinctCount: { sql: 'COUNT', distinct: true },
+};
+export function aggExpr(fn, qualifiedCol) {
+    return fn.distinct ? `COUNT(DISTINCT ${qualifiedCol})` : `${fn.sql}(${qualifiedCol})`;
+}
+/**
+ * Correlated aggregate subquery for `<alias>.<fn>.<field>`, as an Expression carrying the
+ * values of its optional filter. Markers are `?`, so whoever embeds it — a ConditionBuilder
+ * or an ORDER BY list — decides the placeholder positions.
+ *
+ * The subquery carries the join table's own tenant scope, exactly as `executeJoinGroup` does
+ * for the aggregations it returns. Without it, ordering and HAVING-style filtering would count
+ * child rows of other tenants, disagreeing with the scoped `result.joinGroup` for the same
+ * alias and leaking their existence.
+ */
+export function buildAggOrderExpr(db, dbTables, tableConf, alias, fn, field, joinGroup, tenant) {
+    const aggFn = AGG_FN[fn];
+    if (!aggFn)
+        err400(`Invalid aggregation function: ${fn}`);
+    const groupReq = joinGroup?.[alias];
+    if (!groupReq)
+        err400(`orderBy/conditions reference undeclared joinGroup: ${alias}`);
+    const declaredFields = groupReq.aggregations[fn];
+    if (!Array.isArray(declaredFields) || !declaredFields.includes(field)) {
+        err400(`orderBy/conditions reference undeclared aggregation: ${alias}.${fn}.${field}`);
+    }
+    const joinDef = requireJoin(tableConf, alias, false);
+    const { joinSchema, joinField } = joinDef;
+    if (groupReq.aggregations.by && groupReq.aggregations.by !== joinField) {
+        err400(`Cannot order by aggregation on joinGroup with 'by' clause on non-FK column: ${alias} (grouped by '${groupReq.aggregations.by}', correlation FK is '${joinField}')`);
+    }
+    // Pass the join table's conf: without it validateSchemaField skips the readExclude
+    // check, and a HAVING-style condition on a hidden field becomes a 400-vs-200 oracle
+    // (executeJoinGroup's own validation is skipped when the main result set is empty).
+    const fieldCol = validateSchemaField(field, joinSchema, dbTables[joinSchema.tableName]);
+    const refs = extractJoinRefs(db, tableConf, joinDef);
+    // The subquery FROM is aliased so the correlation to the outer table survives a
+    // self-referencing relation; everything inside references the alias.
+    const subAlias = subqueryAlias(alias, tableConf);
+    const subRef = db.qi(subAlias);
+    let filterWhere = '';
+    let filterVals = [];
+    const joinTableConf = dbTables[joinSchema.tableName];
+    // Tenant scope first: it is emitted before the request's own filter, so its values must be
+    // bound in that order too.
+    const guard = buildTenantRowGuard(db, tenantForTable(tenant, joinTableConf), subAlias);
+    let tenantWhere = '';
+    const tenantVals = [];
+    if (guard) {
+        const rendered = guard.toExpression();
+        tenantWhere = ` AND ${rendered.value}`;
+        tenantVals.push(...rendered.values);
+    }
+    if (groupReq.filters || groupReq.conditions?.length) {
+        const cb = buildJoinRefCondition(joinTableConf, joinSchema, { filters: groupReq.filters, conditions: groupReq.conditions }, db, subAlias);
+        const fragment = cb.toExpression();
+        if (fragment.value) {
+            filterWhere = ` AND ${fragment.value}`;
+            filterVals = [...fragment.values];
+        }
+    }
+    const qualifiedCol = `${subRef}.${db.qi(fieldCol)}`;
+    const expr = `COALESCE((SELECT ${aggExpr(aggFn, qualifiedCol)} FROM ${refs.joinTable} AS ${subRef} WHERE ${subRef}.${refs.fkCol} = ${refs.mainTable}.${refs.mainCol}${tenantWhere}${filterWhere}), 0)`;
+    return new Expression(expr, [...tenantVals, ...filterVals]);
+}
+/** HAVING-style conditions: the dotted `<alias>.<fn>.<field>` entries of `conditions`. */
+export function appendAggConditions(params, conditions, db, dbTables, tableConf, joinGroup, tenant) {
+    let where = '';
+    for (const c of conditions) {
+        if (!c.field.includes('.'))
+            continue;
+        if (!ALLOWED_SET.has(c.method)) {
+            err400(`Invalid condition method: ${c.method}`);
+        }
+        const parts = c.field.split('.');
+        if (parts.length !== 3) {
+            err400(`Invalid dotted field in condition: ${c.field} (expected <alias>.<fn>.<field>)`);
+        }
+        const [alias, fn, field] = parts;
+        // The aggregate carries the values of its own filter; passing it as the left-hand side
+        // lets the ConditionBuilder place those and the compared value in one step.
+        const expr = buildAggOrderExpr(db, dbTables, tableConf, alias, fn, field, joinGroup, tenant);
+        const tmpCb = new ConditionBuilder('AND', db.cbDialect);
+        dispatchConditionMethod(tmpCb, c.method, expr, c.params);
+        where += ` AND ${params.emitCondition(tmpCb, db)}`;
+    }
+    return where;
+}

package/dist/lib/engine/search/conditions.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Turning a request's `filters` and `conditions` into ConditionBuilder clauses.
+ *
+ * The method vocabulary itself lives in lib/condition-methods.ts, which is a pure data
+ * module shared with the TypeBox schema builders — the dispatch below is kept out of it so
+ * that module keeps its zero dependencies.
+ */
+import { ConditionBuilder, Expression } from 'node-condition-builder';
+import type { QueryClient } from '../../db.js';
+import type { FilterRecord, ITable, JoinRefFilter, SchemaDefinition, SearchCondition } from '../../../types.js';
+/**
+ * Apply one condition method to a builder, after checking the request actually supplied the
+ * operands that method needs.
+ *
+ * `params` is optional in the request schema, so `{field, method}` with no params is a
+ * well-formed request that reaches here — reading `params[0]` off it throws a TypeError the
+ * error handler can only report as a 500. Arity is checked here rather than at the four call
+ * sites so no path can skip it.
+ */
+export declare function dispatchConditionMethod(cb: ConditionBuilder, method: string, colOrExpr: string | Expression, params: unknown[] | undefined): void;
+export declare function buildJoinRefCondition(joinTableConf: ITable | undefined, joinSchema: SchemaDefinition, ref: JoinRefFilter, db: QueryClient, qualifier?: string): ConditionBuilder;
+/**
+ * Apply non-dotted conditions to the main `condition` ConditionBuilder when
+ * possible. For schema fields → straight dispatch. For computed fields → return
+ * side-channel clauses to be appended to WHERE later (with correct placeholder
+ * offsets), since ConditionBuilder cannot bind values for an LHS expression.
+ */
+export declare function applyConditions(condition: ConditionBuilder, conditions: SearchCondition[], schema: SchemaDefinition, tableConf: ITable, db: QueryClient): void;
+/** Computed-field equality filters on the main table. */
+export declare function applyComputedFilters(condition: ConditionBuilder, filters: FilterRecord, tableConf: ITable, db: QueryClient): void;
+//# sourceMappingURL=conditions.d.ts.map

package/dist/lib/engine/search/conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../../../../src/lib/engine/search/conditions.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAW/C,OAAO,KAAK,EAEV,YAAY,EACZ,MAAM,EACN,aAAa,EACb,gBAAgB,EAChB,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,gBAAgB,EACpB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAG,UAAU,EAC9B,MAAM,EAAE,OAAO,EAAE,GAAG,SAAS,GAC5B,IAAI,CA4BN;AAuDD,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,UAAU,EAAE,gBAAgB,EAC5B,GAAG,EAAE,aAAa,EAClB,EAAE,EAAE,WAAW,EACf,SAAS,CAAC,EAAE,MAAM,GACjB,gBAAgB,CAuBlB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,gBAAgB,EAC3B,UAAU,EAAE,eAAe,EAAE,EAC7B,MAAM,EAAE,gBAAgB,EACxB,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,WAAW,GACd,IAAI,CAcN;AAED,yDAAyD;AACzD,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE,YAAY,EACrB,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,WAAW,GACd,IAAI,CAIN"}