@appweaver/core 1.4.1 → 1.5.1

package/storage/file-service.js

@@ -27,8 +27,9 @@ class FileService {
         this.assertPathNotReserved(fileName);
         let file;
         try {
+            // The files a deleted resource keeps are retained, but no longer served
             file = (await this._db.client().file.findFirst({
-                where: { name: fileName }
+                where: { name: fileName, ...(0, utils_1.liveRecordFilter)('File') }
             }));
         }
         catch (e) {
@@ -253,25 +254,34 @@ class FileService {
         return deletedFiles;
     }
     /**
-     * Deletes all files associated with a resource for file fields configured
-     * with `onResourceDeleted: 'delete'`. Files belonging to fields without this
-     * setting (or set to `'keep'`) are left untouched.
+     * Deletes all files associated with a resource removed from the database,
+     * for the file fields not set to `onResourceDeleted: 'keep'`.
      *
      * @param {string} resourceName - The resource model name.
      * @param {ResourceId} id - The ID of the deleted resource.
      * @return {Promise<File[]>} A promise that resolves to the list of successfully deleted files.
      */
     async deleteResourceFiles(resourceName, id) {
+        return this.deleteResourcesFiles(resourceName, [id]);
+    }
+    /**
+     * Deletes all files associated with the given deleted resources of one model from the storage and the database. A
+     * resource removed from the database loses the files of every field not set to `onResourceDeleted: 'keep'`, while a
+     * soft deleted resource only loses the files of the fields set to `onResourceSoftDeleted: 'delete'`.
+     *
+     * @param {string} resourceName - The resource model name.
+     * @param {ResourceId[]} ids - The IDs of the deleted resources.
+     * @param {boolean} [softDeleted=false] - Whether the resources were soft deleted.
+     * @return {Promise<File[]>} A promise that resolves to the list of successfully deleted files.
+     */
+    async deleteResourcesFiles(resourceName, ids, softDeleted = false) {
         // Owning ids are stored as text, whatever the model primary key type is
-        const resourceId = String(id);
+        const resourceIds = ids.map(String);
         const resourceModel = (0, context_1.injectModel)(resourceName, false);
-        if (!resourceModel) {
+        if (!resourceModel || resourceIds.length === 0) {
             return [];
         }
-        const filesConfig = resourceModel.config.files ?? {};
-        const deleteFields = Object.entries(filesConfig)
-            .filter(([_, config]) => config.onResourceDeleted !== 'keep')
-            .map(([field]) => field);
+        const { deleted: deleteFields } = (0, utils_1.deletedResourceFileFields)(resourceModel.config.files, softDeleted);
         if (deleteFields.length === 0) {
             return [];
         }
@@ -280,13 +290,13 @@ class FileService {
             files = (await this._db.client().file.findMany({
                 where: {
                     resourceName,
-                    resourceId,
+                    resourceId: { in: resourceIds },
                     resourceField: { in: deleteFields }
                 }
             }));
         }
         catch (e) {
-            common_1.logger.error({ resourceName, resourceId, error: e }, 'Error finding resource files for deletion');
+            common_1.logger.error({ resourceName, resourceIds, error: e }, 'Error finding resource files for deletion');
             return [];
         }
         const deletedFiles = [];
@@ -296,11 +306,11 @@ class FileService {
                 deletedFiles.push(file);
             }
             else {
-                common_1.logger.error({ resourceName, resourceId, fileName: file.name }, 'Failed to delete file');
+                common_1.logger.error({ resourceName, resourceId: file.resourceId, fileName: file.name }, 'Failed to delete file');
             }
         }
         if (deletedFiles.length > 0) {
-            common_1.logger.debug({ resourceName, resourceId, deletedCount: deletedFiles.length }, 'Resource files deleted');
+            common_1.logger.debug({ resourceName, resourceIds, deletedCount: deletedFiles.length }, 'Resource files deleted');
         }
         return deletedFiles;
     }

package/storage/resources/file/model.js

@@ -4,6 +4,9 @@ const factory_1 = require("../../../factory");
 const utils_1 = require("../../../utils");
 exports.default = (0, factory_1.createModel)({
     name: 'File',
+    // The files a deleted resource keeps are retained for audit, but no longer
+    // served, by marking their rows deleted together with the resource
+    softDelete: true,
     scalars: {
         name: {
             type: 'string',
@@ -72,5 +75,6 @@ exports.default = (0, factory_1.createModel)({
             }
         }
     },
-    index: [['resourceField', 'resourceName', 'resourceId']]
+    // Leads with the exact match columns, so the prefix also serves lookups
+    index: [['resourceName', 'resourceId', 'resourceField']]
 });

package/types/generated.d.ts

@@ -290,6 +290,7 @@ export type File = {
     updatedAt: Date;
     createdAt: Date;
     createdById?: number | null;
+    deletedAt?: Date | null;
 };
 export type FileSingle = {
     id: number;

package/utils/file-util.d.ts

@@ -9,6 +9,20 @@ import { File } from '../types';
  * @return {string} The absolute URL for accessing the file.
  */
 export declare function buildFileUrl(file: File): string;
+/**
+ * Splits the file fields of a deleted resource by what happens to their files. On a delete removing the resource from
+ * the database each field follows its `onResourceDeleted` option, which defaults to `'delete'`, while on a soft delete
+ * it follows its `onResourceSoftDeleted` option, which defaults to `'keep'`.
+ *
+ * @param {FilesConfig} [files] - The file fields of the deleted resource's model.
+ * @param {boolean} softDeleted - Whether the resource was soft deleted.
+ * @return {{deleted: string[], kept: string[]}} The fields whose files are removed from storage, and the fields whose
+ * files are retained, but no longer served.
+ */
+export declare function deletedResourceFileFields(files: FilesConfig | undefined, softDeleted: boolean): {
+    deleted: string[];
+    kept: string[];
+};
 /**
  * Parses a range string and converts it into an object with start and end values.
  *

package/utils/file-util.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildFileUrl = buildFileUrl;
+exports.deletedResourceFileFields = deletedResourceFileFields;
 exports.parseRange = parseRange;
 exports.maxFileSize = maxFileSize;
 exports.sizeInBytes = sizeInBytes;
@@ -26,6 +27,26 @@ function buildFileUrl(file) {
     const routePrefix = `/${common_1.config.STORAGE_FILES_ROUTE_PREFIX}/`.replace(/\/+/g, '/');
     return `${common_1.config.APP_HOSTNAME}${routePrefix}${pathPrefix}/${file.name}`;
 }
+/**
+ * Splits the file fields of a deleted resource by what happens to their files. On a delete removing the resource from
+ * the database each field follows its `onResourceDeleted` option, which defaults to `'delete'`, while on a soft delete
+ * it follows its `onResourceSoftDeleted` option, which defaults to `'keep'`.
+ *
+ * @param {FilesConfig} [files] - The file fields of the deleted resource's model.
+ * @param {boolean} softDeleted - Whether the resource was soft deleted.
+ * @return {{deleted: string[], kept: string[]}} The fields whose files are removed from storage, and the fields whose
+ * files are retained, but no longer served.
+ */
+function deletedResourceFileFields(files = {}, softDeleted) {
+    const fields = { deleted: [], kept: [] };
+    for (const [field, fileField] of Object.entries(files)) {
+        const action = softDeleted
+            ? (fileField.onResourceSoftDeleted ?? 'keep')
+            : (fileField.onResourceDeleted ?? 'delete');
+        fields[action === 'delete' ? 'deleted' : 'kept'].push(field);
+    }
+    return fields;
+}
 /**
  * Parses a range string and converts it into an object with start and end values.
  *

package/utils/model-util.d.ts

@@ -1,4 +1,28 @@
 import { ResourceModel } from '@appweaver/common';
+/**
+ * Checks whether the model with the given name soft deletes its records.
+ *
+ * @param {string} [resourceName] - The name of the model to check.
+ * @return {boolean} True if the model is loaded and has `softDelete` enabled.
+ */
+export declare function isSoftDeleteModel(resourceName?: string): boolean;
+/**
+ * Builds the condition matching only the records of a model that are not soft
+ * deleted, for the queries reading its records outside the resource service.
+ *
+ * @param {string} resourceName - The name of the model the condition is built for.
+ * @return {Object} The `deletedAt: null` condition for a soft deleted model, or
+ * an empty object otherwise.
+ */
+export declare function liveRecordFilter(resourceName: string): Record<string, any>;
+/**
+ * Validates that every relation cascading on delete from a model with
+ * `softDelete` enabled belongs to a model that soft deletes its records too.
+ *
+ * @param {Record<string, ResourceModel>} models - All loaded models keyed by name.
+ * @throws {Error} When a soft deleted model cascades into a model without soft delete.
+ */
+export declare function validateSoftDeleteCascades(models: Record<string, ResourceModel>): void;
 /**
  * Validates that the default value of every scalar and virtual field satisfies
  * the constraints declared on that same field. A default outside its own

package/utils/model-util.js

@@ -1,7 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSoftDeleteModel = isSoftDeleteModel;
+exports.liveRecordFilter = liveRecordFilter;
+exports.validateSoftDeleteCascades = validateSoftDeleteCascades;
 exports.validateScalarDefaults = validateScalarDefaults;
 const common_1 = require("@appweaver/common");
+const context_1 = require("../context");
+/**
+ * Checks whether the model with the given name soft deletes its records.
+ *
+ * @param {string} [resourceName] - The name of the model to check.
+ * @return {boolean} True if the model is loaded and has `softDelete` enabled.
+ */
+function isSoftDeleteModel(resourceName) {
+    if (!resourceName) {
+        return false;
+    }
+    const model = (0, context_1.injectModel)((0, common_1.capitalize)(resourceName), false);
+    return (0, common_1.hasSoftDelete)(model?.config);
+}
+/**
+ * Builds the condition matching only the records of a model that are not soft
+ * deleted, for the queries reading its records outside the resource service.
+ *
+ * @param {string} resourceName - The name of the model the condition is built for.
+ * @return {Object} The `deletedAt: null` condition for a soft deleted model, or
+ * an empty object otherwise.
+ */
+function liveRecordFilter(resourceName) {
+    return isSoftDeleteModel(resourceName) ? { deletedAt: null } : {};
+}
+/**
+ * Validates that every relation cascading on delete from a model with
+ * `softDelete` enabled belongs to a model that soft deletes its records too.
+ *
+ * @param {Record<string, ResourceModel>} models - All loaded models keyed by name.
+ * @throws {Error} When a soft deleted model cascades into a model without soft delete.
+ */
+function validateSoftDeleteCascades(models) {
+    const errors = (0, common_1.softDeleteCascadeErrors)(models);
+    if (errors.length > 0) {
+        throw new Error(`Invalid resource model soft delete cascades:\n${errors
+            .map((error) => `  - ${error}`)
+            .join('\n')}`);
+    }
+}
 /**
  * Validates that the default value of every scalar and virtual field satisfies
  * the constraints declared on that same field. A default outside its own