@remix-run/data-table 0.0.0 → 0.2.0

package/dist/lib/database/query-execution.js

@@ -0,0 +1,401 @@
+import { DataTableQueryError } from "../errors.js";
+import { normalizeWhereInput } from "../operators.js";
+import { cloneQueryState, querySnapshot } from "../query.js";
+import { getPrimaryKeyObject, getTableName } from "../table.js";
+import { executeOperation } from "./execution-context.js";
+import { buildPrimaryKeyPredicate, hasScopedWriteModifiers, loadPrimaryKeyRowsForScope, } from "./helpers.js";
+import { loadRelationsForRows } from "./relations.js";
+import { applyAfterReadHooksToLoadedRows, applyAfterReadHooksToRows, assertReturningCapability, normalizeReturningSelection, prepareInsertValues, prepareUpdateValues, runAfterDeleteHook, runAfterWriteHook, runBeforeDeleteHook, } from "./write-lifecycle.js";
+export async function executeQuery(database, input) {
+    let snapshot = input[querySnapshot]();
+    switch (snapshot.plan.kind) {
+        case 'all':
+            return (await executeAll(database, snapshot.table, snapshot.state));
+        case 'first':
+            return (await executeFirst(database, snapshot.table, snapshot.state));
+        case 'find':
+            return (await executeFind(database, snapshot.table, snapshot.state, snapshot.plan.value));
+        case 'count':
+            return (await executeCount(database, snapshot.table, snapshot.state));
+        case 'exists':
+            return (await executeExists(database, snapshot.table, snapshot.state));
+        case 'insert':
+            return (await executeInsert(database, snapshot.table, snapshot.plan.values, snapshot.plan.options));
+        case 'insertMany':
+            return (await executeInsertMany(database, snapshot.table, snapshot.plan.values, snapshot.plan.options));
+        case 'update':
+            return (await executeUpdate(database, snapshot.table, snapshot.state, snapshot.plan.changes, snapshot.plan.options));
+        case 'delete':
+            return (await executeDelete(database, snapshot.table, snapshot.state, snapshot.plan.options));
+        case 'upsert':
+            return (await executeUpsert(database, snapshot.table, snapshot.plan.values, snapshot.plan.options));
+        default:
+            throw new DataTableQueryError('Unknown query execution mode');
+    }
+}
+export async function loadRowsWithRelationsForQuery(database, input) {
+    let snapshot = input[querySnapshot]();
+    return loadRowsWithRelationsForState(database, snapshot.table, snapshot.state);
+}
+export async function loadRowsWithRelationsForState(database, table, state) {
+    let operation = createSelectOperation(table, state);
+    let result = await database[executeOperation](operation);
+    let rows = normalizeRows(result.rows);
+    if (Object.keys(state.with).length === 0) {
+        return rows;
+    }
+    return loadRelationsForRows(database, table, rows, state.with);
+}
+async function executeAll(database, table, state) {
+    let rows = await loadRowsWithRelationsForState(database, table, state);
+    return applyAfterReadHooksToLoadedRows(table, rows, state.with);
+}
+async function executeFirst(database, table, state) {
+    let rows = await executeAll(database, table, {
+        ...cloneQueryState(state),
+        limit: 1,
+    });
+    return rows[0] ?? null;
+}
+async function executeFind(database, table, state, value) {
+    let scopedState = cloneQueryState(state);
+    scopedState.where.push(normalizeWhereInput(getPrimaryKeyObject(table, value)));
+    return executeFirst(database, table, scopedState);
+}
+async function executeCount(database, table, state) {
+    let operation = {
+        kind: 'count',
+        table,
+        joins: [...state.joins],
+        where: [...state.where],
+        groupBy: [...state.groupBy],
+        having: [...state.having],
+    };
+    let result = await database[executeOperation](operation);
+    if (result.rows && result.rows[0] && typeof result.rows[0].count === 'number') {
+        return result.rows[0].count;
+    }
+    if (result.rows) {
+        return result.rows.length;
+    }
+    return 0;
+}
+async function executeExists(database, table, state) {
+    let operation = {
+        kind: 'exists',
+        table,
+        joins: [...state.joins],
+        where: [...state.where],
+        groupBy: [...state.groupBy],
+        having: [...state.having],
+    };
+    let result = await database[executeOperation](operation);
+    if (result.rows && result.rows[0] && typeof result.rows[0].exists === 'boolean') {
+        return result.rows[0].exists;
+    }
+    if (result.rows && result.rows[0] && typeof result.rows[0].count === 'number') {
+        return Number(result.rows[0].count) > 0;
+    }
+    return Boolean(result.rows && result.rows.length > 0);
+}
+async function executeInsert(database, table, values, options) {
+    let preparedValues = prepareInsertValues(table, values, database.now(), options?.touch ?? true);
+    let returning = options?.returning;
+    assertReturningCapability(database.adapter, 'insert', returning);
+    if (returning) {
+        let operation = {
+            kind: 'insert',
+            table,
+            values: preparedValues,
+            returning: normalizeReturningSelection(returning),
+        };
+        let result = await database[executeOperation](operation);
+        let row = applyAfterReadHooksToRows(table, normalizeRows(result.rows))[0] ?? null;
+        let affectedRows = result.affectedRows ?? 0;
+        runAfterWriteHook(table, {
+            operation: 'create',
+            tableName: getTableName(table),
+            values: [preparedValues],
+            affectedRows,
+            insertId: result.insertId,
+        });
+        return {
+            affectedRows,
+            insertId: result.insertId,
+            row,
+        };
+    }
+    let operation = {
+        kind: 'insert',
+        table,
+        values: preparedValues,
+    };
+    let result = await database[executeOperation](operation);
+    let affectedRows = result.affectedRows ?? 0;
+    runAfterWriteHook(table, {
+        operation: 'create',
+        tableName: getTableName(table),
+        values: [preparedValues],
+        affectedRows,
+        insertId: result.insertId,
+    });
+    return {
+        affectedRows,
+        insertId: result.insertId,
+    };
+}
+async function executeInsertMany(database, table, values, options) {
+    let preparedValues = values.map((value) => prepareInsertValues(table, value, database.now(), options?.touch ?? true));
+    if (preparedValues.length > 0 &&
+        preparedValues.every((preparedValue) => Object.keys(preparedValue).length === 0)) {
+        throw new DataTableQueryError('insertMany() requires at least one explicit value across the batch');
+    }
+    let returning = options?.returning;
+    assertReturningCapability(database.adapter, 'insertMany', returning);
+    if (returning) {
+        let operation = {
+            kind: 'insertMany',
+            table,
+            values: preparedValues,
+            returning: normalizeReturningSelection(returning),
+        };
+        let result = await database[executeOperation](operation);
+        let affectedRows = result.affectedRows ?? 0;
+        runAfterWriteHook(table, {
+            operation: 'create',
+            tableName: getTableName(table),
+            values: preparedValues,
+            affectedRows,
+            insertId: result.insertId,
+        });
+        return {
+            affectedRows,
+            insertId: result.insertId,
+            rows: applyAfterReadHooksToRows(table, normalizeRows(result.rows)),
+        };
+    }
+    let operation = {
+        kind: 'insertMany',
+        table,
+        values: preparedValues,
+    };
+    let result = await database[executeOperation](operation);
+    let affectedRows = result.affectedRows ?? 0;
+    runAfterWriteHook(table, {
+        operation: 'create',
+        tableName: getTableName(table),
+        values: preparedValues,
+        affectedRows,
+        insertId: result.insertId,
+    });
+    return {
+        affectedRows,
+        insertId: result.insertId,
+    };
+}
+async function executeUpdate(database, table, state, changes, options) {
+    let returning = options?.returning;
+    assertReturningCapability(database.adapter, 'update', returning);
+    let preparedChanges = prepareUpdateValues(table, changes, database.now(), options?.touch ?? true);
+    if (Object.keys(preparedChanges).length === 0) {
+        throw new DataTableQueryError('update() requires at least one change');
+    }
+    let result;
+    if (hasScopedWriteModifiers(state)) {
+        result = await database.transaction(async (tx) => {
+            let primaryKeys = await loadPrimaryKeyRowsForScope(tx, table, state);
+            let primaryKeyPredicate = buildPrimaryKeyPredicate(table, primaryKeys);
+            if (!primaryKeyPredicate) {
+                return {
+                    affectedRows: 0,
+                    insertId: undefined,
+                    rows: returning ? [] : undefined,
+                };
+            }
+            return tx[executeOperation]({
+                kind: 'update',
+                table,
+                changes: preparedChanges,
+                where: [primaryKeyPredicate],
+                returning: returning ? normalizeReturningSelection(returning) : undefined,
+            });
+        });
+    }
+    else {
+        let operation = {
+            kind: 'update',
+            table,
+            changes: preparedChanges,
+            where: [...state.where],
+            returning: returning ? normalizeReturningSelection(returning) : undefined,
+        };
+        result = await database[executeOperation](operation);
+    }
+    let affectedRows = result.affectedRows ?? 0;
+    runAfterWriteHook(table, {
+        operation: 'update',
+        tableName: getTableName(table),
+        values: [preparedChanges],
+        affectedRows,
+        insertId: result.insertId,
+    });
+    if (!returning) {
+        return {
+            affectedRows,
+            insertId: result.insertId,
+        };
+    }
+    return {
+        affectedRows,
+        insertId: result.insertId,
+        rows: applyAfterReadHooksToRows(table, normalizeRows(result.rows)),
+    };
+}
+async function executeDelete(database, table, state, options) {
+    let returning = options?.returning;
+    assertReturningCapability(database.adapter, 'delete', returning);
+    let tableName = getTableName(table);
+    let deleteContext = {
+        tableName,
+        where: [...state.where],
+        orderBy: [...state.orderBy],
+        limit: state.limit,
+        offset: state.offset,
+    };
+    runBeforeDeleteHook(table, deleteContext);
+    let result;
+    if (hasScopedWriteModifiers(state)) {
+        result = await database.transaction(async (tx) => {
+            let primaryKeys = await loadPrimaryKeyRowsForScope(tx, table, state);
+            let primaryKeyPredicate = buildPrimaryKeyPredicate(table, primaryKeys);
+            if (!primaryKeyPredicate) {
+                return {
+                    affectedRows: 0,
+                    insertId: undefined,
+                    rows: returning ? [] : undefined,
+                };
+            }
+            return tx[executeOperation]({
+                kind: 'delete',
+                table,
+                where: [primaryKeyPredicate],
+                returning: returning ? normalizeReturningSelection(returning) : undefined,
+            });
+        });
+    }
+    else {
+        let operation = {
+            kind: 'delete',
+            table,
+            where: [...state.where],
+            returning: returning ? normalizeReturningSelection(returning) : undefined,
+        };
+        result = await database[executeOperation](operation);
+    }
+    let affectedRows = result.affectedRows ?? 0;
+    runAfterDeleteHook(table, {
+        tableName,
+        where: deleteContext.where,
+        orderBy: deleteContext.orderBy,
+        limit: deleteContext.limit,
+        offset: deleteContext.offset,
+        affectedRows,
+    });
+    if (!returning) {
+        return {
+            affectedRows,
+            insertId: result.insertId,
+        };
+    }
+    return {
+        affectedRows,
+        insertId: result.insertId,
+        rows: applyAfterReadHooksToRows(table, normalizeRows(result.rows)),
+    };
+}
+async function executeUpsert(database, table, values, options) {
+    if (!database.adapter.capabilities.upsert) {
+        throw new DataTableQueryError('Adapter does not support upsert');
+    }
+    let preparedValues = prepareInsertValues(table, values, database.now(), options?.touch ?? true);
+    let updateChanges = options?.update
+        ? prepareUpdateValues(table, options.update, database.now(), options?.touch ?? true, 'create')
+        : undefined;
+    let returning = options?.returning;
+    assertReturningCapability(database.adapter, 'upsert', returning);
+    if (returning) {
+        let operation = {
+            kind: 'upsert',
+            table,
+            values: preparedValues,
+            conflictTarget: options?.conflictTarget ? [...options.conflictTarget] : undefined,
+            update: updateChanges,
+            returning: normalizeReturningSelection(returning),
+        };
+        let result = await database[executeOperation](operation);
+        let row = applyAfterReadHooksToRows(table, normalizeRows(result.rows))[0] ?? null;
+        let affectedRows = result.affectedRows ?? 0;
+        let preparedWriteValues = updateChanges ? [preparedValues, updateChanges] : [preparedValues];
+        runAfterWriteHook(table, {
+            operation: 'create',
+            tableName: getTableName(table),
+            values: preparedWriteValues,
+            affectedRows,
+            insertId: result.insertId,
+        });
+        return {
+            affectedRows,
+            insertId: result.insertId,
+            row,
+        };
+    }
+    let operation = {
+        kind: 'upsert',
+        table,
+        values: preparedValues,
+        conflictTarget: options?.conflictTarget ? [...options.conflictTarget] : undefined,
+        update: updateChanges,
+    };
+    let result = await database[executeOperation](operation);
+    let affectedRows = result.affectedRows ?? 0;
+    let preparedWriteValues = updateChanges ? [preparedValues, updateChanges] : [preparedValues];
+    runAfterWriteHook(table, {
+        operation: 'create',
+        tableName: getTableName(table),
+        values: preparedWriteValues,
+        affectedRows,
+        insertId: result.insertId,
+    });
+    return {
+        affectedRows,
+        insertId: result.insertId,
+    };
+}
+function createSelectOperation(table, state) {
+    let clonedState = cloneQueryState(state);
+    return {
+        kind: 'select',
+        table,
+        select: cloneSelection(clonedState.select),
+        distinct: clonedState.distinct,
+        joins: clonedState.joins,
+        where: clonedState.where,
+        groupBy: clonedState.groupBy,
+        having: clonedState.having,
+        orderBy: clonedState.orderBy,
+        limit: clonedState.limit,
+        offset: clonedState.offset,
+    };
+}
+function cloneSelection(selection) {
+    if (selection === '*') {
+        return '*';
+    }
+    return selection.map((column) => ({ ...column }));
+}
+function normalizeRows(rows) {
+    if (!rows) {
+        return [];
+    }
+    return rows.map((row) => ({ ...row }));
+}

package/dist/lib/database/relations.d.ts

@@ -0,0 +1,4 @@
+import type { AnyRelation, AnyTable } from '../table.ts';
+import type { QueryExecutionContext } from './execution-context.ts';
+export declare function loadRelationsForRows(database: QueryExecutionContext, sourceTable: AnyTable, rows: Record<string, unknown>[], relationMap: Record<string, AnyRelation>): Promise<Record<string, unknown>[]>;
+//# sourceMappingURL=relations.d.ts.map

package/dist/lib/database/relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../../../src/lib/database/relations.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAY,MAAM,aAAa,CAAA;AAGlE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAA;AAWnE,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,qBAAqB,EAC/B,WAAW,EAAE,QAAQ,EACrB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GACvC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CA4BpC"}

package/dist/lib/database/relations.js

@@ -0,0 +1,207 @@
+import { DataTableQueryError } from "../errors.js";
+import { and, eq, inList, or } from "../operators.js";
+import { query as createQuery } from "../query.js";
+import { getCompositeKey, getTableName, getTablePrimaryKey } from "../table.js";
+import { loadRowsWithRelationsForQuery } from "./query-execution.js";
+export async function loadRelationsForRows(database, sourceTable, rows, relationMap) {
+    let output = rows.map((row) => ({ ...row }));
+    let relationNames = Object.keys(relationMap);
+    for (let relationName of relationNames) {
+        let relation = relationMap[relationName];
+        if (relation.sourceTable !== sourceTable) {
+            throw new DataTableQueryError('Relation "' +
+                relationName +
+                '" is not defined for source table "' +
+                getTableName(sourceTable) +
+                '"');
+        }
+        let values = await resolveRelationValues(database, output, relation);
+        let index = 0;
+        while (index < output.length) {
+            output[index][relationName] = values[index];
+            index += 1;
+        }
+    }
+    return output;
+}
+async function resolveRelationValues(database, sourceRows, relation) {
+    if (relation.relationKind === 'hasManyThrough') {
+        return loadHasManyThroughValues(database, sourceRows, relation);
+    }
+    return loadDirectRelationValues(database, sourceRows, relation);
+}
+async function loadDirectRelationValues(database, sourceRows, relation) {
+    if (sourceRows.length === 0) {
+        return [];
+    }
+    let sourceTuples = uniqueTuples(sourceRows, relation.sourceKey);
+    if (sourceTuples.length === 0) {
+        return sourceRows.map(() => (relation.cardinality === 'many' ? [] : null));
+    }
+    let query = createQuery(relation.targetTable);
+    let linkPredicate = buildLinkPredicate(relation.targetKey, sourceTuples);
+    if (linkPredicate) {
+        query = query.where(linkPredicate);
+    }
+    query = applyRelationModifiers(query, relation, {
+        includePagination: false,
+    });
+    let relatedRows = await loadRowsWithRelationsForQuery(database, query);
+    let grouped = groupRowsByTuple(relatedRows, relation.targetKey);
+    return sourceRows.map((sourceRow) => {
+        let key = getCompositeKey(sourceRow, relation.sourceKey);
+        let matches = grouped.get(key) ?? [];
+        let pagedMatches = applyPagination(matches, relation.modifiers.limit, relation.modifiers.offset);
+        if (relation.cardinality === 'many') {
+            return pagedMatches;
+        }
+        return pagedMatches[0] ?? null;
+    });
+}
+async function loadHasManyThroughValues(database, sourceRows, relation) {
+    if (!relation.through) {
+        throw new DataTableQueryError('hasManyThrough relation is missing through metadata');
+    }
+    if (sourceRows.length === 0) {
+        return [];
+    }
+    let throughRelation = relation.through.relation;
+    let sourceTuples = uniqueTuples(sourceRows, throughRelation.sourceKey);
+    if (sourceTuples.length === 0) {
+        return sourceRows.map(() => []);
+    }
+    let throughQuery = createQuery(throughRelation.targetTable);
+    let throughPredicate = buildLinkPredicate(throughRelation.targetKey, sourceTuples);
+    if (throughPredicate) {
+        throughQuery = throughQuery.where(throughPredicate);
+    }
+    throughQuery = applyRelationModifiers(throughQuery, throughRelation, {
+        includePagination: false,
+    });
+    let throughRows = await loadRowsWithRelationsForQuery(database, throughQuery);
+    if (throughRows.length === 0) {
+        return sourceRows.map(() => []);
+    }
+    let throughRowsBySource = groupRowsByTuple(throughRows, throughRelation.targetKey);
+    let pagedThroughRowsBySource = new Map();
+    let pagedThroughRows = [];
+    for (let sourceRow of sourceRows) {
+        let sourceKey = getCompositeKey(sourceRow, throughRelation.sourceKey);
+        let matchedThroughRows = throughRowsBySource.get(sourceKey) ?? [];
+        let pagedMatchedRows = applyPagination(matchedThroughRows, throughRelation.modifiers.limit, throughRelation.modifiers.offset);
+        pagedThroughRowsBySource.set(sourceKey, pagedMatchedRows);
+        pagedThroughRows.push(...pagedMatchedRows);
+    }
+    let throughTuples = uniqueTuples(pagedThroughRows, relation.through.throughSourceKey);
+    if (throughTuples.length === 0) {
+        return sourceRows.map(() => []);
+    }
+    let targetQuery = createQuery(relation.targetTable);
+    let targetPredicate = buildLinkPredicate(relation.through.throughTargetKey, throughTuples);
+    if (targetPredicate) {
+        targetQuery = targetQuery.where(targetPredicate);
+    }
+    targetQuery = applyRelationModifiers(targetQuery, relation, {
+        includePagination: false,
+    });
+    let relatedRows = await loadRowsWithRelationsForQuery(database, targetQuery);
+    let targetRowsByThrough = groupRowsByTuple(relatedRows, relation.through.throughTargetKey);
+    return sourceRows.map((sourceRow) => {
+        let sourceKey = getCompositeKey(sourceRow, throughRelation.sourceKey);
+        let matchedThroughRows = pagedThroughRowsBySource.get(sourceKey) ?? [];
+        let outputRows = [];
+        let seen = new Set();
+        for (let throughRow of matchedThroughRows) {
+            let throughKey = getCompositeKey(throughRow, relation.through.throughSourceKey);
+            let rowsForThrough = targetRowsByThrough.get(throughKey) ?? [];
+            for (let row of rowsForThrough) {
+                let rowIdentity = getCompositeKey(row, getTablePrimaryKey(relation.targetTable));
+                if (!seen.has(rowIdentity)) {
+                    seen.add(rowIdentity);
+                    outputRows.push(row);
+                }
+            }
+        }
+        return applyPagination(outputRows, relation.modifiers.limit, relation.modifiers.offset);
+    });
+}
+function applyRelationModifiers(query, relation, options) {
+    let next = query;
+    for (let predicate of relation.modifiers.where) {
+        next = next.where(predicate);
+    }
+    for (let clause of relation.modifiers.orderBy) {
+        next = next.orderBy(clause.column, clause.direction);
+    }
+    if (options.includePagination && relation.modifiers.limit !== undefined) {
+        next = next.limit(relation.modifiers.limit);
+    }
+    if (options.includePagination && relation.modifiers.offset !== undefined) {
+        next = next.offset(relation.modifiers.offset);
+    }
+    if (Object.keys(relation.modifiers.with).length > 0) {
+        next = next.with(relation.modifiers.with);
+    }
+    return next;
+}
+function applyPagination(rows, limit, offset) {
+    let offsetRows = offset === undefined ? rows : rows.slice(offset);
+    return limit === undefined ? offsetRows : offsetRows.slice(0, limit);
+}
+function uniqueTuples(rows, columns) {
+    let output = [];
+    let seen = new Set();
+    for (let row of rows) {
+        let tuple = columns.map((column) => row[column]);
+        let key = tuple.map(stringifyForKey).join('::');
+        if (!seen.has(key)) {
+            seen.add(key);
+            output.push(tuple);
+        }
+    }
+    return output;
+}
+function buildLinkPredicate(targetColumns, tuples) {
+    if (tuples.length === 0) {
+        return undefined;
+    }
+    if (targetColumns.length === 1) {
+        return inList(targetColumns[0], tuples.map((tuple) => tuple[0]));
+    }
+    let tuplePredicates = tuples.map((tuple) => {
+        let comparisons = targetColumns.map((column, index) => eq(column, tuple[index]));
+        return and(...comparisons);
+    });
+    return or(...tuplePredicates);
+}
+function groupRowsByTuple(rows, columns) {
+    let output = new Map();
+    for (let row of rows) {
+        let key = getCompositeKey(row, columns);
+        let group = output.get(key);
+        if (group) {
+            group.push(row);
+            continue;
+        }
+        output.set(key, [row]);
+    }
+    return output;
+}
+function stringifyForKey(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (value instanceof Date) {
+        return 'date:' + value.toISOString();
+    }
+    if (typeof value === 'string') {
+        return JSON.stringify(value);
+    }
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+        return String(value);
+    }
+    return JSON.stringify(value);
+}

package/dist/lib/database/write-lifecycle.d.ts

@@ -0,0 +1,13 @@
+import type { DatabaseAdapter, ReturningSelection } from '../adapter.ts';
+import type { ReturningInput } from '../database.ts';
+import type { AnyRelation, AnyTable, TableAfterDeleteContext, TableAfterWriteContext, TableBeforeDeleteContext, TableRow, TableWriteOperation } from '../table.ts';
+export declare function prepareInsertValues<table extends AnyTable>(table: table, values: Partial<TableRow<table>>, now: unknown, touch: boolean): Record<string, unknown>;
+export declare function prepareUpdateValues<table extends AnyTable>(table: table, values: Partial<TableRow<table>>, now: unknown, touch: boolean, operation?: TableWriteOperation): Record<string, unknown>;
+export declare function applyAfterReadHooksToRows<table extends AnyTable>(table: table, rows: Record<string, unknown>[]): Record<string, unknown>[];
+export declare function applyAfterReadHooksToLoadedRows(table: AnyTable, rows: Record<string, unknown>[], relationMap: Record<string, AnyRelation>): Record<string, unknown>[];
+export declare function runBeforeDeleteHook<table extends AnyTable>(table: table, context: TableBeforeDeleteContext): void;
+export declare function runAfterWriteHook<table extends AnyTable>(table: table, context: TableAfterWriteContext<TableRow<table>>): void;
+export declare function runAfterDeleteHook<table extends AnyTable>(table: table, context: TableAfterDeleteContext): void;
+export declare function assertReturningCapability<row extends Record<string, unknown>>(adapter: DatabaseAdapter, operation: 'insert' | 'insertMany' | 'update' | 'delete' | 'upsert', returning: ReturningInput<row> | undefined): void;
+export declare function normalizeReturningSelection<row extends Record<string, unknown>>(returning: ReturningInput<row>): ReturningSelection;
+//# sourceMappingURL=write-lifecycle.d.ts.map

package/dist/lib/database/write-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-lifecycle.d.ts","sourceRoot":"","sources":["../../../src/lib/database/write-lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAExE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AACpD,OAAO,KAAK,EACV,WAAW,EACX,QAAQ,EACR,uBAAuB,EACvB,sBAAsB,EACtB,wBAAwB,EAExB,QAAQ,EACR,mBAAmB,EAEpB,MAAM,aAAa,CAAA;AAqBpB,wBAAgB,mBAAmB,CAAC,KAAK,SAAS,QAAQ,EACxD,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAChC,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,OAAO,GACb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyBzB;AAED,wBAAgB,mBAAmB,CAAC,KAAK,SAAS,QAAQ,EACxD,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAChC,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,OAAO,EACd,SAAS,GAAE,mBAA8B,GACxC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAiBzB;AAED,wBAAgB,yBAAyB,CAAC,KAAK,SAAS,QAAQ,EAC9D,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAC9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAoC3B;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GACvC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CA6C3B;AAED,wBAAgB,mBAAmB,CAAC,KAAK,SAAS,QAAQ,EACxD,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,wBAAwB,GAChC,IAAI,CA6BN;AAED,wBAAgB,iBAAiB,CAAC,KAAK,SAAS,QAAQ,EACtD,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,sBAAsB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,GAC/C,IAAI,CAcN;AAED,wBAAgB,kBAAkB,CAAC,KAAK,SAAS,QAAQ,EACvD,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,uBAAuB,GAC/B,IAAI,CASN;AAED,wBAAgB,yBAAyB,CAAC,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3E,OAAO,EAAE,eAAe,EACxB,SAAS,EAAE,QAAQ,GAAG,YAAY,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,EACnE,SAAS,EAAE,cAAc,CAAC,GAAG,CAAC,GAAG,SAAS,GACzC,IAAI,CAIN;AAED,wBAAgB,2BAA2B,CAAC,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7E,SAAS,EAAE,cAAc,CAAC,GAAG,CAAC,GAC7B,kBAAkB,CAMpB"}