@appweaver/core 1.0.15 → 1.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appweaver/core",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "Appweaver - the backend framework for AI-first development (@core)",
   "author": "Luka Matosevic",
   "license": "MIT",
@@ -48,7 +48,8 @@
     "date-fns": "4.4.0",
     "fastify": "5.8.5",
     "fastify-plugin": "6.0.0",
-    "flatted": "3.4.2"
+    "flatted": "3.4.2",
+    "sharp": "0.35.3"
   },
   "devDependencies": {
     "@appweaver/common": "^1.0.0",

package/resource/resource-routes.js

@@ -123,6 +123,7 @@ function resourceRoutes(name, routesConfig = {}) {
                 config: deleteConfig
             }, async (request, reply) => {
                 const response = await service.delete(request.params.id);
+                await (0, context_1.inject)(storage_1.FileService).deleteResourceFiles(name, request.params.id);
                 return reply.send(response);
             });
         }

package/storage/file-service.d.ts

@@ -78,4 +78,14 @@ export declare class FileService {
      * an error if no files could be deleted.
      */
     deleteFiles(fileNames: Record<string, string | string[]>, resource: Resource, client: ResourceClient): Promise<File[]>;
+    /**
+     * 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.
+     *
+     * @param {string} resourceName - The resource model name.
+     * @param {number} resourceId - The ID of the deleted resource.
+     * @return {Promise<File[]>} A promise that resolves to the list of successfully deleted files.
+     */
+    deleteResourceFiles(resourceName: string, resourceId: number): Promise<File[]>;
 }

package/storage/file-service.js

@@ -165,7 +165,11 @@ class FileService {
             policy.canCreate?.(identity, resource, createFile) === false) {
             throw new errors_1.HttpError('Creating file is forbidden', 403);
         }
-        const fileName = await this._storage.store(generatedName, data.file);
+        let fileStream = data.file;
+        if (fileConfig.image && (0, utils_1.isProcessableImage)(data.mimetype)) {
+            fileStream = (0, utils_1.processImage)(data.file, data.mimetype, fileConfig.image);
+        }
+        const fileName = await this._storage.store(generatedName, fileStream);
         if (!fileName) {
             throw new errors_1.HttpError('Error saving file to storage', 500);
         }
@@ -327,6 +331,56 @@ class FileService {
         await this._cacheService.invalidateCache(client.name, 'deleteFiles');
         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.
+     *
+     * @param {string} resourceName - The resource model name.
+     * @param {number} resourceId - The ID of the deleted resource.
+     * @return {Promise<File[]>} A promise that resolves to the list of successfully deleted files.
+     */
+    async deleteResourceFiles(resourceName, resourceId) {
+        const resourceModel = (0, context_1.injectModel)(resourceName, false);
+        if (!resourceModel) {
+            return [];
+        }
+        const filesConfig = resourceModel.config.files ?? {};
+        const deleteFields = Object.entries(filesConfig)
+            .filter(([_, config]) => config.onResourceDeleted !== 'keep')
+            .map(([field]) => field);
+        if (deleteFields.length === 0) {
+            return [];
+        }
+        let files;
+        try {
+            files = (await this._db.client().file.findMany({
+                where: {
+                    resourceName,
+                    resourceId,
+                    resourceField: { in: deleteFields }
+                }
+            }));
+        }
+        catch (e) {
+            common_1.logger.error({ resourceName, resourceId, error: e }, 'Error finding resource files for deletion');
+            return [];
+        }
+        const deletedFiles = [];
+        for (const file of files) {
+            const success = await this.deleteSafe(file.name);
+            if (success) {
+                deletedFiles.push(file);
+            }
+            else {
+                common_1.logger.error({ resourceName, resourceId, fileName: file.name }, 'Failed to delete file');
+            }
+        }
+        if (deletedFiles.length > 0) {
+            common_1.logger.debug({ resourceName, resourceId, deletedCount: deletedFiles.length }, 'Resource files deleted');
+        }
+        return deletedFiles;
+    }
     /** @internal */
     buildFileUrl(file, policy) {
         return `${common_1.config.APP_HOSTNAME}/files/${policy.accessType === 'public' ? 'public' : 'protected'}/${file.name}`;

package/utils/image-util.d.ts

@@ -0,0 +1,18 @@
+import { Readable } from 'node:stream';
+import { ImageConfig } from '@appweaver/common';
+/**
+ * Determines if the provided MIME type corresponds to a processable image format.
+ *
+ * @param {string} mimeType - The MIME type of the image to check.
+ * @return {boolean} Returns true if the MIME type is in the list of processable image formats, otherwise false.
+ */
+export declare function isProcessableImage(mimeType: string): boolean;
+/**
+ * Processes an image stream by resizing it and compressing it based on the provided configuration.
+ *
+ * @param {Readable} stream - The readable stream representing the input image.
+ * @param {string} mimeType - The MIME type of the input image (e.g., "image/jpeg", "image/png").
+ * @param {ImageConfig} config - Configuration for image processing, including dimensions, quality, and other options.
+ * @return {Readable} A readable stream of the processed image.
+ */
+export declare function processImage(stream: Readable, mimeType: string, config: ImageConfig): Readable;

package/utils/image-util.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProcessableImage = isProcessableImage;
+exports.processImage = processImage;
+const sharp_1 = __importDefault(require("sharp"));
+const IMAGE_MIME_FORMATS = {
+    'image/jpeg': 'jpeg',
+    'image/png': 'png',
+    'image/webp': 'webp',
+    'image/avif': 'avif',
+    'image/tiff': 'tiff'
+};
+/**
+ * Determines if the provided MIME type corresponds to a processable image format.
+ *
+ * @param {string} mimeType - The MIME type of the image to check.
+ * @return {boolean} Returns true if the MIME type is in the list of processable image formats, otherwise false.
+ */
+function isProcessableImage(mimeType) {
+    return mimeType in IMAGE_MIME_FORMATS;
+}
+/**
+ * Processes an image stream by resizing it and compressing it based on the provided configuration.
+ *
+ * @param {Readable} stream - The readable stream representing the input image.
+ * @param {string} mimeType - The MIME type of the input image (e.g., "image/jpeg", "image/png").
+ * @param {ImageConfig} config - Configuration for image processing, including dimensions, quality, and other options.
+ * @return {Readable} A readable stream of the processed image.
+ */
+function processImage(stream, mimeType, config) {
+    const format = IMAGE_MIME_FORMATS[mimeType];
+    if (!format) {
+        return stream;
+    }
+    let pipeline = (0, sharp_1.default)();
+    const width = config.width ?? config.maxWidth;
+    const height = config.height ?? config.maxHeight;
+    const fit = config.fit ?? 'inside';
+    if (width || height) {
+        pipeline = pipeline.resize({
+            width: width ?? undefined,
+            height: height ?? undefined,
+            fit,
+            withoutEnlargement: !config.width && !config.height
+        });
+    }
+    const opts = config.quality ? { quality: config.quality } : {};
+    pipeline = pipeline.toFormat(format, opts);
+    return stream.pipe(pipeline);
+}

package/utils/index.d.ts

@@ -1,3 +1,4 @@
 export * from './export-util';
 export * from './file-util';
+export * from './image-util';
 export * from './schema-util';

package/utils/index.js

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./export-util"), exports);
 __exportStar(require("./file-util"), exports);
+__exportStar(require("./image-util"), exports);
 __exportStar(require("./schema-util"), exports);