fastify-auto-sqlapi 0.0.1

package/dist/lib/dialect.d.ts

@@ -0,0 +1,17 @@
+export type DialectName = 'postgres' | 'mysql' | 'mariadb';
+export interface SqlDialect {
+    name: DialectName;
+    /** Quote identifier: "id" (postgres) or `id` (mysql/mariadb) */
+    qi(id: string): string;
+    /** Placeholder: $1 (postgres) or ? (mysql/mariadb) */
+    ph(index: number): string;
+    /** ConditionBuilder dialect name */
+    cbDialect: 'postgres' | 'mysql';
+    supportsReturning: boolean;
+    /** ON CONFLICT / ON DUPLICATE KEY syntax */
+    upsertSql(quotedConflictKeys: string, quotedUpdateSet: string): string;
+    /** RETURNING pk_col suffix or empty string */
+    returningPk(quotedPkCol: string): string;
+}
+export declare function getDialect(name: DialectName): SqlDialect;
+//# sourceMappingURL=dialect.d.ts.map

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

@@ -0,0 +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,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;CAC1C;AAqDD,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,CAIxD"}

package/dist/lib/dialect.js

@@ -0,0 +1,56 @@
+const PostgresDialect = {
+    name: 'postgres',
+    qi: (id) => `"${id.replace(/"/g, '""')}"`,
+    ph: (i) => `$${i}`,
+    cbDialect: 'postgres',
+    supportsReturning: true,
+    upsertSql(quotedConflictKeys, quotedUpdateSet) {
+        if (!quotedUpdateSet)
+            return `ON CONFLICT (${quotedConflictKeys}) DO NOTHING`;
+        return `ON CONFLICT (${quotedConflictKeys}) DO UPDATE SET ${quotedUpdateSet}`;
+    },
+    returningPk(quotedPkCol) {
+        return ` RETURNING ${quotedPkCol}`;
+    },
+};
+const MysqlDialect = {
+    name: 'mysql',
+    qi: (id) => `\`${id.replace(/`/g, '``')}\``,
+    ph: () => '?',
+    cbDialect: 'mysql',
+    supportsReturning: false,
+    upsertSql(_quotedConflictKeys, quotedUpdateSet) {
+        if (!quotedUpdateSet)
+            return `ON DUPLICATE KEY UPDATE ${_quotedConflictKeys.split(', ')[0]} = ${_quotedConflictKeys.split(', ')[0]}`;
+        return `ON DUPLICATE KEY UPDATE ${quotedUpdateSet}`;
+    },
+    returningPk() {
+        return '';
+    },
+};
+const MariadbDialect = {
+    name: 'mariadb',
+    qi: (id) => `\`${id.replace(/`/g, '``')}\``,
+    ph: () => '?',
+    cbDialect: 'mysql',
+    supportsReturning: true,
+    upsertSql(_quotedConflictKeys, quotedUpdateSet) {
+        if (!quotedUpdateSet)
+            return `ON DUPLICATE KEY UPDATE ${_quotedConflictKeys.split(', ')[0]} = ${_quotedConflictKeys.split(', ')[0]}`;
+        return `ON DUPLICATE KEY UPDATE ${quotedUpdateSet}`;
+    },
+    returningPk(quotedPkCol) {
+        return ` RETURNING ${quotedPkCol}`;
+    },
+};
+const dialects = {
+    postgres: PostgresDialect,
+    mysql: MysqlDialect,
+    mariadb: MariadbDialect,
+};
+export function getDialect(name) {
+    const d = dialects[name];
+    if (!d)
+        throw new Error(`Unknown dialect: ${name}`);
+    return d;
+}

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

@@ -0,0 +1,3 @@
+import type { BulkDeleteParams, BulkDeleteResult } from '../../../types.js';
+export declare function bulkDeleteEngine(params: BulkDeleteParams): Promise<BulkDeleteResult[]>;
+//# sourceMappingURL=bulk-delete.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-delete.d.ts","sourceRoot":"","sources":["../../../../src/lib/engine/bulk/bulk-delete.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE5E,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAiC5F"}

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

@@ -0,0 +1,30 @@
+import { ConditionBuilder } from 'node-condition-builder';
+import { buildTenantDeleteWhere } from '../../tenant.js';
+import { primaryAsString } from '../../../types.js';
+export async function bulkDeleteEngine(params) {
+    const { db, tableConf, ids, tenant } = params;
+    if (!ids.length)
+        return [];
+    const pk = primaryAsString(tableConf.primary);
+    const pkCol = tableConf.Schema.col(pk);
+    const tableName = tableConf.Schema.tableName;
+    let where;
+    let values;
+    if (tenant) {
+        ({ where, values } = buildTenantDeleteWhere(db, tableName, pkCol, ids, tenant));
+    }
+    else {
+        const cb = new ConditionBuilder('AND');
+        cb.isIn(db.qi(pkCol), ids);
+        where = cb.build(1, db.ph);
+        values = cb.getValues();
+    }
+    const result = await db.query(`DELETE FROM ${db.qi(tableName)} WHERE ${where}`, values);
+    // Return PK-only for each deleted record
+    if (result.affectedRows === ids.length) {
+        return ids.map((id) => ({ main: { [pk]: id } }));
+    }
+    // Partial delete: best effort (no RETURNING on MySQL)
+    const deletedCount = result.affectedRows;
+    return ids.slice(0, deletedCount).map((id) => ({ main: { [pk]: id } }));
+}

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

@@ -0,0 +1,3 @@
+import type { BulkUpsertParams, BulkUpsertResult } from '../../../types.js';
+export declare function bulkUpsertEngine(params: BulkUpsertParams): Promise<BulkUpsertResult[]>;
+//# sourceMappingURL=bulk-upsert.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-upsert.d.ts","sourceRoot":"","sources":["../../../../src/lib/engine/bulk/bulk-upsert.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAGjB,MAAM,mBAAmB,CAAC;AAE3B,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAuF5F"}

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

@@ -0,0 +1,74 @@
+import { camelcaseObject, snakecaseRecord } from '../../naming.js';
+import { removeExcludedFields, processSecondaries, processDeletions } from '../write-helpers.js';
+import { injectTenantValue, validateTenantFK } from '../../tenant.js';
+import { primaryAsString } from '../../../types.js';
+export async function bulkUpsertEngine(params) {
+    const { db, tableConf, dbTables, request, items, tenant } = params;
+    if (!items.length)
+        return [];
+    const pk = primaryAsString(tableConf.primary);
+    const pkCol = tableConf.Schema.col(pk);
+    // 1. Prepare all main records
+    const preparedMains = items.map((item) => {
+        let rec = snakecaseRecord(item.main);
+        rec = removeExcludedFields(rec, tableConf);
+        return rec;
+    });
+    // 1b. Tenant: inject or validate FK
+    if (tenant) {
+        if ('through' in tenant.scope) {
+            // Indirect: collect all FK values, validate in batch
+            const scope = tenant.scope;
+            const fkCol = scope.through.localField;
+            const fkValues = preparedMains.map((rec) => rec[fkCol]);
+            await validateTenantFK(db, scope, tenant.ids, fkValues);
+        }
+        else {
+            for (const rec of preparedMains) {
+                injectTenantValue(rec, tenant.scope, tenant.ids);
+            }
+        }
+    }
+    // 2. beforeInsert hook per record
+    if (tableConf.beforeInsert) {
+        for (const rec of preparedMains) {
+            await tableConf.beforeInsert(db, request, rec);
+        }
+    }
+    // 3. Bulk upsert all mains in one query → returns PK-only
+    const upsertKeys = tableConf.upsertMap?.get(tableConf.Schema);
+    let pkRows;
+    if (upsertKeys) {
+        const conflictCols = upsertKeys.map((k) => tableConf.Schema.col(k));
+        pkRows = await db.bulkInsertOrUpdate(tableConf.Schema.tableName, preparedMains, conflictCols, pkCol);
+    }
+    else {
+        pkRows = await db.bulkInsert(tableConf.Schema.tableName, preparedMains, pkCol);
+    }
+    const pksCamel = pkRows.map((r) => camelcaseObject(r));
+    // 4. Process secondaries and deletions per item
+    const results = [];
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const mainPk = pksCamel[i];
+        const result = { main: mainPk };
+        // For FK auto-fill in secondaries, merge input record + PK
+        const mainForFK = { ...camelcaseObject(preparedMains[i]), ...mainPk };
+        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, item.deletions);
+            if (Object.keys(del).length > 0)
+                result.deletions = del;
+        }
+        // 5. afterInsert hook per item
+        if (tableConf.afterInsert) {
+            await tableConf.afterInsert(db, request, mainForFK, result.secondaries);
+        }
+        results.push(result);
+    }
+    return results;
+}

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

@@ -0,0 +1,3 @@
+import type { DeleteParams, DeleteResult } from '../../../types.js';
+export declare function deleteEngine(params: DeleteParams): Promise<DeleteResult>;
+//# sourceMappingURL=delete.d.ts.map

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

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

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

@@ -0,0 +1,25 @@
+import { buildTenantDeleteWhere } from '../../tenant.js';
+import { primaryAsString } from '../../../types.js';
+export async function deleteEngine(params) {
+    const { db, tableConf, id, tenant } = params;
+    const pk = primaryAsString(tableConf.primary);
+    const pkCol = tableConf.Schema.col(pk);
+    const tableName = tableConf.Schema.tableName;
+    if (!tenant) {
+        const affectedRows = await db.delete(tableName, { [pkCol]: id });
+        if (affectedRows === 0) {
+            const err = new Error(`Record not found: ${id}`);
+            err.statusCode = 404;
+            throw err;
+        }
+        return { main: { [pk]: id } };
+    }
+    const { where, values } = buildTenantDeleteWhere(db, tableName, pkCol, id, tenant);
+    const result = await db.query(`DELETE FROM ${db.qi(tableName)} WHERE ${where}`, values);
+    if (result.affectedRows === 0) {
+        const err = new Error(`Record not found: ${id}`);
+        err.statusCode = 404;
+        throw err;
+    }
+    return { main: { [pk]: id } };
+}

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

@@ -0,0 +1,3 @@
+import type { GetParams, GetResult } from '../../../types.js';
+export declare function getEngine(params: GetParams): Promise<GetResult>;
+//# sourceMappingURL=get.d.ts.map

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

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

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

@@ -0,0 +1,32 @@
+import { ConditionBuilder } from 'node-condition-builder';
+import { camelcaseObject } from '../../naming.js';
+import { buildTenantCondition, buildTenantJoin } from '../../tenant.js';
+import { primaryAsString } from '../../../types.js';
+export async function getEngine(params) {
+    const { db, tableConf, id, tenant } = params;
+    const pkCol = tableConf.Schema.col(primaryAsString(tableConf.primary));
+    const cb = new ConditionBuilder('AND');
+    cb.isEqual(db.qi(pkCol), id);
+    const joins = [];
+    if (tenant) {
+        cb.append(buildTenantCondition(db, tenant.scope, tenant.ids));
+        if ('through' in tenant.scope) {
+            joins.push(buildTenantJoin(db, tenant.scope, tableConf.Schema.tableName));
+        }
+    }
+    const where = cb.build(1, db.ph);
+    const values = cb.getValues();
+    const rows = await db.select({
+        tableName: tableConf.Schema.tableName,
+        where,
+        values,
+        limit: '1',
+        joins: joins.length > 0 ? joins : undefined,
+    });
+    if (rows.length === 0) {
+        const err = new Error(`Record not found: ${id}`);
+        err.statusCode = 404;
+        throw err;
+    }
+    return { main: camelcaseObject(rows[0]) };
+}

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

@@ -0,0 +1,3 @@
+import type { InsertParams, InsertResult } from '../../../types.js';
+export declare function insertEngine(params: InsertParams): Promise<InsertResult>;
+//# sourceMappingURL=insert.d.ts.map

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

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

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

@@ -0,0 +1,58 @@
+import { camelcaseObject, snakecaseRecord } from '../../naming.js';
+import { removeExcludedFields, processSecondaries } from '../write-helpers.js';
+import { injectTenantValue, validateTenantFK } from '../../tenant.js';
+import { primaryAsString } from '../../../types.js';
+export async function insertEngine(params) {
+    const { db, tableConf, dbTables, request, record, secondaries, tenant } = params;
+    const pk = primaryAsString(tableConf.primary);
+    const pkCol = tableConf.Schema.col(pk);
+    // 1. Prepare main record
+    let mainRecord = snakecaseRecord(record);
+    mainRecord = removeExcludedFields(mainRecord, tableConf);
+    // 1b. Tenant: inject or validate
+    if (tenant) {
+        if ('through' in tenant.scope) {
+            // Indirect: validate FK belongs to tenant
+            const scope = tenant.scope;
+            const fkCol = scope.through.localField;
+            const fkValue = mainRecord[fkCol];
+            await validateTenantFK(db, scope, tenant.ids, [fkValue]);
+        }
+        else {
+            injectTenantValue(mainRecord, tenant.scope, tenant.ids);
+        }
+    }
+    // 2. beforeInsert hook
+    if (tableConf.beforeInsert) {
+        await tableConf.beforeInsert(db, request, mainRecord);
+    }
+    // 3. Insert main → returns PK-only
+    let pkResult;
+    const upsertKeys = tableConf.upsertMap?.get(tableConf.Schema);
+    if (upsertKeys) {
+        const conflictCols = upsertKeys.map((k) => tableConf.Schema.col(k));
+        pkResult = await db.insertOrUpdate(tableConf.Schema.tableName, mainRecord, conflictCols, pkCol);
+    }
+    else {
+        pkResult = await db.insert(tableConf.Schema.tableName, mainRecord, pkCol);
+    }
+    const mainPkCamel = camelcaseObject(pkResult);
+    // 4. Secondaries: need full record for FK auto-fill
+    let secondaryResults;
+    if (secondaries && Object.keys(secondaries).length > 0) {
+        // Merge input record + PK for FK auto-fill
+        const mainForFK = { ...camelcaseObject(mainRecord), ...mainPkCamel };
+        secondaryResults = await processSecondaries(db, tableConf, dbTables, mainForFK, secondaries);
+    }
+    // 5. afterInsert hook
+    if (tableConf.afterInsert) {
+        const mainForHook = { ...camelcaseObject(mainRecord), ...mainPkCamel };
+        await tableConf.afterInsert(db, request, mainForHook, secondaryResults);
+    }
+    // 6. Return PK-only
+    const result = { main: mainPkCamel };
+    if (secondaryResults && Object.keys(secondaryResults).length > 0) {
+        result.secondaries = secondaryResults;
+    }
+    return result;
+}

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

@@ -0,0 +1,3 @@
+import type { UpdateParams, UpdateResult } from '../../../types.js';
+export declare function updateEngine(params: UpdateParams): Promise<UpdateResult>;
+//# sourceMappingURL=update.d.ts.map

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

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

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

@@ -0,0 +1,110 @@
+import { camelcaseObject, snakecaseRecord } from '../../naming.js';
+import { processSecondaries, processDeletions } from '../write-helpers.js';
+import { stripTenantColumn, buildTenantCondition, buildTenantJoin } from '../../tenant.js';
+import { ConditionBuilder } from 'node-condition-builder';
+import { primaryAsString } from '../../../types.js';
+export async function updateEngine(params) {
+    const { db, tableConf, dbTables, request, record, secondaries, deletions, tenant } = params;
+    // 1. Prepare: extract PK, snakecase, build update fields
+    const pk = primaryAsString(tableConf.primary);
+    const pkCol = tableConf.Schema.col(pk);
+    const snaked = snakecaseRecord(record);
+    const pkValue = snaked[pkCol];
+    if (pkValue == null) {
+        const error = new Error(`Primary key "${pk}" is required`);
+        error.statusCode = 400;
+        throw error;
+    }
+    const updateFields = { ...snaked };
+    delete updateFields[pkCol];
+    // 1b. Tenant: strip tenant column from update fields + validate ownership
+    if (tenant) {
+        stripTenantColumn(updateFields, tenant.scope);
+        if ('through' in tenant.scope) {
+            // Indirect: verify the record belongs to tenant via subquery
+            const scope = tenant.scope;
+            const tableName = tableConf.Schema.tableName;
+            const cb = new ConditionBuilder('AND');
+            cb.isEqual(`${db.qi(tableName)}.${db.qi(pkCol)}`, pkValue);
+            cb.append(buildTenantCondition(db, scope, tenant.ids));
+            const checkWhere = cb.build(1, db.ph);
+            const checkValues = cb.getValues();
+            const joinSql = buildTenantJoin(db, scope, tableName);
+            const checkSql = `SELECT 1 FROM ${db.qi(tableName)} ${joinSql} WHERE ${checkWhere} LIMIT 1`;
+            const checkResult = await db.query(checkSql, checkValues);
+            if (checkResult.rows.length === 0) {
+                const error = new Error('Record not found');
+                error.statusCode = 404;
+                throw error;
+            }
+        }
+    }
+    // 2. beforeUpdate hook
+    if (tableConf.beforeUpdate) {
+        await tableConf.beforeUpdate(db, request, updateFields);
+    }
+    // 3. Update main
+    const hasFieldsToUpdate = Object.keys(updateFields).length > 0;
+    let extraCondition;
+    if (tenant && !('through' in tenant.scope)) {
+        // Direct: add tenant to WHERE
+        extraCondition = new ConditionBuilder('AND');
+        if (tenant.ids.length === 1) {
+            extraCondition.isEqual(tenant.scope.column, tenant.ids[0]);
+        }
+        else {
+            extraCondition.isIn(tenant.scope.column, tenant.ids);
+        }
+    }
+    if (hasFieldsToUpdate) {
+        const affectedRows = await db.update(tableConf.Schema.tableName, updateFields, { [pkCol]: pkValue }, extraCondition);
+        if (affectedRows === 0) {
+            const error = new Error(`Record not found`);
+            error.statusCode = 404;
+            throw error;
+        }
+    }
+    else {
+        // No fields to update: verify the record exists (for secondaries/deletions)
+        let whereSql = `${db.qi(tableConf.Schema.tableName)}.${db.qi(pkCol)} = ${db.ph(1)}`;
+        const whereValues = [pkValue];
+        if (extraCondition) {
+            whereSql += ` AND ${extraCondition.build(2, db.ph)}`;
+            whereValues.push(...extraCondition.getValues());
+        }
+        const rows = await db.select({
+            tableName: tableConf.Schema.tableName,
+            where: whereSql,
+            values: whereValues,
+            limit: '1',
+        });
+        if (rows.length === 0) {
+            const error = new Error(`Record not found`);
+            error.statusCode = 404;
+            throw error;
+        }
+    }
+    // Build the main response (PK-only)
+    const mainResult = { [pk]: pkValue };
+    // 4. Secondaries (upsert/insert with FK auto-fill)
+    let secondaryResults;
+    if (secondaries && Object.keys(secondaries).length > 0) {
+        // Merge input fields + PK for FK auto-fill
+        const mainForFK = { ...camelcaseObject(snaked) };
+        secondaryResults = await processSecondaries(db, tableConf, dbTables, mainForFK, secondaries);
+    }
+    // 5. Deletions
+    let deletionResults;
+    if (deletions && Object.keys(deletions).length > 0) {
+        deletionResults = await processDeletions(db, tableConf, deletions);
+    }
+    // 6. Return PK-only
+    const result = { main: mainResult };
+    if (secondaryResults && Object.keys(secondaryResults).length > 0) {
+        result.secondaries = secondaryResults;
+    }
+    if (deletionResults && Object.keys(deletionResults).length > 0) {
+        result.deletions = deletionResults;
+    }
+    return result;
+}

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

@@ -0,0 +1,3 @@
+import type { DbTables, SearchParams, SearchResult } from '../../../types.js';
+export declare function searchEngine(dbTables: DbTables, params: SearchParams): Promise<SearchResult>;
+//# sourceMappingURL=search.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/lib/engine/search/search.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,QAAQ,EAER,YAAY,EACZ,YAAY,EASb,MAAM,mBAAmB,CAAC;AA+V3B,wBAAsB,YAAY,CAChC,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,YAAY,CAAC,CAyDvB"}