fastify-auto-sqlapi 0.0.4 → 0.0.5

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

@@ -10,19 +10,112 @@ function validateSchemaField(field, schema) {
     }
     return schema.col(field);
 }
-function validateOrderBy(orderBy, tableConf, db) {
-    return orderBy.split(',').map((part) => {
+const AGG_FN_SQL = {
+    sum: 'SUM',
+    min: 'MIN',
+    max: 'MAX',
+    avg: 'AVG',
+    count: 'COUNT',
+    distinctCount: 'COUNT DISTINCT', // marker, handled specially
+};
+function buildAggOrderExpr(db, dbTables, tableConf, joinTableName, fn, field, joinGroups, startIdx) {
+    const err400 = (msg) => {
+        const e = new Error(msg);
+        e.statusCode = 400;
+        throw e;
+    };
+    // Whitelist fn
+    if (!(fn in AGG_FN_SQL)) {
+        err400(`Invalid aggregation function: ${fn}`);
+    }
+    // Require joinGroups declaration for the referenced table + fn + field
+    const groupReq = joinGroups?.[joinTableName];
+    if (!groupReq) {
+        err400(`orderBy references undeclared joinGroup: ${joinTableName}`);
+    }
+    const declaredFields = groupReq.aggregations[fn];
+    if (!Array.isArray(declaredFields) || !declaredFields.includes(field)) {
+        err400(`orderBy references undeclared aggregation: ${joinTableName}.${fn}.${field}`);
+    }
+    // Resolve join definition
+    const joinDef = tableConf.allowedReadJoins?.find(([js]) => js.tableName === joinTableName);
+    if (!joinDef) {
+        err400(`Unknown join table in orderBy: ${joinTableName}`);
+    }
+    const [joinSchema, joinField, mainField] = joinDef;
+    // If joinGroup has `by`, only accept it when `by` is the correlation FK (joinField).
+    // In that case each main row corresponds to exactly one group, so the scalar
+    // subquery is semantically equivalent to no-by. Any other `by` produces multiple
+    // groups per main row → not a single scalar, reject.
+    if (groupReq.aggregations.by && groupReq.aggregations.by !== joinField) {
+        err400(`Cannot order by aggregation on joinGroup with 'by' clause on non-FK column: ${joinTableName} (grouped by '${groupReq.aggregations.by}', correlation FK is '${joinField}')`);
+    }
+    // Validate field exists on join schema
+    const fieldCol = validateSchemaField(field, joinSchema);
+    // Build correlation: joinTable.fk = mainTable.main_pk
+    const mainColName = Array.isArray(mainField) ? mainField[0] : mainField;
+    const mainCol = db.qi(tableConf.Schema.col(mainColName));
+    const mainTable = db.qi(tableConf.Schema.tableName);
+    const joinTable = db.qi(joinSchema.tableName);
+    const fkCol = db.qi(joinSchema.col(joinField));
+    // Rebuild joinGroup filters + conditions with correct placeholder offset
+    let filterWhere = '';
+    let filterVals = [];
+    const joinTableConf = dbTables[joinTableName];
+    if ((groupReq.filters || groupReq.conditions?.length) && joinSchema) {
+        const cb = buildJoinRefCondition(joinTableConf, joinSchema, { filters: groupReq.filters, conditions: groupReq.conditions }, db);
+        const built = cb.build(startIdx, db.ph);
+        if (built) {
+            filterWhere = ` AND ${built}`;
+            filterVals = cb.getValues();
+        }
+    }
+    // Generate SQL expression
+    const qField = db.qi(fieldCol);
+    const fnSql = AGG_FN_SQL[fn];
+    const aggExpr = fnSql === 'COUNT DISTINCT'
+        ? `COUNT(DISTINCT ${joinTable}.${qField})`
+        : `${fnSql}(${joinTable}.${qField})`;
+    // COALESCE with 0 so main rows without matching joined records get a sortable
+    // numeric value instead of NULL. Works on all dialects (PG/MySQL/MariaDB) and
+    // keeps "no data" at the bottom on DESC (top-N queries), and at the top on ASC.
+    const expr = `COALESCE((SELECT ${aggExpr} FROM ${joinTable} WHERE ${joinTable}.${fkCol} = ${mainTable}.${mainCol}${filterWhere}), 0)`;
+    return { expr, values: filterVals };
+}
+function validateOrderBy(orderBy, tableConf, db, dbTables, joinGroups, startIdx) {
+    const parts = orderBy.split(',');
+    const outParts = [];
+    const outValues = [];
+    let currentIdx = startIdx;
+    for (const part of parts) {
         const trimmed = part.trim();
-        const match = trimmed.match(/^(\w+)(?:\s+(ASC|DESC))?$/i);
-        if (!match) {
+        // Dotted notation: <joinTable>.<fn>.<field> [ASC|DESC]
+        const dottedMatch = trimmed.match(/^(\w+)\.(\w+)\.(\w+)(?:\s+(ASC|DESC))?$/i);
+        if (dottedMatch) {
+            if (tableConf.distinctResults) {
+                const err = new Error('Cannot combine distinctResults with aggregation orderBy');
+                err.statusCode = 400;
+                throw err;
+            }
+            const [, joinTableName, fn, field, dir] = dottedMatch;
+            const { expr, values } = buildAggOrderExpr(db, dbTables, tableConf, joinTableName, fn, field, joinGroups, currentIdx);
+            outParts.push(`${expr} ${(dir || 'ASC').toUpperCase()}`);
+            outValues.push(...values);
+            currentIdx += values.length;
+            continue;
+        }
+        // Plain field: <field> [ASC|DESC]
+        const plainMatch = trimmed.match(/^(\w+)(?:\s+(ASC|DESC))?$/i);
+        if (!plainMatch) {
             const err = new Error(`Invalid orderBy: ${trimmed}`);
             err.statusCode = 400;
             throw err;
         }
-        const [, field, dir] = match;
+        const [, field, dir] = plainMatch;
         const col = validateSchemaField(field, tableConf.Schema);
-        return `${db.qi(col)} ${(dir || 'ASC').toUpperCase()}`;
-    }).join(', ');
+        outParts.push(`${db.qi(col)} ${(dir || 'ASC').toUpperCase()}`);
+    }
+    return { sql: outParts.join(', '), values: outValues };
 }
 async function executeMainQuery(db, tableConf, where, values, orderBy, paginator, extraJoins = []) {
     const tableName = tableConf.Schema.tableName;
@@ -39,7 +132,7 @@ async function executeMainQuery(db, tableConf, where, values, orderBy, paginator
         distinct: tableConf.distinctResults,
         joins: extraJoins.length > 0 ? extraJoins : undefined,
     });
-    return rows.map((r) => camelcaseObject(r));
+    return rows.map((r) => camelcaseObject(r, tableConf.Schema));
 }
 async function buildPagination(db, tableConf, where, values, paginator, extraJoins = [], computeMin, computeMax, computeSum, computeAvg) {
     const tableName = tableConf.Schema.tableName;
@@ -72,7 +165,7 @@ function findJoinDefinition(tableConf, joinTableName) {
 }
 async function executeVirtualJoins(db, dbTables, tableConf, mainResults, joins) {
     const result = {};
-    for (const [joinTableName, joinOpts] of Object.entries(joins)) {
+    for (const [joinTableName, joinRef] of Object.entries(joins)) {
         const joinDef = findJoinDefinition(tableConf, joinTableName);
         if (!joinDef)
             continue;
@@ -84,22 +177,27 @@ async function executeVirtualJoins(db, dbTables, tableConf, mainResults, joins)
             result[joinTableName] = [];
             continue;
         }
-        // Build join filters
-        const cb = joinTableConf
-            ? joinTableConf.filters(joinOpts?.filters || {})
-            : new ConditionBuilder('AND');
+        // Build join filters (equality) + rich conditions
+        const cb = buildJoinRefCondition(joinTableConf, joinSchema, joinRef || {}, db);
         const fkCol = joinSchema.col(joinField);
         cb.isIn(db.qi(fkCol), ids);
         const where = cb.build(1, db.ph);
         const values = cb.getValues();
-        const columns = selection === '*' ? '*' : selection;
+        // selection is a comma-separated list of field names (camelCase API names).
+        // Resolve each to its DB column via schema.col() and quote it.
+        const columns = selection === '*'
+            ? '*'
+            : selection.split(',').map((c) => {
+                const field = c.trim();
+                return db.qi(joinSchema.col(field));
+            }).join(', ');
         const rows = await db.select({
             tableName: joinSchema.tableName,
             columns,
             where,
             values,
         });
-        result[joinTableName] = rows.map((r) => camelcaseObject(r));
+        result[joinTableName] = rows.map((r) => camelcaseObject(r, joinSchema));
     }
     return result;
 }
@@ -115,7 +213,7 @@ async function executeJoinGroups(db, dbTables, tableConf, mainResults, joinGroup
             result[joinTableName] = {};
             continue;
         }
-        const { aggregations, filters: groupFilters } = groupReq;
+        const { aggregations, filters: groupFilters, conditions: groupConditions } = groupReq;
         const selectParts = [];
         const groupByParts = [];
         if (aggregations.by) {
@@ -147,15 +245,25 @@ async function executeJoinGroups(db, dbTables, tableConf, mainResults, joinGroup
                 selectParts.push(`SUM(${db.qi(col)}) as "sum_${f}"`);
             }
         }
+        if (aggregations.avg) {
+            for (const f of aggregations.avg) {
+                const col = validateSchemaField(f, joinSchema);
+                selectParts.push(`AVG(${db.qi(col)}) as "avg_${f}"`);
+            }
+        }
+        if (aggregations.count) {
+            for (const f of aggregations.count) {
+                const col = validateSchemaField(f, joinSchema);
+                selectParts.push(`COUNT(${db.qi(col)}) as "count_${f}"`);
+            }
+        }
         if (selectParts.length === 0) {
             result[joinTableName] = {};
             continue;
         }
-        // Build WHERE clause
+        // Build WHERE clause: equality filters + rich conditions
         const joinTableConf = dbTables[joinTableName];
-        const cb = joinTableConf && groupFilters
-            ? joinTableConf.filters(groupFilters)
-            : new ConditionBuilder('AND');
+        const cb = buildJoinRefCondition(joinTableConf, joinSchema, { filters: groupFilters, conditions: groupConditions }, db);
         const fkCol = joinSchema.col(joinField);
         cb.isIn(db.qi(fkCol), ids);
         const where = cb.build(1, db.ph);
@@ -205,8 +313,47 @@ function collectIds(mainResults, mainField) {
 }
 // ─── Conditions (advanced filters) ──────────────────────────
 import { ALLOWED_SET, SINGLE_VALUE_SET, BETWEEN_SET, IN_SET, NULL_SET, } from '../../condition-methods.js';
+function dispatchConditionMethod(cb, method, colOrExpr, params) {
+    if (SINGLE_VALUE_SET.has(method)) {
+        cb[method](colOrExpr, params[0]);
+    }
+    else if (BETWEEN_SET.has(method)) {
+        cb[method](colOrExpr, params[0], params[1]);
+    }
+    else if (IN_SET.has(method)) {
+        cb[method](colOrExpr, params[0]);
+    }
+    else if (NULL_SET.has(method)) {
+        cb[method](colOrExpr, true);
+    }
+}
+/**
+ * Build a ConditionBuilder that applies both equality filters and rich conditions
+ * to a join schema. Used by joinFilters (EXISTS), virtual joins data fetching,
+ * and joinGroups (aggregation WHERE + orderBy scalar subquery).
+ */
+function buildJoinRefCondition(joinTableConf, joinSchema, ref, db) {
+    const cb = (ref.filters && joinTableConf)
+        ? joinTableConf.filters(ref.filters)
+        : new ConditionBuilder('AND');
+    if (ref.conditions?.length) {
+        for (const c of ref.conditions) {
+            if (!ALLOWED_SET.has(c.method)) {
+                const err = new Error(`Invalid condition method: ${c.method}`);
+                err.statusCode = 400;
+                throw err;
+            }
+            const col = db.qi(validateSchemaField(c.field, joinSchema));
+            dispatchConditionMethod(cb, c.method, col, c.params ?? []);
+        }
+    }
+    return cb;
+}
 function applyConditions(condition, conditions, schema, db) {
     for (const c of conditions) {
+        // Skip dot-notation fields — those become aggregation conditions processed later
+        if (c.field.includes('.'))
+            continue;
         // Validate method — whitelist only, blocks prototype poisoning
         if (!ALLOWED_SET.has(c.method)) {
             const err = new Error(`Invalid condition method: ${c.method}`);
@@ -214,33 +361,61 @@ function applyConditions(condition, conditions, schema, db) {
             throw err;
         }
         const col = db.qi(validateSchemaField(c.field, schema));
-        if (SINGLE_VALUE_SET.has(c.method)) {
-            condition[c.method](col, c.params[0]);
-        }
-        else if (BETWEEN_SET.has(c.method)) {
-            condition[c.method](col, c.params[0], c.params[1]);
-        }
-        else if (IN_SET.has(c.method)) {
-            condition[c.method](col, c.params[0]);
+        dispatchConditionMethod(condition, c.method, col, c.params);
+    }
+}
+/**
+ * Append aggregation-based conditions (HAVING-style) to the main WHERE clause.
+ * For each condition with a dotted field like `session.count.id`, builds a
+ * correlated scalar subquery (reusing buildAggOrderExpr) and uses it as the
+ * left-hand side of a ConditionBuilder method.
+ *
+ * Runs after the base WHERE / joinFilters are built so placeholder offsets
+ * are correct.
+ */
+function appendAggConditions(currentWhere, currentValues, conditions, db, dbTables, tableConf, joinGroups) {
+    let where = currentWhere;
+    let values = [...currentValues];
+    for (const c of conditions) {
+        if (!c.field.includes('.'))
+            continue;
+        if (!ALLOWED_SET.has(c.method)) {
+            const err = new Error(`Invalid condition method: ${c.method}`);
+            err.statusCode = 400;
+            throw err;
         }
-        else if (NULL_SET.has(c.method)) {
-            condition[c.method](col, true);
+        const parts = c.field.split('.');
+        if (parts.length !== 3) {
+            const err = new Error(`Invalid dotted field in condition: ${c.field} (expected <joinTable>.<fn>.<field>)`);
+            err.statusCode = 400;
+            throw err;
         }
+        const [joinTableName, fn, field] = parts;
+        // Build the scalar subquery; values for its filters are appended to the main values array.
+        const { expr, values: exprValues } = buildAggOrderExpr(db, dbTables, tableConf, joinTableName, fn, field, joinGroups, values.length + 1);
+        values = [...values, ...exprValues];
+        // Use a temporary ConditionBuilder to generate "<expr> <op> <placeholder>" with
+        // the correct placeholder offset, then merge it back into the main values.
+        const tmpCb = new ConditionBuilder('AND');
+        dispatchConditionMethod(tmpCb, c.method, expr, c.params);
+        const startIdx = values.length + 1;
+        const clause = tmpCb.build(startIdx, db.ph);
+        where += ` AND ${clause}`;
+        values.push(...tmpCb.getValues());
     }
+    return { where, values };
 }
 // ─── Join filters (EXISTS subquery) ─────────────────────────
 function buildJoinFiltersExists(db, dbTables, tableConf, joinFilters, currentWhere, currentValues) {
     let where = currentWhere;
     const values = [...currentValues];
-    for (const [joinTableName, filterValues] of Object.entries(joinFilters)) {
+    for (const [joinTableName, ref] of Object.entries(joinFilters)) {
         const joinDef = findJoinDefinition(tableConf, joinTableName);
         if (!joinDef)
             continue;
         const [joinSchema, joinField, mainField] = joinDef;
         const joinTableConf = dbTables[joinTableName];
-        if (!joinTableConf)
-            continue;
-        const filterCondition = joinTableConf.filters(filterValues);
+        const filterCondition = buildJoinRefCondition(joinTableConf, joinSchema, ref, db);
         const startIdx = values.length + 1;
         const filterWhere = filterCondition.build(startIdx, db.ph);
         const filterVals = filterCondition.getValues();
@@ -248,7 +423,11 @@ function buildJoinFiltersExists(db, dbTables, tableConf, joinFilters, currentWhe
         const mainColName = Array.isArray(mainField) ? mainField[0] : mainField;
         const mainCol = db.qi(tableConf.Schema.col(mainColName));
         const mainTable = db.qi(tableConf.Schema.tableName);
-        where += ` AND EXISTS (SELECT 1 FROM ${db.qi(joinSchema.tableName)} WHERE ${fkCol} = ${mainTable}.${mainCol} AND ${filterWhere})`;
+        // If there are no inner conditions, just the correlation suffices.
+        const innerWhere = filterWhere
+            ? `${fkCol} = ${mainTable}.${mainCol} AND ${filterWhere}`
+            : `${fkCol} = ${mainTable}.${mainCol}`;
+        where += ` AND EXISTS (SELECT 1 FROM ${db.qi(joinSchema.tableName)} WHERE ${innerWhere})`;
         values.push(...filterVals);
     }
     return { where, values };
@@ -275,11 +454,28 @@ export async function searchEngine(dbTables, params) {
     if (joinFilters && Object.keys(joinFilters).length > 0) {
         ({ where, values } = buildJoinFiltersExists(db, dbTables, tableConf, joinFilters, where, values));
     }
+    // Aggregation conditions (HAVING-style): dotted fields in `conditions` are
+    // translated into scalar subqueries using the joinGroup aggregation.
+    if (conditions?.length) {
+        const hasAggConditions = conditions.some((c) => c.field.includes('.'));
+        if (hasAggConditions) {
+            ({ where, values } = appendAggConditions(where, values, conditions, db, dbTables, tableConf, joinGroups));
+        }
+    }
     // Validate and sanitize orderBy (user input -> SQL identifier)
-    const safeOrderBy = orderBy ? validateOrderBy(orderBy, tableConf, db) : undefined;
-    // Main query
-    const main = await executeMainQuery(db, tableConf, where, values, safeOrderBy, paginator, tenantJoins);
-    // Pagination
+    // Note: orderBy aggregation values are kept separate from WHERE values,
+    // so that buildPagination (which doesn't use ORDER BY) only binds WHERE params.
+    let safeOrderBy;
+    let orderByValues = [];
+    if (orderBy) {
+        const obResult = validateOrderBy(orderBy, tableConf, db, dbTables, joinGroups, values.length + 1);
+        safeOrderBy = obResult.sql;
+        orderByValues = obResult.values;
+    }
+    // Main query: bind WHERE values + orderBy aggregation values
+    const mainValues = [...values, ...orderByValues];
+    const main = await executeMainQuery(db, tableConf, where, mainValues, safeOrderBy, paginator, tenantJoins);
+    // Pagination: bind only WHERE values (COUNT/compute queries don't use ORDER BY)
     let pagination;
     if (paginator) {
         pagination = await buildPagination(db, tableConf, where, values, paginator, tenantJoins, computeMin, computeMax, computeSum, computeAvg);

package/dist/lib/engine/write-helpers.js

@@ -35,7 +35,7 @@ export async function processSecondaries(db, tableConf, dbTables, mainRecord, se
             ? secondaryPk.map((f) => joinSchema.col(f))
             : joinSchema.col(secondaryPk);
         const preparedRecords = records.map((rec) => {
-            let prepared = snakecaseRecord(rec);
+            let prepared = snakecaseRecord(rec, joinSchema);
             // Auto-fill FK from main record
             const mainValue = Array.isArray(mainField)
                 ? mainRecord[mainField[0]]
@@ -56,7 +56,7 @@ export async function processSecondaries(db, tableConf, dbTables, mainRecord, se
         else {
             pkRows = await db.bulkInsert(joinSchema.tableName, preparedRecords, secondaryPkCol);
         }
-        results[joinTableName] = pkRows.map((r) => camelcaseObject(r));
+        results[joinTableName] = pkRows.map((r) => camelcaseObject(r, joinSchema));
     }
     return results;
 }
@@ -71,10 +71,10 @@ export async function processDeletions(db, tableConf, deletions) {
         const [joinSchema] = joinDef;
         const deletedRows = [];
         for (const rec of records) {
-            const snaked = snakecaseRecord(rec);
+            const snaked = snakecaseRecord(rec, joinSchema);
             const affectedRows = await db.delete(joinSchema.tableName, snaked);
             if (affectedRows > 0) {
-                deletedRows.push(camelcaseObject(snaked));
+                deletedRows.push(camelcaseObject(snaked, joinSchema));
             }
         }
         results[joinTableName] = deletedRows;

package/dist/lib/naming.d.ts

@@ -1,6 +1,15 @@
+import type { SchemaDefinition } from '../types.js';
 export declare function toCamelCase(str: string): string;
 export declare function toUnderscore(str: string): string;
-export declare function camelcaseObject<T extends Record<string, unknown>>(obj: T): Record<string, unknown>;
-export declare function snakecaseRecord(obj: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Convert API record (camelCase keys) to DB record (actual column names).
+ * Uses schema.colMap when available, falls back to toUnderscore.
+ */
+export declare function snakecaseRecord(obj: Record<string, unknown>, schema?: SchemaDefinition): Record<string, unknown>;
+/**
+ * Convert DB row (actual column names) to API record (camelCase field names).
+ * Uses schema.colMap when available, falls back to toCamelCase.
+ */
+export declare function camelcaseObject<T extends Record<string, unknown>>(obj: T, schema?: SchemaDefinition): Record<string, unknown>;
 export declare function toSchemaName(tableName: string): string;
 //# sourceMappingURL=naming.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"naming.d.ts","sourceRoot":"","sources":["../../src/lib/naming.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI/C;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAMhD;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/D,GAAG,EAAE,CAAC,GACL,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAIzB;AAED,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAIzB;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAQtD"}
+{"version":3,"file":"naming.d.ts","sourceRoot":"","sources":["../../src/lib/naming.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI/C;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAMhD;AAiBD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,MAAM,CAAC,EAAE,gBAAgB,GACxB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAOzB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/D,GAAG,EAAE,CAAC,EACN,MAAM,CAAC,EAAE,gBAAgB,GACxB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUzB;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAQtD"}

package/dist/lib/naming.js

@@ -1,5 +1,5 @@
 export function toCamelCase(str) {
-    return str.toLowerCase().replace(/([-_][a-z])/g, (group) => group.toUpperCase().replace('-', '').replace('_', ''));
+    return str.replace(/([-_])([a-zA-Z])/g, (_, _sep, char) => char.toUpperCase());
 }
 export function toUnderscore(str) {
     return str
@@ -8,11 +8,39 @@ export function toUnderscore(str) {
         .map((a, index) => (index === 0 ? a : a[0].toLowerCase() + a.substring(1)))
         .join('_');
 }
-export function camelcaseObject(obj) {
-    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [toCamelCase(k), v]));
+// Reverse colMap cache: colMap object → { column: field }
+const reverseCache = new WeakMap();
+function getReverseMap(colMap) {
+    let reverse = reverseCache.get(colMap);
+    if (!reverse) {
+        reverse = {};
+        for (const [field, col] of Object.entries(colMap)) {
+            reverse[col] = field;
+        }
+        reverseCache.set(colMap, reverse);
+    }
+    return reverse;
+}
+/**
+ * Convert API record (camelCase keys) to DB record (actual column names).
+ * Uses schema.colMap when available, falls back to toUnderscore.
+ */
+export function snakecaseRecord(obj, schema) {
+    const mapFn = schema?.colMap
+        ? (k) => schema.colMap[k] ?? k
+        : (k) => toUnderscore(k);
+    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [mapFn(k), v]));
 }
-export function snakecaseRecord(obj) {
-    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [toUnderscore(k), v]));
+/**
+ * Convert DB row (actual column names) to API record (camelCase field names).
+ * Uses schema.colMap when available, falls back to toCamelCase.
+ */
+export function camelcaseObject(obj, schema) {
+    if (schema?.colMap) {
+        const reverse = getReverseMap(schema.colMap);
+        return Object.fromEntries(Object.entries(obj).map(([k, v]) => [reverse[k] ?? k, v]));
+    }
+    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [toCamelCase(k), v]));
 }
 export function toSchemaName(tableName) {
     return ('Schema' +

package/dist/lib/schema/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/lib/schema/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,OAAO,EAAgB,MAAM,mBAAmB,CAAC;AAErE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAU/C,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAgElF;AAED,eAAO,MAAM,sBAAsB;;;;;;;;EAQjC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAiClF"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/lib/schema/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,OAAO,EAAgB,MAAM,mBAAmB,CAAC;AAErE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAU/C,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAsElF;AAED,eAAO,MAAM,sBAAsB;;;;;;;;EAQjC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAiClF"}

package/dist/lib/schema/search.js

@@ -10,6 +10,13 @@ const JoinGroupResultItem = Type.Object({
 export function SearchTableBodyPost(dbTables, tableName) {
     const tableConf = dbTables[tableName];
     const schema = tableConf.Schema;
+    // Condition item shape (shared across main, joinFilters, joins, joinGroups)
+    const methodEnum = Type.Union(ALLOWED_METHODS.map((m) => Type.Literal(m)));
+    const conditionItemSchema = Type.Object({
+        field: Type.String(),
+        method: methodEnum,
+        params: Type.Optional(Type.Array(Type.Any())),
+    });
     // Filters: schema fields + extraFilters
     const filterFields = {
         ...schema.fields,
@@ -27,10 +34,13 @@ export function SearchTableBodyPost(dbTables, tableName) {
             const joinFilterFields = joinTableConf
                 ? { ...joinSchema.fields, ...joinTableConf.extraFilters }
                 : { ...joinSchema.fields };
-            joinProperties[joinTableName] = Type.Object({
+            // Shared { filters?, conditions? } shape for joinFilters, joins, and joinGroups inner filters
+            const joinRefShape = {
                 filters: Type.Optional(Type.Partial(Type.Object(joinFilterFields))),
-            });
-            joinFilterProperties[joinTableName] = Type.Partial(Type.Object(joinFilterFields));
+                conditions: Type.Optional(Type.Array(conditionItemSchema)),
+            };
+            joinProperties[joinTableName] = Type.Object(joinRefShape);
+            joinFilterProperties[joinTableName] = Type.Object(joinRefShape);
             joinGroupProperties[joinTableName] = Type.Object({
                 aggregations: Type.Object({
                     by: Type.Optional(Type.String()),
@@ -38,18 +48,14 @@ export function SearchTableBodyPost(dbTables, tableName) {
                     min: Type.Optional(Type.Array(Type.String())),
                     max: Type.Optional(Type.Array(Type.String())),
                     sum: Type.Optional(Type.Array(Type.String())),
+                    avg: Type.Optional(Type.Array(Type.String())),
+                    count: Type.Optional(Type.Array(Type.String())),
                 }),
                 filters: Type.Optional(Type.Partial(Type.Object(joinFilterFields))),
+                conditions: Type.Optional(Type.Array(conditionItemSchema)),
             });
         }
     }
-    // Conditions: advanced filters with ConditionBuilder methods
-    const methodEnum = Type.Union(ALLOWED_METHODS.map((m) => Type.Literal(m)));
-    const conditionItemSchema = Type.Object({
-        field: Type.String(),
-        method: methodEnum,
-        params: Type.Optional(Type.Array(Type.Any())),
-    });
     const bodyProperties = {
         filters: filtersSchema,
         conditions: Type.Optional(Type.Array(conditionItemSchema)),

package/dist/lib/table-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"table-helpers.d.ts","sourceRoot":"","sources":["../../src/lib/table-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAC1F,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EACV,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,MAAM,EACP,MAAM,aAAa,CAAC;AAGrB,KAAK,UAAU,CAAC,EAAE,IAAI,EAAE,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAExH,wBAAgB,eAAe,CAC7B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,EAAE,SAAS,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,EAErE,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC3B,YAAY,GAAE,EAAa,EAC3B,iBAAiB,CAAC,EAAE,CAClB,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,yBAAyB;CAAE,KAC3E,IAAI,GACR;IAAE,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAAC,OAAO,EAAE,aAAa,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CA0BhG;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3D,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAChB,MAAM,CAAC,CAAC,CAAC,CAEX;AAED,wBAAgB,aAAa,CAC3B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAEjC,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC/B,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,EAClD,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC/B,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,EAC3B,SAAS,GAAE,MAAY,GACtB,cAAc,CAEhB;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/D,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC3B,OAAO,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,GAC5B,CAAC,gBAAgB,EAAE,MAAM,EAAE,CAAC,CAE9B;AAED,wBAAgB,gBAAgB,CAC9B,GAAG,KAAK,EAAE,CAAC,gBAAgB,EAAE,MAAM,EAAE,CAAC,EAAE,GACvC,GAAG,CAAC,gBAAgB,EAAE,MAAM,EAAE,CAAC,CAEjC"}
+{"version":3,"file":"table-helpers.d.ts","sourceRoot":"","sources":["../../src/lib/table-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAC1F,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EACV,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,MAAM,EACP,MAAM,aAAa,CAAC;AAYrB,KAAK,UAAU,CAAC,EAAE,IAAI,EAAE,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAExH,wBAAgB,eAAe,CAC7B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,EAAE,SAAS,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,EAErE,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC3B,YAAY,GAAE,EAAa,EAC3B,iBAAiB,CAAC,EAAE,CAClB,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,yBAAyB;CAAE,KAC3E,IAAI,GACR;IAAE,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAAC,OAAO,EAAE,aAAa,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CA0BhG;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3D,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAChB,MAAM,CAAC,CAAC,CAAC,CAEX;AAED,wBAAgB,aAAa,CAC3B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAEjC,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC/B,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,EAClD,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC/B,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,EAC3B,SAAS,GAAE,MAAY,GACtB,cAAc,CAEhB;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/D,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC3B,OAAO,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,GAC5B,CAAC,gBAAgB,EAAE,MAAM,EAAE,CAAC,CAE9B;AAED,wBAAgB,gBAAgB,CAC9B,GAAG,KAAK,EAAE,CAAC,gBAAgB,EAAE,MAAM,EAAE,CAAC,EAAE,GACvC,GAAG,CAAC,gBAAgB,EAAE,MAAM,EAAE,CAAC,CAEjC"}

package/dist/lib/table-helpers.js

@@ -1,11 +1,19 @@
 import { ConditionBuilder } from 'node-condition-builder';
+import { getDialect } from './dialect.js';
+// Quote an identifier using the current global ConditionBuilder dialect.
+// Needed so that DB columns with uppercase letters (e.g. betterauth "userId")
+// are preserved on PostgreSQL (which folds unquoted identifiers to lowercase)
+// and on MySQL (which is case-sensitive on Linux filesystems).
+function qi(field) {
+    return getDialect(ConditionBuilder.DIALECT).qi(field);
+}
 export function exportTableInfo(Schema, extraFilters = {}, extendedCondition) {
     const filters = (filterValues) => {
         const condition = new ConditionBuilder('AND');
         // Only auto-match real schema fields (DB columns)
         for (const field of Object.keys(Schema.fields)) {
             if (field in filterValues && filterValues[field] !== null && filterValues[field] !== undefined) {
-                condition.isEqual(Schema.col(field), filterValues[field]);
+                condition.isEqual(qi(Schema.col(field)), filterValues[field]);
             }
         }
         // extraFilters are handled exclusively by extendedCondition

package/dist/types.d.ts

@@ -8,6 +8,7 @@ export interface SqlApiConfig {
     outputDir: string;
     schema?: string;
     dialect?: DialectName;
+    envFile?: string;
 }
 export interface ColumnInfo {
     table_name: string;
@@ -20,6 +21,7 @@ export interface TableMap {
     [schemaName: string]: {
         name: string;
         fields: Record<string, string>;
+        colMap: Record<string, string>;
     };
 }
 export interface SqlResult<T = Record<string, unknown>> {
@@ -44,6 +46,7 @@ export interface SelectOptions {
 }
 export interface SchemaDefinition<T = Record<string, TSchema>> {
     col(field: string): string;
+    colMap?: Record<string, string>;
     fields: T;
     validation: TObject;
     tableName: string;
@@ -98,9 +101,15 @@ export interface ITable<F extends Record<string, TSchema> = Record<string, TSche
     schemaOverrides?: Partial<Record<string & keyof F, TSchema>>;
     validate?: ValidatorFn<F>;
     validateBulk?: BulkValidatorFn<F>;
-    beforeInsert?: (db: QueryClient, req: FastifyRequest, record: Record<string, unknown>) => Promise<void>;
-    beforeUpdate?: (db: QueryClient, req: FastifyRequest, fields: Record<string, unknown>, secondaryFieldsFetcher?: unknown) => void | Promise<void>;
-    afterInsert?: (db: QueryClient, req: FastifyRequest, record: Record<string, unknown>, secondaryRecords?: unknown) => Promise<void>;
+    beforeInsert?: (db: QueryClient, req: FastifyRequest, record: {
+        [K in keyof F]?: Static<F[K]> | Expression | null;
+    }) => Promise<void>;
+    beforeUpdate?: (db: QueryClient, req: FastifyRequest, fields: {
+        [K in keyof F]?: Static<F[K]> | Expression | null;
+    }, secondaryFieldsFetcher?: unknown) => void | Promise<void>;
+    afterInsert?: (db: QueryClient, req: FastifyRequest, record: {
+        [K in keyof F]?: Static<F[K]>;
+    }, secondaryRecords?: unknown) => Promise<void>;
     defaultOrder?: string;
     excludeFromCreation?: (string & keyof F)[];
     distinctResults?: boolean;
@@ -149,20 +158,30 @@ export interface AggregationRequest {
     min?: string[];
     max?: string[];
     sum?: string[];
+    avg?: string[];
+    count?: string[];
 }
 export interface JoinGroupRequest {
     aggregations: AggregationRequest;
     filters?: FilterRecord;
+    conditions?: SearchCondition[];
+}
+/**
+ * Reference filter for join-based existential filtering (joinFilters) and
+ * join-based virtual joins data fetching (joins). Combines equality-based filters
+ * with rich ConditionBuilder-powered conditions, both applied to the join schema.
+ */
+export interface JoinRefFilter {
+    filters?: FilterRecord;
+    conditions?: SearchCondition[];
 }
 export interface SearchParams {
     db: QueryClient;
     tableConf: ITable;
     filters?: FilterRecord;
     conditions?: SearchCondition[];
-    joinFilters?: Record<string, FilterRecord>;
-    joins?: Record<string, {
-        filters?: FilterRecord;
-    }>;
+    joinFilters?: Record<string, JoinRefFilter>;
+    joins?: Record<string, JoinRefFilter>;
     joinGroups?: Record<string, JoinGroupRequest>;
     orderBy?: string;
     paginator?: Paginator;