@appweaver/data 0.0.0-stage → 2.0.0

package/resource/utils/date-util.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIsoDate = parseIsoDate;
+exports.addSeconds = addSeconds;
+exports.addMinutes = addMinutes;
+exports.addHours = addHours;
+exports.addDays = addDays;
+exports.addMonths = addMonths;
+exports.addYears = addYears;
+exports.differenceInSeconds = differenceInSeconds;
+exports.differenceInMonths = differenceInMonths;
+exports.differenceInYears = differenceInYears;
+const MS_IN_SECOND = 1000;
+const MS_IN_MINUTE = 60 * MS_IN_SECOND;
+const MS_IN_HOUR = 60 * MS_IN_MINUTE;
+/** A date-only ISO string, which reads as the local midnight instead of the UTC one of the `Date` constructor. */
+const DATE_ONLY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+/**
+ * Parses an ISO 8601 date string. A date without a time is the local midnight of that day, a date and time without an
+ * offset is local, and one with an offset is that exact instant.
+ *
+ * @param {string} value - The ISO date string.
+ * @return {Date} The parsed date, invalid when the string is not a date.
+ */
+function parseIsoDate(value) {
+    const dateOnly = DATE_ONLY_PATTERN.exec(value);
+    if (dateOnly) {
+        const [, year, month, day] = dateOnly;
+        return new Date(Number(year), Number(month) - 1, Number(day));
+    }
+    return new Date(value);
+}
+function addSeconds(date, amount) {
+    return new Date(date.getTime() + amount * MS_IN_SECOND);
+}
+function addMinutes(date, amount) {
+    return new Date(date.getTime() + amount * MS_IN_MINUTE);
+}
+function addHours(date, amount) {
+    return new Date(date.getTime() + amount * MS_IN_HOUR);
+}
+/** Adds whole local days, keeping the time of day across daylight saving time changes. */
+function addDays(date, amount) {
+    const result = new Date(date.getTime());
+    if (amount) {
+        result.setDate(result.getDate() + amount);
+    }
+    return result;
+}
+/** Adds whole local months, clamping the day to the last day of a shorter month (January 31 plus one is February 28). */
+function addMonths(date, amount) {
+    const result = new Date(date.getTime());
+    if (!amount) {
+        return result;
+    }
+    const dayOfMonth = result.getDate();
+    const endOfDesiredMonth = new Date(date.getTime());
+    endOfDesiredMonth.setMonth(result.getMonth() + amount + 1, 0);
+    if (dayOfMonth >= endOfDesiredMonth.getDate()) {
+        return endOfDesiredMonth;
+    }
+    result.setFullYear(endOfDesiredMonth.getFullYear(), endOfDesiredMonth.getMonth(), dayOfMonth);
+    return result;
+}
+function addYears(date, amount) {
+    return addMonths(date, amount * 12);
+}
+/** Returns the whole seconds between two dates, truncated toward zero. */
+function differenceInSeconds(laterDate, earlierDate) {
+    return Math.trunc((laterDate.getTime() - earlierDate.getTime()) / MS_IN_SECOND);
+}
+/** Returns the full local months between two dates, negative when the first date is the earlier one. */
+function differenceInMonths(laterDate, earlierDate) {
+    const sign = compare(laterDate, earlierDate);
+    const difference = Math.abs((laterDate.getFullYear() - earlierDate.getFullYear()) * 12 +
+        laterDate.getMonth() -
+        earlierDate.getMonth());
+    if (difference < 1) {
+        return 0;
+    }
+    const working = new Date(laterDate.getTime());
+    if (working.getMonth() === 1 && working.getDate() > 27) {
+        working.setDate(30);
+    }
+    working.setMonth(working.getMonth() - sign * difference);
+    // The last month counts only once its day is reached, unless the later date ends a month
+    let isLastMonthNotFull = compare(working, earlierDate) === -sign;
+    if (isLastDayOfMonth(laterDate) && difference === 1 && sign === 1) {
+        isLastMonthNotFull = false;
+    }
+    return sign * (difference - Number(isLastMonthNotFull)) || 0;
+}
+/** Returns the full local years between two dates, negative when the first date is the earlier one. */
+function differenceInYears(laterDate, earlierDate) {
+    const sign = compare(laterDate, earlierDate);
+    const difference = Math.abs(laterDate.getFullYear() - earlierDate.getFullYear());
+    // Compares the dates within the same leap year to tell whether the last year is full
+    const later = new Date(laterDate.getTime());
+    const earlier = new Date(earlierDate.getTime());
+    later.setFullYear(1584);
+    earlier.setFullYear(1584);
+    const isLastYearNotFull = compare(later, earlier) === -sign;
+    return sign * (difference - Number(isLastYearNotFull)) || 0;
+}
+function compare(left, right) {
+    return Math.sign(left.getTime() - right.getTime());
+}
+function isLastDayOfMonth(date) {
+    const next = new Date(date.getTime());
+    next.setDate(next.getDate() + 1);
+    return next.getMonth() !== date.getMonth();
+}

package/resource/utils/delete-util.d.ts

@@ -0,0 +1,131 @@
+import { ResourceId } from '@appweaver/common';
+/** The nested write actions a single relation field can be mapped to. */
+export type RelationActions = Record<string, Partial<{
+    connect: any;
+    create: any;
+    update: any;
+    connectOrCreate: any;
+    disconnect: any;
+    delete: any;
+}>>;
+/** The records of every model affected by a delete, keyed by model name. */
+export type AffectedRecords = Record<string, ResourceId[]>;
+/** The records deleted by one action, split by how they were deleted. */
+export type DeletedRecords = {
+    /** Records marked with the soft delete columns */
+    soft: AffectedRecords;
+    /** Records removed from the database */
+    hard: AffectedRecords;
+};
+/** The columns marking a record as soft deleted. */
+export type SoftDeleteData = {
+    deletedAt: Date;
+    deletedById?: ResourceId | null;
+};
+/**
+ * Restricts a mapped relation filter to the related records that are not soft deleted, so a filter never matches
+ * through a deleted record, and a null check treats a deleted related record as missing.
+ *
+ * @param {*} condition - The mapped database condition of the relation field.
+ * @param {string} resourceName - The name of the related model.
+ * @param {boolean} isArrayType - Whether the relation is a list (to-many) relation.
+ * @return {*} The condition restricted to the live related records, or unchanged if the related model does not soft
+ * delete its records.
+ */
+export declare function liveRelationFilter(condition: any, resourceName: string, isArrayType: boolean): any;
+/**
+ * Builds the inclusion filter of a list relation, so only the related records that are not soft deleted are read.
+ *
+ * @param {string} [resourceName] - The name of the related model.
+ * @return {Object|undefined} The `where` clause of the inclusion, or undefined if the related model does not soft
+ * delete its records.
+ */
+export declare function liveInclusionFilter(resourceName?: string): {
+    where: Record<string, any>;
+} | undefined;
+/**
+ * Replaces the soft deleted records in the single relations of a resource with null, recursively. Unlike the list
+ * relations, a single relation cannot be filtered when it is read.
+ *
+ * @param {Object} resource - The resource as returned by the database client.
+ * @param {string} resourceName - The name of the model describing the resource.
+ * @return {Object} A copy of the resource without the soft deleted related records, or the resource itself if it
+ * holds no relations.
+ */
+export declare function hideDeletedRelations<T>(resource: T, resourceName: string): T;
+/**
+ * Builds the column values marking a record as soft deleted now by the current user, who is only recorded when the
+ * application defines an auth model.
+ *
+ * @return {SoftDeleteData} The soft delete column values.
+ */
+export declare function softDeleteData(): SoftDeleteData;
+/**
+ * Mirrors the referential actions of a database delete for soft deleted records: cascading records are soft deleted
+ * with the same column values, level by level, a restricting relation aborts the delete, and references set to null on
+ * delete are kept for a manual restore. The records themselves are not updated.
+ *
+ * @param {Object} tx - The transaction client the delete runs in.
+ * @param {string} resourceName - The name of the model of the deleted records.
+ * @param {ResourceId[]} ids - The ids of the deleted records.
+ * @param {SoftDeleteData} data - The soft delete column values applied to the cascaded records.
+ * @return {Promise<AffectedRecords>} The ids of the soft deleted records per model, excluding the records themselves.
+ * @throws {ResourceError} `RESOURCE_DELETE_RESTRICTED` if a live record references a deleted record through a
+ * restricting relation.
+ */
+export declare function softDeleteCascade(tx: any, resourceName: string, ids: ResourceId[], data: SoftDeleteData): Promise<AffectedRecords>;
+/**
+ * Collects the records the database cascade removes together with deleted records, so their files and caches can be
+ * cleaned up once the delete commits.
+ *
+ * @param {Object} tx - The transaction client the delete runs in.
+ * @param {string} resourceName - The name of the model of the deleted records.
+ * @param {ResourceId[]} ids - The ids of the deleted records.
+ * @return {Promise<AffectedRecords>} The ids of the cascaded records per model, excluding the records themselves.
+ */
+export declare function cascadedRecords(tx: any, resourceName: string, ids: ResourceId[]): Promise<AffectedRecords>;
+/**
+ * Removes the orphans an update maps to a nested `delete` action (`orphanRemoval`). Orphans of a soft deleted model are
+ * soft deleted with their cascade and keep their references, so their `delete` action is dropped; the others are left
+ * to the `delete` action, collecting the records its cascade removes.
+ *
+ * @param {Object} tx - The transaction client the update runs in.
+ * @param {string} resourceName - The name of the model the relation actions belong to.
+ * @param {RelationActions} relationActions - The mapped relation write actions, from which the nested `delete` actions
+ * of the soft deleted orphans are removed.
+ * @param {SoftDeleteData} data - The soft delete column values applied to the soft deleted orphans.
+ * @return {Promise<DeletedRecords>} The ids of the soft deleted and the removed records per model.
+ * @throws {ResourceError} `RESOURCE_DELETE_RESTRICTED` if a live record references a soft deleted orphan through a
+ * restricting relation.
+ */
+export declare function removeOrphans(tx: any, resourceName: string, relationActions: RelationActions, data: SoftDeleteData): Promise<DeletedRecords>;
+/**
+ * Marks the file rows of the files the deleted records keep (`onResourceDeleted` / `onResourceSoftDeleted: 'keep'`) as
+ * deleted with the values of the delete, so they stay stored, e.g. for audit, but are no longer served.
+ *
+ * @param {Object} tx - The transaction client the delete runs in.
+ * @param {DeletedRecords} deleted - The soft deleted and the removed records.
+ * @param {SoftDeleteData} data - The soft delete column values of the delete.
+ * @return {Promise<void>} Resolves when the kept files are marked deleted.
+ */
+export declare function retainDeletedFiles(tx: any, deleted: DeletedRecords, data: SoftDeleteData): Promise<void>;
+/**
+ * Merges the affected records of several deletes into the target, keeping the ids of every model unique.
+ *
+ * @param {AffectedRecords} target - The affected records merged into.
+ * @param {AffectedRecords[]} sources - The affected records to add.
+ * @return {AffectedRecords} The target holding the ids of every source.
+ */
+export declare function mergeAffectedRecords(target: AffectedRecords, ...sources: AffectedRecords[]): AffectedRecords;
+/**
+ * Rejects the relation write actions pointing at soft deleted records, which the database would otherwise connect or
+ * update, since it does not know the record is deleted.
+ *
+ * @param {Object} client - The database client, or the transaction client the write runs in.
+ * @param {string} resourceName - The name of the model the relation actions belong to.
+ * @param {RelationActions} relationActions - The mapped relation write actions.
+ * @return {Promise<void>} Resolves when no action points at a soft deleted record.
+ * @throws {ResourceError} `RESOURCE_INVALID_RELATION` if a connect, update or connect-or-create action matches a soft
+ * deleted record.
+ */
+export declare function assertLiveRelationTargets(client: any, resourceName: string, relationActions: RelationActions): Promise<void>;

package/resource/utils/delete-util.js

@@ -0,0 +1,385 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.liveRelationFilter = liveRelationFilter;
+exports.liveInclusionFilter = liveInclusionFilter;
+exports.hideDeletedRelations = hideDeletedRelations;
+exports.softDeleteData = softDeleteData;
+exports.softDeleteCascade = softDeleteCascade;
+exports.cascadedRecords = cascadedRecords;
+exports.removeOrphans = removeOrphans;
+exports.retainDeletedFiles = retainDeletedFiles;
+exports.mergeAffectedRecords = mergeAffectedRecords;
+exports.assertLiveRelationTargets = assertLiveRelationTargets;
+const common_1 = require("@appweaver/common");
+const internal_1 = require("@appweaver/core/internal");
+const core_1 = require("@appweaver/core");
+const helper_1 = require("../../security/helper");
+const file_util_1 = require("../../utils/file-util");
+const model_util_1 = require("../../utils/model-util");
+/** The condition matching the records that are not soft deleted. */
+const LIVE_RECORD = Object.freeze({ deletedAt: null });
+/** The condition matching the soft deleted records. */
+const DELETED_RECORD = Object.freeze({ deletedAt: { not: null } });
+/** Referential actions that prevent deleting a record while others reference it. */
+const RESTRICTING_ACTIONS = ['restrict', 'noAction'];
+/**
+ * Restricts a mapped relation filter to the related records that are not soft deleted, so a filter never matches
+ * through a deleted record, and a null check treats a deleted related record as missing.
+ *
+ * @param {*} condition - The mapped database condition of the relation field.
+ * @param {string} resourceName - The name of the related model.
+ * @param {boolean} isArrayType - Whether the relation is a list (to-many) relation.
+ * @return {*} The condition restricted to the live related records, or unchanged if the related model does not soft
+ * delete its records.
+ */
+function liveRelationFilter(condition, resourceName, isArrayType) {
+    if (!(0, model_util_1.isSoftDeleteModel)(resourceName)) {
+        return condition;
+    }
+    if (isArrayType) {
+        if (!(0, common_1.isPlainObject)(condition)) {
+            return condition;
+        }
+        const mapped = { ...condition };
+        for (const quantifier of ['some', 'none']) {
+            if (mapped[quantifier] !== undefined) {
+                mapped[quantifier] = { AND: [mapped[quantifier], LIVE_RECORD] };
+            }
+        }
+        if (mapped.every !== undefined) {
+            mapped.every = { OR: [mapped.every, DELETED_RECORD] };
+        }
+        return mapped;
+    }
+    if (condition === null) {
+        return { isNot: LIVE_RECORD };
+    }
+    if (!(0, common_1.isPlainObject)(condition)) {
+        return condition;
+    }
+    const { is, isNot, ...fields } = condition;
+    const matches = [];
+    const mapped = {};
+    if (is === null) {
+        mapped.isNot = LIVE_RECORD;
+    }
+    else if (is !== undefined) {
+        matches.push(is);
+    }
+    if (isNot === null) {
+        matches.push({});
+    }
+    else if (isNot !== undefined) {
+        mapped.isNot = { AND: [isNot, LIVE_RECORD] };
+    }
+    // The fields given without `is` are its shorthand
+    if (Object.keys(fields).length > 0) {
+        matches.push(fields);
+    }
+    if (matches.length > 0) {
+        mapped.is = { AND: [...matches, LIVE_RECORD] };
+    }
+    return mapped;
+}
+/**
+ * Builds the inclusion filter of a list relation, so only the related records that are not soft deleted are read.
+ *
+ * @param {string} [resourceName] - The name of the related model.
+ * @return {Object|undefined} The `where` clause of the inclusion, or undefined if the related model does not soft
+ * delete its records.
+ */
+function liveInclusionFilter(resourceName) {
+    return (0, model_util_1.isSoftDeleteModel)(resourceName)
+        ? { where: { ...LIVE_RECORD } }
+        : undefined;
+}
+/**
+ * Replaces the soft deleted records in the single relations of a resource with null, recursively. Unlike the list
+ * relations, a single relation cannot be filtered when it is read.
+ *
+ * @param {Object} resource - The resource as returned by the database client.
+ * @param {string} resourceName - The name of the model describing the resource.
+ * @return {Object} A copy of the resource without the soft deleted related records, or the resource itself if it
+ * holds no relations.
+ */
+function hideDeletedRelations(resource, resourceName) {
+    const relations = (0, core_1.injectModel)(resourceName, false)?.config?.relations;
+    if (!(0, common_1.isPlainObject)(resource) || !relations) {
+        return resource;
+    }
+    const projected = { ...resource };
+    for (const [key, relation] of Object.entries(relations)) {
+        const value = projected[key];
+        const relatedName = (0, common_1.capitalize)(relation.model);
+        if ((0, common_1.isArray)(value)) {
+            projected[key] = value.map((item) => hideDeletedRelations(item, relatedName));
+        }
+        else if ((0, common_1.isPlainObject)(value)) {
+            projected[key] =
+                value.deletedAt != null && (0, model_util_1.isSoftDeleteModel)(relatedName)
+                    ? null
+                    : hideDeletedRelations(value, relatedName);
+        }
+    }
+    return projected;
+}
+/**
+ * Builds the column values marking a record as soft deleted now by the current user, who is only recorded when the
+ * application defines an auth model.
+ *
+ * @return {SoftDeleteData} The soft delete column values.
+ */
+function softDeleteData() {
+    const data = { deletedAt: new Date() };
+    if ((0, helper_1.resourceAuthModel)()) {
+        data.deletedById = (0, core_1.currentAuthUser)()?.id ?? null;
+    }
+    return data;
+}
+/**
+ * Mirrors the referential actions of a database delete for soft deleted records: cascading records are soft deleted
+ * with the same column values, level by level, a restricting relation aborts the delete, and references set to null on
+ * delete are kept for a manual restore. The records themselves are not updated.
+ *
+ * @param {Object} tx - The transaction client the delete runs in.
+ * @param {string} resourceName - The name of the model of the deleted records.
+ * @param {ResourceId[]} ids - The ids of the deleted records.
+ * @param {SoftDeleteData} data - The soft delete column values applied to the cascaded records.
+ * @return {Promise<AffectedRecords>} The ids of the soft deleted records per model, excluding the records themselves.
+ * @throws {ResourceError} `RESOURCE_DELETE_RESTRICTED` if a live record references a deleted record through a
+ * restricting relation.
+ */
+async function softDeleteCascade(tx, resourceName, ids, data) {
+    return walkReferencingRecords(tx, resourceName, ids, async (relation) => {
+        const client = tx[(0, common_1.uncapitalize)(relation.modelName)];
+        const where = {
+            [relation.foreignKey]: { in: relation.ids },
+            ...(0, model_util_1.liveRecordFilter)(relation.modelName)
+        };
+        if (RESTRICTING_ACTIONS.includes(relation.onDelete)) {
+            await assertNotReferenced(client, where, relation);
+            return [];
+        }
+        if (relation.onDelete !== 'cascade') {
+            return [];
+        }
+        // Loading validates every cascade of a soft deleted model, so this only
+        // guards the models registered after it
+        if (!(0, model_util_1.isSoftDeleteModel)(relation.modelName)) {
+            throw new common_1.ConfigurationError(common_1.ErrorCode.ConfigurationInvalid, `${relation.modelName} must enable soft delete to cascade from ${relation.referencedName}`);
+        }
+        const records = await client.findMany({ where, select: { id: true } });
+        const cascadedIds = records.map((record) => record.id);
+        if (cascadedIds.length > 0) {
+            await client.updateMany({ where: { id: { in: cascadedIds } }, data });
+        }
+        return cascadedIds;
+    });
+}
+/**
+ * Collects the records the database cascade removes together with deleted records, so their files and caches can be
+ * cleaned up once the delete commits.
+ *
+ * @param {Object} tx - The transaction client the delete runs in.
+ * @param {string} resourceName - The name of the model of the deleted records.
+ * @param {ResourceId[]} ids - The ids of the deleted records.
+ * @return {Promise<AffectedRecords>} The ids of the cascaded records per model, excluding the records themselves.
+ */
+async function cascadedRecords(tx, resourceName, ids) {
+    return walkReferencingRecords(tx, resourceName, ids, async (relation) => {
+        if (relation.onDelete !== 'cascade') {
+            return [];
+        }
+        // Soft deleted records are removed by the cascade as well
+        const records = await tx[(0, common_1.uncapitalize)(relation.modelName)].findMany({
+            where: { [relation.foreignKey]: { in: relation.ids } },
+            select: { id: true }
+        });
+        return records.map((record) => record.id);
+    });
+}
+/**
+ * Removes the orphans an update maps to a nested `delete` action (`orphanRemoval`). Orphans of a soft deleted model are
+ * soft deleted with their cascade and keep their references, so their `delete` action is dropped; the others are left
+ * to the `delete` action, collecting the records its cascade removes.
+ *
+ * @param {Object} tx - The transaction client the update runs in.
+ * @param {string} resourceName - The name of the model the relation actions belong to.
+ * @param {RelationActions} relationActions - The mapped relation write actions, from which the nested `delete` actions
+ * of the soft deleted orphans are removed.
+ * @param {SoftDeleteData} data - The soft delete column values applied to the soft deleted orphans.
+ * @return {Promise<DeletedRecords>} The ids of the soft deleted and the removed records per model.
+ * @throws {ResourceError} `RESOURCE_DELETE_RESTRICTED` if a live record references a soft deleted orphan through a
+ * restricting relation.
+ */
+async function removeOrphans(tx, resourceName, relationActions, data) {
+    const relations = (0, core_1.injectModel)(resourceName, false)?.config?.relations ?? {};
+    const deleted = { soft: {}, hard: {} };
+    for (const [key, actions] of Object.entries(relationActions)) {
+        const relation = relations[key];
+        if (!actions?.delete || !relation) {
+            continue;
+        }
+        const relatedName = (0, common_1.capitalize)(relation.model);
+        const client = tx[(0, common_1.uncapitalize)(relatedName)];
+        const orphans = await client.findMany({
+            where: { OR: asList(actions.delete) },
+            select: { id: true }
+        });
+        const ids = orphans.map((orphan) => orphan.id);
+        if (ids.length === 0) {
+            continue;
+        }
+        if ((0, model_util_1.isSoftDeleteModel)(relatedName)) {
+            // Left undefined rather than removed, so the raw input value of the
+            // relation does not reach the database write in its place
+            delete actions.delete;
+            if (Object.keys(actions).length === 0) {
+                relationActions[key] = undefined;
+            }
+            const cascaded = await softDeleteCascade(tx, relatedName, ids, data);
+            await client.updateMany({ where: { id: { in: ids } }, data });
+            mergeAffectedRecords(deleted.soft, { [relatedName]: ids }, cascaded);
+        }
+        else {
+            const cascaded = await cascadedRecords(tx, relatedName, ids);
+            mergeAffectedRecords(deleted.hard, { [relatedName]: ids }, cascaded);
+        }
+    }
+    return deleted;
+}
+/**
+ * Marks the file rows of the files the deleted records keep (`onResourceDeleted` / `onResourceSoftDeleted: 'keep'`) as
+ * deleted with the values of the delete, so they stay stored, e.g. for audit, but are no longer served.
+ *
+ * @param {Object} tx - The transaction client the delete runs in.
+ * @param {DeletedRecords} deleted - The soft deleted and the removed records.
+ * @param {SoftDeleteData} data - The soft delete column values of the delete.
+ * @return {Promise<void>} Resolves when the kept files are marked deleted.
+ */
+async function retainDeletedFiles(tx, deleted, data) {
+    const groups = [
+        [true, deleted.soft],
+        [false, deleted.hard]
+    ];
+    for (const [softDeleted, records] of groups) {
+        for (const [modelName, ids] of Object.entries(records)) {
+            const files = (0, core_1.injectModel)(modelName, false)?.config.files;
+            const { kept } = (0, file_util_1.deletedResourceFileFields)(files, softDeleted);
+            if (kept.length === 0 || ids.length === 0) {
+                continue;
+            }
+            await tx.file.updateMany({
+                where: {
+                    resourceName: modelName,
+                    // Owning ids are stored as text, whatever the model primary key is
+                    resourceId: { in: ids.map(String) },
+                    resourceField: { in: kept },
+                    ...(0, model_util_1.liveRecordFilter)('File')
+                },
+                data
+            });
+        }
+    }
+}
+/**
+ * Merges the affected records of several deletes into the target, keeping the ids of every model unique.
+ *
+ * @param {AffectedRecords} target - The affected records merged into.
+ * @param {AffectedRecords[]} sources - The affected records to add.
+ * @return {AffectedRecords} The target holding the ids of every source.
+ */
+function mergeAffectedRecords(target, ...sources) {
+    for (const source of sources) {
+        for (const [modelName, ids] of Object.entries(source)) {
+            const seen = new Set((target[modelName] ?? []).map(String));
+            target[modelName] = [
+                ...(target[modelName] ?? []),
+                ...ids.filter((id) => !seen.has(String(id)))
+            ];
+        }
+    }
+    return target;
+}
+/**
+ * Rejects the relation write actions pointing at soft deleted records, which the database would otherwise connect or
+ * update, since it does not know the record is deleted.
+ *
+ * @param {Object} client - The database client, or the transaction client the write runs in.
+ * @param {string} resourceName - The name of the model the relation actions belong to.
+ * @param {RelationActions} relationActions - The mapped relation write actions.
+ * @return {Promise<void>} Resolves when no action points at a soft deleted record.
+ * @throws {ResourceError} `RESOURCE_INVALID_RELATION` if a connect, update or connect-or-create action matches a soft
+ * deleted record.
+ */
+async function assertLiveRelationTargets(client, resourceName, relationActions) {
+    const relations = (0, core_1.injectModel)(resourceName, false)?.config?.relations ?? {};
+    for (const [key, actions] of Object.entries(relationActions)) {
+        const relatedName = relations[key]?.model;
+        if (!actions || !(0, model_util_1.isSoftDeleteModel)(relatedName)) {
+            continue;
+        }
+        const matches = [
+            ...asList(actions.connect).map((item) => ({ id: item.id })),
+            ...asList(actions.update).map((item) => item.where),
+            ...asList(actions.connectOrCreate).map((item) => item.where)
+        ];
+        if (matches.length === 0) {
+            continue;
+        }
+        const deletedCount = await client[(0, common_1.uncapitalize)(relatedName)].count({
+            where: { AND: [DELETED_RECORD, { OR: matches }] }
+        });
+        if (deletedCount > 0) {
+            throw new common_1.ResourceError(common_1.ErrorCode.ResourceInvalidRelation, `${resourceName} relation '${key}' references a ${(0, common_1.capitalize)(relatedName)} record that does not exist`, { model: resourceName, relation: key });
+        }
+    }
+}
+/** Wraps a single relation action value into a list. */
+function asList(value) {
+    return value === undefined ? [] : (0, common_1.isArray)(value) ? value : [value];
+}
+/**
+ * Rejects a delete while records reference the deleted ones through a restricting relation.
+ */
+async function assertNotReferenced(client, where, relation) {
+    const count = await client.count({ where });
+    if (count > 0) {
+        throw new common_1.ResourceError(common_1.ErrorCode.ResourceDeleteRestricted, `${relation.referencedName} cannot be deleted while ${relation.modelName} records reference it`, { model: relation.referencedName, referencedBy: relation.modelName });
+    }
+}
+/**
+ * Walks the records referencing the given records breadth first. The visitor gets every referencing relation with the
+ * referenced ids and returns the ids of the records the walk continues from.
+ */
+async function walkReferencingRecords(tx, resourceName, ids, visit) {
+    const models = Object.fromEntries(internal_1.context.resource.models);
+    const affected = {};
+    const queue = [
+        { modelName: resourceName, ids }
+    ];
+    while (queue.length > 0) {
+        const level = queue.shift();
+        for (const relation of (0, common_1.referencingRelations)(models, level.modelName)) {
+            const visitedIds = await visit({
+                ...relation,
+                ids: level.ids,
+                referencedName: level.modelName
+            });
+            // A record reached twice, i.e. through a self relation, is walked once
+            const seen = new Set((affected[relation.modelName] ?? []).map(String));
+            if (relation.modelName === resourceName) {
+                ids.forEach((id) => seen.add(String(id)));
+            }
+            const newIds = visitedIds.filter((value) => !seen.has(String(value)));
+            if (newIds.length > 0) {
+                affected[relation.modelName] = [
+                    ...(affected[relation.modelName] ?? []),
+                    ...newIds
+                ];
+                queue.push({ modelName: relation.modelName, ids: newIds });
+            }
+        }
+    }
+    return affected;
+}

package/resource/utils/filter-util.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Maps a request filter to a Prisma `where` clause based on the schema of the
+ * given resource model. The logical operators (`_and`, `_or`, `_not`, `_nor`)
+ * combine their nested conditions with the matching connective, the field
+ * operator objects (`_eq`, `_gt`, `_like`, `_exists`, ...) are translated to
+ * their database conditions, and the list relation quantifiers (`_some`,
+ * `_every`, `_none`) filter the related records. Plain values keep their
+ * shorthand meaning: relation and file fields are matched by id (wrapped in a
+ * `some` condition for the array relations), array fields use the `has` and
+ * `hasSome` operators, an array value on a numeric or date field becomes an
+ * inclusive `gte`/`lte` range, other array values become an `in` inclusion,
+ * nested objects are mapped recursively against the related model, and null
+ * values are passed through to match records without a value or a related
+ * record. Values that match no known field are passed through with only their
+ * operators translated, so the Prisma operators can still be used directly.
+ *
+ * @param {Object} filter The request filter object to map.
+ * @param {string} resourceName The name of the model the filter is matched
+ * against. It is set to the related model name when recursing into a nested
+ * relation or file filter.
+ * @return {Object} The `where` clause with every recognized field mapped to its
+ * database condition and the unrecognized values passed through unchanged.
+ */
+export declare function mapQueryFilter(filter: any, resourceName: string): any;