fastify-auto-sqlapi 0.0.1

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

@@ -0,0 +1,300 @@
+import { ConditionBuilder } from 'node-condition-builder';
+import { camelcaseObject } from '../../naming.js';
+import { buildTenantCondition, buildTenantJoin } from '../../tenant.js';
+import { primaryAsString } from '../../../types.js';
+function validateSchemaField(field, schema) {
+    if (!(field in schema.fields)) {
+        const err = new Error(`Unknown field: ${field}`);
+        err.statusCode = 400;
+        throw err;
+    }
+    return schema.col(field);
+}
+function validateOrderBy(orderBy, tableConf, db) {
+    return orderBy.split(',').map((part) => {
+        const trimmed = part.trim();
+        const match = trimmed.match(/^(\w+)(?:\s+(ASC|DESC))?$/i);
+        if (!match) {
+            const err = new Error(`Invalid orderBy: ${trimmed}`);
+            err.statusCode = 400;
+            throw err;
+        }
+        const [, field, dir] = match;
+        const col = validateSchemaField(field, tableConf.Schema);
+        return `${db.qi(col)} ${(dir || 'ASC').toUpperCase()}`;
+    }).join(', ');
+}
+async function executeMainQuery(db, tableConf, where, values, orderBy, paginator, extraJoins = []) {
+    const tableName = tableConf.Schema.tableName;
+    const order = orderBy || tableConf.defaultOrder || primaryAsString(tableConf.primary);
+    const limit = paginator
+        ? `${paginator.itemsPerPage} OFFSET ${(paginator.page - 1) * paginator.itemsPerPage}`
+        : null;
+    const rows = await db.select({
+        tableName,
+        where,
+        values,
+        orderBy: order,
+        limit,
+        distinct: tableConf.distinctResults,
+        joins: extraJoins.length > 0 ? extraJoins : undefined,
+    });
+    return rows.map((r) => camelcaseObject(r));
+}
+async function buildPagination(db, tableConf, where, values, paginator, extraJoins = [], computeMin, computeMax, computeSum, computeAvg) {
+    const tableName = tableConf.Schema.tableName;
+    const joinClause = extraJoins.length > 0 ? ' ' + extraJoins.join(' ') : '';
+    const countResult = await db.query(`SELECT COUNT(*) as total FROM ${db.qi(tableName)}${joinClause} WHERE ${where}`, values);
+    const total = parseInt(countResult.rows[0].total, 10);
+    const computed = {};
+    const computations = [
+        { key: 'min', field: computeMin, fn: 'MIN' },
+        { key: 'max', field: computeMax, fn: 'MAX' },
+        { key: 'sum', field: computeSum, fn: 'SUM' },
+        { key: 'avg', field: computeAvg, fn: 'AVG' },
+    ];
+    for (const { key, field, fn } of computations) {
+        if (field) {
+            const col = validateSchemaField(field, tableConf.Schema);
+            const result = await db.query(`SELECT ${fn}(${db.qi(col)}) as value FROM ${db.qi(tableName)}${joinClause} WHERE ${where}`, values);
+            computed[key] = { [field]: result.rows[0].value };
+        }
+    }
+    return {
+        total,
+        pages: Math.ceil(total / paginator.itemsPerPage),
+        ...(Object.keys(computed).length > 0 ? { computed } : {}),
+        paginator,
+    };
+}
+function findJoinDefinition(tableConf, joinTableName) {
+    return tableConf.allowedReadJoins?.find(([joinSchema]) => joinSchema.tableName === joinTableName);
+}
+async function executeVirtualJoins(db, dbTables, tableConf, mainResults, joins) {
+    const result = {};
+    for (const [joinTableName, joinOpts] of Object.entries(joins)) {
+        const joinDef = findJoinDefinition(tableConf, joinTableName);
+        if (!joinDef)
+            continue;
+        const [joinSchema, joinField, mainField, selection] = joinDef;
+        const joinTableConf = dbTables[joinTableName];
+        // Collect IDs from main results
+        const ids = collectIds(mainResults, mainField);
+        if (ids.length === 0) {
+            result[joinTableName] = [];
+            continue;
+        }
+        // Build join filters
+        const cb = joinTableConf
+            ? joinTableConf.filters(joinOpts?.filters || {})
+            : new ConditionBuilder('AND');
+        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;
+        const rows = await db.select({
+            tableName: joinSchema.tableName,
+            columns,
+            where,
+            values,
+        });
+        result[joinTableName] = rows.map((r) => camelcaseObject(r));
+    }
+    return result;
+}
+async function executeJoinGroups(db, dbTables, tableConf, mainResults, joinGroups) {
+    const result = {};
+    for (const [joinTableName, groupReq] of Object.entries(joinGroups)) {
+        const joinDef = findJoinDefinition(tableConf, joinTableName);
+        if (!joinDef)
+            continue;
+        const [joinSchema, joinField, mainField] = joinDef;
+        const ids = collectIds(mainResults, mainField);
+        if (ids.length === 0) {
+            result[joinTableName] = {};
+            continue;
+        }
+        const { aggregations, filters: groupFilters } = groupReq;
+        const selectParts = [];
+        const groupByParts = [];
+        if (aggregations.by) {
+            const byCol = validateSchemaField(aggregations.by, joinSchema);
+            selectParts.push(`${db.qi(byCol)} as "by"`);
+            groupByParts.push(db.qi(byCol));
+        }
+        if (aggregations.distinctCount) {
+            for (const f of aggregations.distinctCount) {
+                const col = validateSchemaField(f, joinSchema);
+                selectParts.push(`COUNT(DISTINCT ${db.qi(col)}) as "distinctCount_${f}"`);
+            }
+        }
+        if (aggregations.min) {
+            for (const f of aggregations.min) {
+                const col = validateSchemaField(f, joinSchema);
+                selectParts.push(`MIN(${db.qi(col)}) as "min_${f}"`);
+            }
+        }
+        if (aggregations.max) {
+            for (const f of aggregations.max) {
+                const col = validateSchemaField(f, joinSchema);
+                selectParts.push(`MAX(${db.qi(col)}) as "max_${f}"`);
+            }
+        }
+        if (aggregations.sum) {
+            for (const f of aggregations.sum) {
+                const col = validateSchemaField(f, joinSchema);
+                selectParts.push(`SUM(${db.qi(col)}) as "sum_${f}"`);
+            }
+        }
+        if (selectParts.length === 0) {
+            result[joinTableName] = {};
+            continue;
+        }
+        // Build WHERE clause
+        const joinTableConf = dbTables[joinTableName];
+        const cb = joinTableConf && groupFilters
+            ? joinTableConf.filters(groupFilters)
+            : new ConditionBuilder('AND');
+        const fkCol = joinSchema.col(joinField);
+        cb.isIn(db.qi(fkCol), ids);
+        const where = cb.build(1, db.ph);
+        const values = cb.getValues();
+        const groupBy = groupByParts.length > 0 ? `GROUP BY ${groupByParts.join(', ')}` : '';
+        const sql = `SELECT ${selectParts.join(', ')} FROM ${db.qi(joinSchema.tableName)} WHERE ${where} ${groupBy}`;
+        const queryResult = await db.query(sql, values);
+        const rows = queryResult.rows;
+        // Format: { distinctCount: {field: value}, min: {field: value}, ... }
+        const formatted = {};
+        if (rows.length > 0) {
+            const row = rows.length === 1 && !aggregations.by ? rows[0] : rows;
+            if (Array.isArray(row)) {
+                formatted.rows = row;
+            }
+            else {
+                for (const [key, value] of Object.entries(row)) {
+                    if (key === 'by')
+                        continue;
+                    const [fn, field] = key.split('_');
+                    if (!formatted[fn])
+                        formatted[fn] = {};
+                    formatted[fn][field] = value;
+                }
+            }
+        }
+        result[joinTableName] = formatted;
+    }
+    return result;
+}
+function collectIds(mainResults, mainField) {
+    if (Array.isArray(mainField)) {
+        // Composite key: collect tuples
+        const seen = new Set();
+        const ids = [];
+        for (const r of mainResults) {
+            const key = mainField.map((f) => r[f]).join('|');
+            if (!seen.has(key) && mainField.every((f) => r[f] != null)) {
+                seen.add(key);
+                ids.push(...mainField.map((f) => r[f]));
+            }
+        }
+        return ids;
+    }
+    const unique = [...new Set(mainResults.map((r) => r[mainField]).filter((v) => v != null))];
+    return unique;
+}
+// ─── Conditions (advanced filters) ──────────────────────────
+import { ALLOWED_SET, SINGLE_VALUE_SET, BETWEEN_SET, IN_SET, NULL_SET, } from '../../condition-methods.js';
+function applyConditions(condition, conditions, schema, db) {
+    for (const c of conditions) {
+        // Validate method — whitelist only, blocks prototype poisoning
+        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, 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]);
+        }
+        else if (NULL_SET.has(c.method)) {
+            condition[c.method](col, true);
+        }
+    }
+}
+// ─── 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)) {
+        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 startIdx = values.length + 1;
+        const filterWhere = filterCondition.build(startIdx, db.ph);
+        const filterVals = filterCondition.getValues();
+        const fkCol = db.qi(joinSchema.col(joinField));
+        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})`;
+        values.push(...filterVals);
+    }
+    return { where, values };
+}
+export async function searchEngine(dbTables, params) {
+    const { db, tableConf, filters, conditions, joinFilters, joins, joinGroups, orderBy, paginator, computeMin, computeMax, computeSum, computeAvg, tenant } = params;
+    // Build main condition
+    const condition = tableConf.filters(filters || {});
+    // Advanced conditions
+    if (conditions?.length) {
+        applyConditions(condition, conditions, tableConf.Schema, db);
+    }
+    // Tenant filtering
+    const tenantJoins = [];
+    if (tenant) {
+        condition.append(buildTenantCondition(db, tenant.scope, tenant.ids));
+        if ('through' in tenant.scope) {
+            tenantJoins.push(buildTenantJoin(db, tenant.scope, tableConf.Schema.tableName));
+        }
+    }
+    let where = condition.build(1, db.ph);
+    let values = [...condition.getValues()];
+    // Join filters: add EXISTS subqueries
+    if (joinFilters && Object.keys(joinFilters).length > 0) {
+        ({ where, values } = buildJoinFiltersExists(db, dbTables, tableConf, joinFilters, where, values));
+    }
+    // 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
+    let pagination;
+    if (paginator) {
+        pagination = await buildPagination(db, tableConf, where, values, paginator, tenantJoins, computeMin, computeMax, computeSum, computeAvg);
+    }
+    // Virtual joins (only if requested)
+    const result = { main };
+    if (joins && Object.keys(joins).length > 0) {
+        result.joins = await executeVirtualJoins(db, dbTables, tableConf, main, joins);
+    }
+    // Join groups (only if requested)
+    if (joinGroups && Object.keys(joinGroups).length > 0) {
+        result.joinGroups = await executeJoinGroups(db, dbTables, tableConf, main, joinGroups);
+    }
+    if (pagination) {
+        result.pagination = pagination;
+    }
+    return result;
+}

package/dist/lib/engine/write-helpers.d.ts

@@ -0,0 +1,8 @@
+import type { QueryClient } from '../db.js';
+import type { ITable, DbTables, JoinDefinition } from '../../types.js';
+export declare function findWriteJoin(tableConf: ITable, joinTableName: string): JoinDefinition | undefined;
+export declare function removeExcludedFields(record: Record<string, unknown>, tableConf: ITable): Record<string, unknown>;
+export declare function findSecondaryTableConf(dbTables: DbTables, joinTableName: string): ITable | undefined;
+export declare function processSecondaries(db: QueryClient, tableConf: ITable, dbTables: DbTables, mainRecord: Record<string, unknown>, secondaries: Record<string, Record<string, unknown>[]>): Promise<Record<string, Record<string, unknown>[]>>;
+export declare function processDeletions(db: QueryClient, tableConf: ITable, deletions: Record<string, Record<string, unknown>[]>): Promise<Record<string, Record<string, unknown>[]>>;
+//# sourceMappingURL=write-helpers.d.ts.map

package/dist/lib/engine/write-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-helpers.d.ts","sourceRoot":"","sources":["../../../src/lib/engine/write-helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EACV,MAAM,EACN,QAAQ,EACR,cAAc,EAEf,MAAM,gBAAgB,CAAC;AAExB,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,GACpB,cAAc,GAAG,SAAS,CAI5B;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,SAAS,EAAE,MAAM,GAChB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQzB;AAED,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,MAAM,GACpB,MAAM,GAAG,SAAS,CAKpB;AAED,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,WAAW,EACf,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GACrD,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CA2DpD;AAED,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,WAAW,EACf,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GACnD,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CAwBpD"}

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

@@ -0,0 +1,83 @@
+import { camelcaseObject, snakecaseRecord } from '../naming.js';
+export function findWriteJoin(tableConf, joinTableName) {
+    return tableConf.allowedWriteJoins?.find(([joinSchema]) => joinSchema.tableName === joinTableName);
+}
+export function removeExcludedFields(record, tableConf) {
+    if (!tableConf.excludeFromCreation?.length)
+        return record;
+    const result = { ...record };
+    for (const field of tableConf.excludeFromCreation) {
+        const col = tableConf.Schema.col(field);
+        delete result[col];
+    }
+    return result;
+}
+export function findSecondaryTableConf(dbTables, joinTableName) {
+    for (const [, conf] of Object.entries(dbTables)) {
+        if (conf.Schema.tableName === joinTableName)
+            return conf;
+    }
+    return undefined;
+}
+export async function processSecondaries(db, tableConf, dbTables, mainRecord, secondaries) {
+    const results = {};
+    for (const [joinTableName, records] of Object.entries(secondaries)) {
+        if (!records?.length)
+            continue;
+        const joinDef = findWriteJoin(tableConf, joinTableName);
+        if (!joinDef)
+            continue;
+        const [joinSchema, joinField, mainField] = joinDef;
+        const joinCol = joinSchema.col(joinField);
+        const secondaryTableConf = findSecondaryTableConf(dbTables, joinTableName);
+        const secondaryPk = secondaryTableConf?.primary || joinField;
+        const secondaryPkCol = Array.isArray(secondaryPk)
+            ? secondaryPk.map((f) => joinSchema.col(f))
+            : joinSchema.col(secondaryPk);
+        const preparedRecords = records.map((rec) => {
+            let prepared = snakecaseRecord(rec);
+            // Auto-fill FK from main record
+            const mainValue = Array.isArray(mainField)
+                ? mainRecord[mainField[0]]
+                : mainRecord[mainField];
+            prepared[joinCol] = mainValue;
+            // Remove excluded fields
+            if (secondaryTableConf) {
+                prepared = removeExcludedFields(prepared, secondaryTableConf);
+            }
+            return prepared;
+        });
+        const secondaryUpsertKeys = tableConf.upsertMap?.get(joinSchema);
+        let pkRows;
+        if (secondaryUpsertKeys) {
+            const conflictCols = secondaryUpsertKeys.map((k) => joinSchema.col(k));
+            pkRows = await db.bulkInsertOrUpdate(joinSchema.tableName, preparedRecords, conflictCols, secondaryPkCol);
+        }
+        else {
+            pkRows = await db.bulkInsert(joinSchema.tableName, preparedRecords, secondaryPkCol);
+        }
+        results[joinTableName] = pkRows.map((r) => camelcaseObject(r));
+    }
+    return results;
+}
+export async function processDeletions(db, tableConf, deletions) {
+    const results = {};
+    for (const [joinTableName, records] of Object.entries(deletions)) {
+        if (!records?.length)
+            continue;
+        const joinDef = findWriteJoin(tableConf, joinTableName);
+        if (!joinDef)
+            continue;
+        const [joinSchema] = joinDef;
+        const deletedRows = [];
+        for (const rec of records) {
+            const snaked = snakecaseRecord(rec);
+            const affectedRows = await db.delete(joinSchema.tableName, snaked);
+            if (affectedRows > 0) {
+                deletedRows.push(camelcaseObject(snaked));
+            }
+        }
+        results[joinTableName] = deletedRows;
+    }
+    return results;
+}

package/dist/lib/naming.d.ts

@@ -0,0 +1,6 @@
+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>;
+export declare function toSchemaName(tableName: string): string;
+//# sourceMappingURL=naming.d.ts.map

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

@@ -0,0 +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"}

package/dist/lib/naming.js

@@ -0,0 +1,23 @@
+export function toCamelCase(str) {
+    return str.toLowerCase().replace(/([-_][a-z])/g, (group) => group.toUpperCase().replace('-', '').replace('_', ''));
+}
+export function toUnderscore(str) {
+    return str
+        .replace(/([A-Z])/g, '|$1')
+        .split('|')
+        .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]));
+}
+export function snakecaseRecord(obj) {
+    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [toUnderscore(k), v]));
+}
+export function toSchemaName(tableName) {
+    return ('Schema' +
+        tableName
+            .split('_')
+            .map((w) => w.substring(0, 1).toUpperCase() + w.substring(1))
+            .join(''));
+}

package/dist/lib/schema/bulk-delete.d.ts

@@ -0,0 +1,10 @@
+import type { DbTables } from '../../types.js';
+export declare function BulkDeleteTableBody(dbTables: DbTables, tableName: string): import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+    [x: string]: any;
+}>>;
+export declare function BulkDeleteTableResponse(dbTables: DbTables, tableName: string): import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+    main: import("@sinclair/typebox").TObject<{
+        [x: string]: any;
+    }>;
+}>>;
+//# sourceMappingURL=bulk-delete.d.ts.map

package/dist/lib/schema/bulk-delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-delete.d.ts","sourceRoot":"","sources":["../../../src/lib/schema/bulk-delete.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM;;IAMxE;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM;;;;IAU5E"}

package/dist/lib/schema/bulk-delete.js

@@ -0,0 +1,16 @@
+import { Type } from '@sinclair/typebox';
+import { primaryAsString } from '../../types.js';
+export function BulkDeleteTableBody(dbTables, tableName) {
+    const tableConf = dbTables[tableName];
+    const pkField = primaryAsString(tableConf.primary);
+    const pkType = tableConf.Schema.fields[pkField];
+    return Type.Array(Type.Object({ [pkField]: pkType }));
+}
+export function BulkDeleteTableResponse(dbTables, tableName) {
+    const tableConf = dbTables[tableName];
+    const pkField = primaryAsString(tableConf.primary);
+    const pkType = tableConf.Schema.fields[pkField];
+    return Type.Array(Type.Object({
+        main: Type.Object({ [pkField]: pkType }),
+    }));
+}

package/dist/lib/schema/bulk-upsert.d.ts

@@ -0,0 +1,5 @@
+import { type TSchema } from '@sinclair/typebox';
+import type { DbTables } from '../../types.js';
+export declare function BulkUpsertTableBody(dbTables: DbTables, tableName: string): import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<Record<string, TSchema>>>;
+export declare function BulkUpsertTableResponse(dbTables: DbTables, tableName: string): import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<Record<string, TSchema>>>;
+//# sourceMappingURL=bulk-upsert.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-upsert.d.ts","sourceRoot":"","sources":["../../../src/lib/schema/bulk-upsert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI/C,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,oGAiCxE;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,oGA8B5E"}

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

@@ -0,0 +1,43 @@
+import { Type } from '@sinclair/typebox';
+import { primaryAsString } from '../../types.js';
+import { findSecondaryTableConf } from '../engine/write-helpers.js';
+import { pkSchema, buildSecondaryFields } from './helpers.js';
+export function BulkUpsertTableBody(dbTables, tableName) {
+    const tableConf = dbTables[tableName];
+    const schema = tableConf.Schema;
+    const mainSchema = Type.Partial(Type.Object(schema.fields));
+    const itemProperties = {
+        main: mainSchema,
+    };
+    if (tableConf.allowedWriteJoins?.length) {
+        const secondaryProperties = {};
+        const deletionProperties = {};
+        for (const [joinSchema, joinField] of tableConf.allowedWriteJoins) {
+            const secondaryTableConf = findSecondaryTableConf(dbTables, joinSchema.tableName);
+            const joinFields = buildSecondaryFields(joinSchema, joinField, secondaryTableConf);
+            secondaryProperties[joinSchema.tableName] = Type.Array(Type.Object(joinFields));
+            deletionProperties[joinSchema.tableName] = Type.Array(Type.Partial(Type.Object(joinSchema.fields)));
+        }
+        itemProperties.secondaries = Type.Optional(Type.Partial(Type.Object(secondaryProperties)));
+        itemProperties.deletions = Type.Optional(Type.Partial(Type.Object(deletionProperties)));
+    }
+    return Type.Array(Type.Object(itemProperties));
+}
+export function BulkUpsertTableResponse(dbTables, tableName) {
+    const tableConf = dbTables[tableName];
+    const responseProperties = {
+        main: Type.Object(pkSchema(tableConf, tableConf.Schema, primaryAsString(tableConf.primary))),
+    };
+    if (tableConf.allowedWriteJoins?.length) {
+        const secondaryProperties = {};
+        const deletionProperties = {};
+        for (const [joinSchema, joinField] of tableConf.allowedWriteJoins) {
+            const secondaryTableConf = findSecondaryTableConf(dbTables, joinSchema.tableName);
+            secondaryProperties[joinSchema.tableName] = Type.Array(Type.Object(pkSchema(secondaryTableConf, joinSchema, joinField)));
+            deletionProperties[joinSchema.tableName] = Type.Array(Type.Partial(Type.Object(joinSchema.fields)));
+        }
+        responseProperties.secondaries = Type.Optional(Type.Partial(Type.Object(secondaryProperties)));
+        responseProperties.deletions = Type.Optional(Type.Partial(Type.Object(deletionProperties)));
+    }
+    return Type.Array(Type.Object(responseProperties));
+}

package/dist/lib/schema/helpers.d.ts

@@ -0,0 +1,14 @@
+import { type TSchema } from '@sinclair/typebox';
+import type { ITable, SchemaDefinition } from '../../types.js';
+/**
+ * Build a PK-only schema for response shapes (single or composite PK).
+ * Falls back to `fallback` field if tableConf is undefined.
+ */
+export declare function pkSchema(tableConf: ITable | undefined, schema: SchemaDefinition, fallback: string): Record<string, TSchema>;
+/**
+ * Build secondary table fields for body schemas:
+ * - FK field becomes Optional (auto-filled from main)
+ * - excludeFromCreation fields become Optional
+ */
+export declare function buildSecondaryFields(joinSchema: SchemaDefinition, joinField: string, secondaryTableConf: ITable | undefined): Record<string, TSchema>;
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/lib/schema/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAE/D;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQ3H;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,gBAAgB,EAC5B,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,MAAM,GAAG,SAAS,GACrC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgBzB"}

package/dist/lib/schema/helpers.js

@@ -0,0 +1,33 @@
+import { Type } from '@sinclair/typebox';
+/**
+ * Build a PK-only schema for response shapes (single or composite PK).
+ * Falls back to `fallback` field if tableConf is undefined.
+ */
+export function pkSchema(tableConf, schema, fallback) {
+    const pk = tableConf?.primary || fallback;
+    const fields = Array.isArray(pk) ? pk : [pk];
+    const result = {};
+    for (const f of fields) {
+        result[f] = schema.fields[f] || Type.Any();
+    }
+    return result;
+}
+/**
+ * Build secondary table fields for body schemas:
+ * - FK field becomes Optional (auto-filled from main)
+ * - excludeFromCreation fields become Optional
+ */
+export function buildSecondaryFields(joinSchema, joinField, secondaryTableConf) {
+    const fields = { ...joinSchema.fields };
+    if (joinField in fields) {
+        fields[joinField] = Type.Optional(fields[joinField]);
+    }
+    if (secondaryTableConf?.excludeFromCreation) {
+        for (const field of secondaryTableConf.excludeFromCreation) {
+            if (field in fields) {
+                fields[field] = Type.Optional(fields[field]);
+            }
+        }
+    }
+    return fields;
+}

package/dist/lib/schema/insert.d.ts

@@ -0,0 +1,5 @@
+import { type TObject } from '@sinclair/typebox';
+import type { DbTables } from '../../types.js';
+export declare function InsertTableBody(dbTables: DbTables, tableName: string): TObject;
+export declare function InsertTableResponse(dbTables: DbTables, tableName: string): TObject;
+//# sourceMappingURL=insert.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../../../src/lib/schema/insert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,OAAO,EAAgB,MAAM,mBAAmB,CAAC;AAErE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI/C,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CA+B9E;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAuBlF"}

package/dist/lib/schema/insert.js

@@ -0,0 +1,43 @@
+import { Type } from '@sinclair/typebox';
+import { primaryAsString } from '../../types.js';
+import { findSecondaryTableConf } from '../engine/write-helpers.js';
+import { pkSchema, buildSecondaryFields } from './helpers.js';
+export function InsertTableBody(dbTables, tableName) {
+    const tableConf = dbTables[tableName];
+    const schema = tableConf.Schema;
+    // Main: full validation, but excludeFromCreation fields become Optional
+    const mainFields = { ...schema.fields };
+    if (tableConf.excludeFromCreation) {
+        for (const field of tableConf.excludeFromCreation) {
+            mainFields[field] = Type.Optional(mainFields[field]);
+        }
+    }
+    const bodyProperties = {
+        main: Type.Object(mainFields),
+    };
+    if (tableConf.allowedWriteJoins?.length) {
+        const secondaryProperties = {};
+        for (const [joinSchema, joinField] of tableConf.allowedWriteJoins) {
+            const secondaryTableConf = findSecondaryTableConf(dbTables, joinSchema.tableName);
+            const joinFields = buildSecondaryFields(joinSchema, joinField, secondaryTableConf);
+            secondaryProperties[joinSchema.tableName] = Type.Array(Type.Object(joinFields));
+        }
+        bodyProperties.secondaries = Type.Optional(Type.Partial(Type.Object(secondaryProperties)));
+    }
+    return Type.Object(bodyProperties);
+}
+export function InsertTableResponse(dbTables, tableName) {
+    const tableConf = dbTables[tableName];
+    const responseProperties = {
+        main: Type.Object(pkSchema(tableConf, tableConf.Schema, primaryAsString(tableConf.primary))),
+    };
+    if (tableConf.allowedWriteJoins?.length) {
+        const secondaryProperties = {};
+        for (const [joinSchema, joinField] of tableConf.allowedWriteJoins) {
+            const secondaryTableConf = findSecondaryTableConf(dbTables, joinSchema.tableName);
+            secondaryProperties[joinSchema.tableName] = Type.Array(Type.Object(pkSchema(secondaryTableConf, joinSchema, joinField)));
+        }
+        responseProperties.secondaries = Type.Optional(Type.Partial(Type.Object(secondaryProperties)));
+    }
+    return Type.Object(responseProperties);
+}

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

@@ -0,0 +1,14 @@
+import { type TObject } from '@sinclair/typebox';
+import type { DbTables } from '../../types.js';
+export declare function SearchTableBodyPost(dbTables: DbTables, tableName: string): TObject;
+export declare const SearchTableQueryString: TObject<{
+    orderBy: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    page: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    itemsPerPage: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    computeMin: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    computeMax: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    computeSum: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    computeAvg: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare function SearchTableResponse(dbTables: DbTables, tableName: string): TObject;
+//# sourceMappingURL=search.d.ts.map

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

@@ -0,0 +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"}