@appweaver/core 1.4.0 → 1.5.0

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 context_1 = require("../../context");
+const security_1 = require("../../security");
+const errors_1 = require("../../errors");
+const utils_1 = require("../../utils");
+/** 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, utils_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, utils_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, context_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, utils_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, security_1.resourceAuthModel)()) {
+        data.deletedById = (0, security_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 {HttpError} 409 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, utils_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, utils_1.isSoftDeleteModel)(relation.modelName)) {
+            throw new errors_1.HttpError(`${relation.modelName} must enable soft delete to cascade from ${relation.referencedName}`, 500);
+        }
+        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 {HttpError} 409 if a live record references a soft deleted orphan through a restricting relation.
+ */
+async function removeOrphans(tx, resourceName, relationActions, data) {
+    const relations = (0, context_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, utils_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, context_1.injectModel)(modelName, false)?.config.files;
+            const { kept } = (0, utils_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, utils_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 {HttpError} 400 if a connect, update or connect-or-create action matches a soft deleted record.
+ */
+async function assertLiveRelationTargets(client, resourceName, relationActions) {
+    const relations = (0, context_1.injectModel)(resourceName, false)?.config?.relations ?? {};
+    for (const [key, actions] of Object.entries(relationActions)) {
+        const relatedName = relations[key]?.model;
+        if (!actions || !(0, utils_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 errors_1.HttpError(`${resourceName} relation '${key}' references a ${(0, common_1.capitalize)(relatedName)} record that does not exist`, 400);
+        }
+    }
+}
+/** Wraps a single relation action value into a list. @internal */
+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.
+ *
+ * @internal
+ */
+async function assertNotReferenced(client, where, relation) {
+    const count = await client.count({ where });
+    if (count > 0) {
+        throw new errors_1.HttpError(`${relation.referencedName} cannot be deleted while ${relation.modelName} records reference it`, 409);
+    }
+}
+/**
+ * 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.
+ *
+ * @internal
+ */
+async function walkReferencingRecords(tx, resourceName, ids, visit) {
+    const models = Object.fromEntries(context_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.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapQueryFilter = mapQueryFilter;
 const common_1 = require("@appweaver/common");
 const context_1 = require("../../context");
+const delete_util_1 = require("./delete-util");
 /**
  * Logical filter operators mapped to their database query connectives. Both
  * `_not` and `_nor` negate the conjunction of their conditions.
@@ -121,10 +122,15 @@ function mapQueryFilter(filter, resourceName) {
             relationSchema?.type === 'array' ||
             fileSchema?.type === 'array';
         const isArrayValue = (0, common_1.isArray)(value);
-        // Null values are passed through untouched, matching records without a
-        // value or, for relations, without a related record.
+        // A soft deleted related record is matched as if it did not exist
+        const relationName = (0, common_1.extractResourceName)(relationSchema);
+        const liveRelation = (condition) => relationName
+            ? (0, delete_util_1.liveRelationFilter)(condition, relationName, isArrayType)
+            : condition;
+        // Null values match records without a value or, for relations, without a
+        // related record, a soft deleted one included
         if (value === null) {
-            queryFilter[key] = null;
+            queryFilter[key] = liveRelation(null);
             continue;
         }
         // Recursively map nested objects and handle arrays of objects. Arrays of
@@ -134,7 +140,7 @@ function mapQueryFilter(filter, resourceName) {
             if (relatedName) {
                 queryFilter[key] = isArrayValue
                     ? value.map((item) => mapQueryFilter(item, relatedName))
-                    : mapRelationFilter(value, relatedName, isArrayType);
+                    : liveRelation(mapRelationFilter(value, relatedName, isArrayType));
             }
             else {
                 // Objects that match no relation have their field operators
@@ -145,7 +151,7 @@ function mapQueryFilter(filter, resourceName) {
         // Map ID values for both single and array types of relationships
         else if (relationSchema || fileSchema) {
             const queryId = { id: isArrayValue ? { in: value } : value };
-            queryFilter[key] = isArrayType ? { some: queryId } : queryId;
+            queryFilter[key] = liveRelation(isArrayType ? { some: queryId } : queryId);
         }
         // Map fields without relationships, supporting array types
         else if (readSchema) {

package/resource/utils/index.d.ts

@@ -3,3 +3,4 @@ export * from './cursor-util';
 export * from './filter-util';
 export * from './relation-util';
 export * from './sort-util';
+export * from './delete-util';

package/resource/utils/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./cursor-util"), exports);
 __exportStar(require("./filter-util"), exports);
 __exportStar(require("./relation-util"), exports);
 __exportStar(require("./sort-util"), exports);
+__exportStar(require("./delete-util"), exports);

package/resource/utils/relation-util.js

@@ -9,6 +9,10 @@ const common_1 = require("@appweaver/common");
 const context_1 = require("../../context");
 const security_1 = require("../../security");
 const errors_1 = require("../../errors");
+const delete_util_1 = require("./delete-util");
+/** Levels of a self referencing relation read when the relation configures no
+ * `maxDepth`, i.e. the relation itself and nothing below it. */
+const DEFAULT_RELATION_MAX_DEPTH = 1;
 /**
  * Builds the Prisma `include` clause for the relation and file fields of a resource model. A field is included when
  * its configured output type allows it for the given action, or always when no action is specified, and the relations
@@ -37,11 +41,13 @@ function mapRelationInclusions(resourceName, action) {
         const relationField = relationConfig?.[key] || fileConfig?.[key];
         if (relationField?.output?.count) {
             inclusion._count = inclusion._count ?? { select: {} };
-            inclusion._count.select[key] = true;
+            // Soft deleted related records are not counted
+            inclusion._count.select[key] =
+                (0, delete_util_1.liveInclusionFilter)(relationField.model) ?? true;
         }
         // Check if the relation should be included based on the output type
         if (shouldIncludeRelation(relationField?.output?.type, action)) {
-            inclusion[key] = buildNestedInclusion(relationField, action);
+            inclusion[key] = buildNestedInclusion(relationField, key, action);
         }
     }
     return inclusion;
@@ -294,33 +300,76 @@ function createdByConnect(resourceName) {
         : undefined;
 }
 /**
- * Resolves the inclusion value of a single relation field by walking its configured nested output includes
- * recursively. Returns `true` when the relation has no nested includes to apply for the given action, or a nested
- * `include` clause otherwise.
+ * Resolves the inclusion value of a single relation field, walking both the levels a self referencing relation
+ * repeats itself for and the nested includes it configures. Returns `true` when the relation reads no further than
+ * itself for the given action, or a nested `include` clause otherwise.
+ *
+ * A relation whose related model holds the same relation again points back at its own model, so it repeats itself
+ * down the tree up to its configured `output.maxDepth`, letting a category carry its ancestors without every level
+ * being spelled out. An `output.include` entry naming that same relation configures the level itself and replaces
+ * the repetition.
  *
  * @param {RelationField} relationField - The configuration of the relation whose inclusion value is resolved, read
- * from its `output.include` property.
+ * from its `output.include` and `output.maxDepth` properties.
+ * @param {string} key - The field name the relation is declared under, matched against the related model to detect a
+ * relation pointing back at its own model.
  * @param {ActionType} [action] - The action the inclusions are built for, matched against the configured output type
  * of every nested relation.
- * @return {boolean|Object} True if the relation has no nested relations to include for the given action, or the
- * nested `include` clause otherwise.
+ * @param {number} [depth=1] - The level of the relation being resolved, counting the relation itself as the first.
+ * @return {boolean|Object} True if the relation reads no further than itself, or its nested `include` clause, and
+ * for a list relation of a soft deleted model, the `where` clause skipping the deleted records.
  */
-function buildNestedInclusion(relationField, action) {
+function buildNestedInclusion(relationField, key, action, depth = 1) {
     const nestedIncludeConfig = relationField?.output?.include;
-    if (!nestedIncludeConfig || Object.keys(nestedIncludeConfig).length === 0) {
-        return true;
-    }
     const nestedInclusion = {};
-    for (const [nestedKey, nestedOutput] of Object.entries(nestedIncludeConfig)) {
+    // A file field carries no related model, so it reads no further than itself
+    const relatedModel = relationField?.model
+        ? (0, context_1.injectModel)((0, common_1.capitalize)(relationField.model), false)
+        : undefined;
+    const selfRelation = selfReferencingRelation(relatedModel, key);
+    const maxDepth = relationField?.output?.maxDepth ?? DEFAULT_RELATION_MAX_DEPTH;
+    if (selfRelation && depth < maxDepth && !nestedIncludeConfig?.[key]) {
+        nestedInclusion[key] = buildNestedInclusion({ ...selfRelation, output: relationField.output }, key, action, depth + 1);
+    }
+    for (const [nestedKey, nestedOutput] of Object.entries(nestedIncludeConfig ?? {})) {
         // Check if the nested relation should be included
-        if (shouldIncludeRelation(nestedOutput?.type, action)) {
-            // Recursively build nested inclusions
-            nestedInclusion[nestedKey] = buildNestedInclusion({ output: nestedOutput }, action);
+        if (!shouldIncludeRelation(nestedOutput?.type, action)) {
+            continue;
         }
+        // The related model carries the field the nested include names, so each
+        // level is resolved against the model it actually belongs to
+        const nestedRelation = relatedModel?.config?.relations?.[nestedKey] ??
+            relatedModel?.config?.files?.[nestedKey];
+        nestedInclusion[nestedKey] = buildNestedInclusion({ ...nestedRelation, output: nestedOutput }, nestedKey, action);
+    }
+    // A list relation reads only the related records that are not soft deleted,
+    // while a single relation is cleared of them after it is read
+    const liveFilter = relatedModel && (0, common_1.isRelationArray)(relationField)
+        ? (0, delete_util_1.liveInclusionFilter)(relatedModel.name)
+        : undefined;
+    const hasNested = Object.keys(nestedInclusion).length > 0;
+    if (!hasNested && !liveFilter) {
+        return true;
     }
-    return Object.keys(nestedInclusion).length > 0
-        ? { include: nestedInclusion }
-        : true;
+    return {
+        ...(liveFilter ?? {}),
+        ...(hasNested ? { include: nestedInclusion } : {})
+    };
+}
+/**
+ * Reads the relation a related model holds under the given field name, when it points back at that same model. It is
+ * the relation a self referencing field repeats itself through, i.e. the `parent` of the parent of a category.
+ *
+ * @param {ResourceModel} [model] - The related model the field is looked up on.
+ * @param {string} key - The field name of the relation.
+ * @return {RelationField | undefined} The relation of the model under that name when it references the model itself,
+ * undefined otherwise.
+ */
+function selfReferencingRelation(model, key) {
+    const relation = key ? model?.config?.relations?.[key] : undefined;
+    return relation && (0, common_1.capitalize)(relation.model) === model?.name
+        ? relation
+        : undefined;
 }
 /**
  * Decides whether a relation with the given configured output type is included for the given action. The `none` type

package/security/api-key/api-key-auth.js

@@ -9,6 +9,7 @@ const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
 const request_context_1 = require("@fastify/request-context");
 const common_1 = require("@appweaver/common");
 const context_1 = require("../../context");
+const utils_1 = require("../../utils");
 const helper_1 = require("../helper");
 const auth_service_1 = require("../auth-service");
 const errors_1 = require("../../errors");
@@ -38,9 +39,9 @@ exports.apiKeyAuth = (0, fastify_plugin_1.default)(async (server) => {
         if (!apiKey) {
             try {
                 // The generated client types the id after the configured primary key
-                apiKey = await db
-                    .client()
-                    .apiKey.findFirst({ where: { id: apiKeyId } });
+                apiKey = await db.client().apiKey.findFirst({
+                    where: { id: apiKeyId, ...(0, utils_1.liveRecordFilter)('ApiKey') }
+                });
             }
             catch (e) {
                 throw new errors_1.HttpError(`Invalid API key format`, 401);

package/security/oauth2/oauth2-service.js

@@ -112,11 +112,16 @@ class OAuth2Service {
         if (account && this.connectedAccountOwnerId(account) !== authUser.id) {
             throw new errors_1.HttpError('This provider account is already linked to another user', 403);
         }
-        try {
-            if (account) {
+        if (account) {
+            try {
                 await service.update(account.id, { scope, lastLoginAt: new Date() });
-                return;
             }
+            catch (e) {
+                throw new errors_1.HttpError('Connected account link error', 500, e);
+            }
+            return;
+        }
+        try {
             await service.create({
                 provider: source,
                 providerAccountId,
@@ -124,11 +129,20 @@ class OAuth2Service {
                 lastLoginAt: new Date(),
                 [(0, common_1.uncapitalize)(this._authUserService.modelName)]: { id: authUser.id }
             });
-            common_1.logger.debug({ id: authUser.id, source }, 'OAuth2 provider account linked');
         }
         catch (e) {
-            throw new errors_1.HttpError('Connected account link error', 500, e);
+            // A concurrent sign-in may have created the link first, which the unique
+            // constraint on the provider account rejects this one for
+            const linked = await this.findConnectedAccount(source, providerAccountId).catch(() => null);
+            if (!linked) {
+                throw new errors_1.HttpError('Connected account link error', 500, e);
+            }
+            if (this.connectedAccountOwnerId(linked) !== authUser.id) {
+                throw new errors_1.HttpError('This provider account is already linked to another user', 403);
+            }
+            return;
         }
+        common_1.logger.debug({ id: authUser.id, source }, 'OAuth2 provider account linked');
     }
     /**
      * Reads the owning user id off a link, which the generated model exposes as a `<authModel>Id` foreign key.

package/security/resources/api-key/model.js

@@ -9,6 +9,8 @@ const shouldCreateModel = common_1.config.SECURITY_API_KEY_ENABLED ||
 exports.default = shouldCreateModel
     ? (0, factory_1.createModel)({
         name: 'ApiKey',
+        // Cascades from the auth model, so it is soft deleted together with it
+        softDelete: !!authModel?.config.softDelete,
         scalars: {
             key: {
                 type: 'string'

package/security/resources/connected-account/model.js

@@ -9,6 +9,8 @@ const shouldCreateModel = (0, helper_1.isOAuth2Enabled)() ||
 exports.default = shouldCreateModel
     ? (0, factory_1.createModel)({
         name: 'ConnectedAccount',
+        // Cascades from the auth model, so it is soft deleted together with it
+        softDelete: !!authModel?.config.softDelete,
         audit: {
             createdById: false
         },
@@ -50,6 +52,6 @@ exports.default = shouldCreateModel
             }
             : {}),
         // A provider account may only ever be linked to a single user
-        index: [['provider', 'providerAccountId']]
+        unique: [['provider', 'providerAccountId']]
     })
     : undefined;