@appweaver/data 0.0.0-stage → 2.0.0

package/storage/file-service.js

@@ -0,0 +1,586 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileService = void 0;
+const node_stream_1 = require("node:stream");
+const common_1 = require("@appweaver/common");
+const core_1 = require("@appweaver/core");
+const database_error_1 = require("../database/database-error");
+const policy_util_1 = require("../utils/policy-util");
+const file_util_1 = require("../utils/file-util");
+const model_util_1 = require("../utils/model-util");
+const internal_1 = require("@appweaver/core/internal");
+class FileService {
+    /** @internal */
+    _db = (0, core_1.inject)(common_1.Database);
+    /** @internal */
+    _storage = (0, core_1.inject)(common_1.Storage);
+    /** @internal */
+    _cacheService = (0, core_1.inject)(core_1.CacheService);
+    /** @internal */
+    _imageProcessor = (0, core_1.inject)(common_1.ImageProcessor, false);
+    /**
+     * Searches for a file by its name from a database.
+     *
+     * @param {string} fileName - The name of the file to search for.
+     * @return {Promise<File>} A promise that resolves to the file object if found.
+     * @throws {FileError} Throws an error if the file name is placed under a reserved storage path, if a database error
+     * occurs, or if the file is not found.
+     */
+    async findByName(fileName) {
+        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, ...(0, model_util_1.liveRecordFilter)('File') }
+            }));
+        }
+        catch (e) {
+            throw (0, database_error_1.toDatabaseError)(e, 'File');
+        }
+        if (!file) {
+            throw new common_1.FileError(common_1.ErrorCode.FileNotFound, 'File does not exist', {
+                fileName
+            });
+        }
+        return file;
+    }
+    /**
+     * Streams a file from storage, handling authorization and range-based requests.
+     *
+     * @param {string} fileName - The name of the file to stream.
+     * @param {string} [range] - An optional range header specifying the byte range to stream.
+     * @return {Promise<FileStream>} A promise that resolves to a file stream object containing the content, metadata, and
+     * range details.
+     * @throws {FileError} `FILE_NOT_FOUND` if the file does not exist.
+     * @throws {FileError} `FILE_FORBIDDEN` if user access to the file is forbidden.
+     * @throws {FileError} `FILE_STORAGE_ERROR` if an error occurs while reading the file from storage.
+     */
+    async stream(fileName, range) {
+        const file = await this.authorizeRead(fileName);
+        const parsedRange = (0, file_util_1.parseRange)(range);
+        const start = parsedRange.start;
+        let end = parsedRange.end;
+        const fileStream = await this._storage.stream(fileName, start, end);
+        if (!fileStream) {
+            throw new common_1.FileError(common_1.ErrorCode.FileStorageError, 'Error reading file from storage');
+        }
+        if (end === undefined || end >= fileStream.size || end >= file.sizeBytes) {
+            end = (fileStream.size ?? file.sizeBytes) - 1;
+        }
+        return {
+            content: fileStream,
+            fileName: file.name.split('/')[0],
+            mimeType: file.mimeType,
+            start,
+            end
+        };
+    }
+    /**
+     * Opens a file for a download, handling authorization like {@link stream}: the URL of its storage when the storage
+     * serves its files directly, otherwise the stream of the file.
+     *
+     * @param {string} fileName - The name of the file to download.
+     * @param {string} [range] - An optional range header specifying the byte range to stream.
+     * @return {Promise<FileStream | FileRedirect>} The URL of the file, or its stream.
+     * @throws {FileError} The errors of {@link stream}.
+     */
+    async download(fileName, range) {
+        const file = await this.authorizeRead(fileName);
+        const url = await this._storage.url(fileName, {
+            expiresIn: core_1.storageConfig.URL_TTL
+        });
+        if (url) {
+            return {
+                url,
+                fileName: file.name.split('/')[0],
+                mimeType: file.mimeType
+            };
+        }
+        return this.stream(fileName, range);
+    }
+    /**
+     * Saves a file to storage, validates its properties, and associates it with a specific resource and client.
+     *
+     * @param {UploadedFile} data The multipart file object containing the file data, field name, filename, and metadata.
+     * @param {Resource} resource The resource object with which the file is being associated.
+     * @param {ResourceClient} client The database client responsible for handling the resource.
+     * @return {Promise<File>} A promise that resolves to the saved file object or rejects with an error if the operation
+     * fails.
+     * @throws {FileError} Throws an error if file validation, storage, or resource association fails.
+     */
+    async saveFile(data, resource, client) {
+        return this.saveContent({
+            fieldName: data.fieldname,
+            fileName: data.filename,
+            mimeType: data.mimetype,
+            encoding: data.encoding,
+            stream: data.file,
+            bytesRead: () => data.file.bytesRead,
+            truncated: () => data.file.truncated
+        }, resource, client);
+    }
+    /**
+     * Saves an in-memory file to storage and associates it with a file field of a specific resource. Behaves exactly like
+     * {@link saveFile}, except the content is taken from a buffer instead of a multipart upload, which makes it usable
+     * outside a file upload request, for an avatar downloaded from an OAuth2 provider or an image the application
+     * generates itself.
+     *
+     * @param {string} fieldName The file field of the resource the file is saved to.
+     * @param {FileBuffer} file The file content, along with its original name and media type.
+     * @param {Resource} resource The resource object with which the file is being associated.
+     * @param {ResourceClient} client The database client responsible for handling the resource.
+     * @return {Promise<File>} A promise that resolves to the saved file object or rejects with an error if the operation
+     * fails.
+     * @throws {FileError} Throws an error if file validation, storage, or resource association fails.
+     */
+    async saveBuffer(fieldName, file, resource, client) {
+        const size = file.size ?? file.data.length;
+        return this.saveContent({
+            fieldName,
+            fileName: file.name,
+            mimeType: file.mimeType,
+            encoding: file.encoding ?? '7bit',
+            stream: node_stream_1.Readable.from(file.data),
+            bytesRead: () => size,
+            truncated: () => false
+        }, resource, client);
+    }
+    /**
+     * Saves files received as an asynchronous iterable of multipart data.
+     *
+     * @param {AsyncIterableIterator<UploadPart>} parts - The asynchronous iterable providing multipart data where each
+     * part is expected to represent a file or other data.
+     * @param {Resource} resource - The resource associated with the files being saved, providing additional contextual
+     * information.
+     * @param {ResourceClient} client - The database client responsible for handling resource-related operations, such as
+     * database interaction.
+     * @return {Promise<File[]>} A promise that resolves to an array of successfully saved files. Rejects with an error
+     * if one or more files fail to save.
+     */
+    async saveFiles(parts, resource, client) {
+        const saveActions = [];
+        for await (const part of parts) {
+            if (part.type === 'file') {
+                saveActions.push(this.saveFile(part, resource, client));
+            }
+        }
+        const saveResults = await Promise.allSettled(saveActions);
+        const savedFiles = saveResults
+            .filter((r) => r.status === 'fulfilled')
+            .map((r) => r.value);
+        const errors = saveResults
+            .filter((r) => r.status === 'rejected')
+            .map((r) => r.reason);
+        if (errors.length > 0) {
+            // Delete all successfully saved files in storage and rows in a database.
+            const deleteActions = savedFiles.map((f) => this.deleteSafe(f.name));
+            await Promise.all(deleteActions);
+            const errorMessage = errors.join('\n');
+            throw new common_1.FileError(common_1.ErrorCode.FileUploadFailed, `Error while saving files: ${errorMessage}`, { errors });
+        }
+        await this._cacheService.invalidateCache(client.name, 'uploadFiles');
+        return savedFiles;
+    }
+    /**
+     * Deletes a file from the storage and database if it meets the specified conditions.
+     *
+     * @param {string} fileName - The name of the file to be deleted.
+     * @param {string} fieldName - The field associated with the resource to which the file belongs.
+     * @param {Resource} resource - The resource that the file is associated with.
+     * @param {ResourceClient} client - The client instance representing the resource's type.
+     * @return {Promise<File>} A promise that resolves with the deleted file information upon successful deletion.
+     * @throws {FileError} If the file is not associated with the provided resource or client,
+     *                     if the current user does not have permission to delete the file,
+     *                     if there is an error removing the file from storage,
+     *                     or if there is an error deleting the file from the database.
+     */
+    async deleteFile(fileName, fieldName, resource, client) {
+        const currentUser = (0, core_1.currentAuthUser)();
+        const file = await this.findByName(fileName);
+        if (file.resourceId !== String(resource.id) ||
+            file.resourceName !== client.name ||
+            file.resourceField !== fieldName) {
+            throw new common_1.FileError(common_1.ErrorCode.FileForbidden, `File does not belong to a '${client.name}' resource`, { fileName, action: 'delete' });
+        }
+        const policy = this.getFilePolicy(file.resourceName, file.resourceField);
+        if (!(0, policy_util_1.arePoliciesSkipped)() &&
+            (await policy.canDelete?.(currentUser ?? null, resource, file)) === false) {
+            throw new common_1.FileError(common_1.ErrorCode.FileForbidden, 'Deleting file is forbidden', { fileName, action: 'delete' });
+        }
+        const result = await this.deleteStored(fileName);
+        if (!result) {
+            throw new common_1.FileError(common_1.ErrorCode.FileStorageError, 'Error deleting file from storage');
+        }
+        try {
+            const deletedFile = (await this._db.client().file.delete({
+                where: { name: fileName }
+            }));
+            deletedFile.url = (0, file_util_1.buildFileUrl)(deletedFile);
+            common_1.logger.debug({ deletedFile }, 'File deleted');
+            return deletedFile;
+        }
+        catch (e) {
+            throw (0, database_error_1.toDatabaseError)(e, 'File');
+        }
+    }
+    /**
+     * Deletes a list of files associated with a given resource using the provided resource client.
+     *
+     * @param {Record<string, string | string[]>} fileNames - An object where the keys correspond to file fields and the
+     * values are either a string (single file name) or an array of file names to be deleted.
+     * @param {Resource} resource - The resource instance associated with the files to be deleted.
+     * @param {ResourceClient} client - The resource a client used to handle deletion operations.
+     * @return {Promise<File[]>} A promise that resolves to an array of files that were successfully deleted. Rejects with
+     * an error if no files could be deleted.
+     */
+    async deleteFiles(fileNames, resource, client) {
+        if (Object.keys(fileNames ?? {}).length === 0) {
+            throw new common_1.FileError(common_1.ErrorCode.FileNoneProvided, 'No files for deletion are provided');
+        }
+        const deleteActions = [];
+        for (const [field, value] of Object.entries(fileNames)) {
+            const names = typeof value === 'string' ? [value] : value;
+            for (const name of names) {
+                deleteActions.push(this.deleteFile(name, field, resource, client));
+            }
+        }
+        const deleteResults = await Promise.allSettled(deleteActions);
+        const deletedFiles = deleteResults
+            .filter((r) => r.status === 'fulfilled')
+            .map((r) => r.value);
+        const errors = deleteResults
+            .filter((r) => r.status === 'rejected')
+            .map((r) => r.reason);
+        if (errors.length > 0 && deletedFiles.length === 0) {
+            const errorMessage = errors.join('\n');
+            throw new common_1.FileError(common_1.ErrorCode.FileDeleteFailed, `Error while deleting files: ${errorMessage}`, { errors });
+        }
+        await this._cacheService.invalidateCache(client.name, 'deleteFiles');
+        return deletedFiles;
+    }
+    /**
+     * 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 resourceIds = ids.map(String);
+        const resourceModel = (0, core_1.injectModel)(resourceName, false);
+        if (!resourceModel || resourceIds.length === 0) {
+            return [];
+        }
+        const { deleted: deleteFields } = (0, file_util_1.deletedResourceFileFields)(resourceModel.config.files, softDeleted);
+        if (deleteFields.length === 0) {
+            return [];
+        }
+        let files;
+        try {
+            files = (await this._db.client().file.findMany({
+                where: {
+                    resourceName,
+                    resourceId: { in: resourceIds },
+                    resourceField: { in: deleteFields }
+                }
+            }));
+        }
+        catch (e) {
+            common_1.logger.error({ resourceName, resourceIds, 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: file.resourceId, fileName: file.name }, 'Failed to delete file');
+            }
+        }
+        if (deletedFiles.length > 0) {
+            common_1.logger.debug({ resourceName, resourceIds, deletedCount: deletedFiles.length }, 'Resource files deleted');
+        }
+        return deletedFiles;
+    }
+    /**
+     * Finds a file, checking that the current user may read it.
+     *
+     * @internal
+     */
+    async authorizeRead(fileName) {
+        const identity = (0, core_1.currentAuthUser)();
+        const file = await this.findByName(fileName);
+        if (!file) {
+            throw new common_1.FileError(common_1.ErrorCode.FileNotFound, 'File does not exist', {
+                fileName
+            });
+        }
+        const policy = this.getFilePolicy(file.resourceName, file.resourceField);
+        if (!identity && policy.accessType !== 'public') {
+            throw new common_1.FileError(common_1.ErrorCode.FileForbidden, 'Public file access is forbidden', { fileName, action: 'read' });
+        }
+        if (policy.accessType === 'private' && identity?.id !== file.createdById) {
+            throw new common_1.FileError(common_1.ErrorCode.FileForbidden, 'Private file access is forbidden', { fileName, action: 'read' });
+        }
+        if (policy.accessType == 'protected' &&
+            file.resourceName &&
+            file.resourceId) {
+            const resourceService = (0, core_1.injectService)(file.resourceName);
+            // The owning id is stored as text, so it is converted back to the
+            // primary key type of that model before the lookup
+            const resource = await resourceService.find((0, common_1.toResourceId)(file.resourceId, (0, core_1.injectModel)(file.resourceName, false)?.config?.id));
+            if (!(0, policy_util_1.arePoliciesSkipped)() &&
+                (await policy.canAccess?.(identity ?? null, resource, file)) === false) {
+                throw new common_1.FileError(common_1.ErrorCode.FileForbidden, 'File access is forbidden', { fileName, action: 'read' });
+            }
+        }
+        return file;
+    }
+    /** @internal */
+    async saveContent(data, resource, client) {
+        const identity = (0, core_1.currentAuthUser)();
+        // Checked against the model rather than the resource object, so a file field
+        // kept out of the resource output is still writable
+        const fileConfig = this.getFileConfig(client.name, data.fieldName);
+        if (!fileConfig) {
+            throw new common_1.FileError(common_1.ErrorCode.FileFieldNotFound, `File field '${data.fieldName}' does not exist on resource '${client.name}'`, { model: client.name, field: data.fieldName });
+        }
+        const policy = this.getFilePolicy(client.name, data.fieldName);
+        if (!(0, file_util_1.isValidMimeType)(data.mimeType, fileConfig.mimeType)) {
+            throw new common_1.FileError(common_1.ErrorCode.FileUnsupportedType, `Unsupported media file type: ${data.mimeType}`, { mimeType: data.mimeType });
+        }
+        if (fileConfig.array) {
+            const fileCount = await this.fileCount(data.fieldName, client.name, String(resource.id));
+            if (fileConfig.maxCount && fileConfig.maxCount < fileCount + 1) {
+                throw new common_1.FileError(common_1.ErrorCode.FileLimitExceeded, `Maximum number of files allowed: ${fileConfig.maxCount}`, { maxCount: fileConfig.maxCount });
+            }
+        }
+        let pattern;
+        if ((0, common_1.isFunction)(fileConfig.namePattern)) {
+            pattern = fileConfig.namePattern({
+                fieldName: data.fieldName,
+                fileName: data.fileName,
+                encoding: data.encoding,
+                mimeType: data.mimeType,
+                bytesRead: data.bytesRead(),
+                truncated: data.truncated()
+            }, resource);
+        }
+        else {
+            pattern = fileConfig.namePattern;
+        }
+        let generatedName = (0, file_util_1.generateFileName)(data.fileName, pattern, {
+            resourceField: data.fieldName,
+            resourceName: client.name,
+            resourceId: resource.id,
+            userId: identity?.id,
+            userEmail: identity?.email
+        });
+        // The generated name may come from a name pattern configured as a function,
+        // which cannot be validated on startup, so it is checked here as well.
+        this.assertPathNotReserved(generatedName);
+        let nameRegenCount = 0;
+        while (await this._storage.exists(generatedName)) {
+            nameRegenCount++;
+            if (nameRegenCount === 10) {
+                throw new common_1.FileError(common_1.ErrorCode.FileStorageError, 'Unable to generate unique file name');
+            }
+            const hash = (0, common_1.generateToken)('bytes');
+            const nameParts = generatedName.split('.');
+            if (nameParts.length > 1) {
+                const ext = nameParts.pop();
+                const base = nameParts.join('.');
+                generatedName = `${base}-${hash}.${ext}`;
+            }
+            else {
+                generatedName = `${nameParts[0]}-${hash}`;
+            }
+        }
+        const createFile = {
+            name: generatedName,
+            originalName: data.fileName,
+            mimeType: data.mimeType,
+            sizeBytes: data.bytesRead(),
+            resourceField: data.fieldName,
+            resourceName: client.name,
+            resourceId: String(resource.id),
+            createdById: identity?.id
+        };
+        if (!(0, policy_util_1.arePoliciesSkipped)() &&
+            (await policy.canCreate?.(identity ?? null, resource, createFile)) ===
+                false) {
+            throw new common_1.FileError(common_1.ErrorCode.FileForbidden, 'Creating file is forbidden', { action: 'create' });
+        }
+        let fileStream = data.stream;
+        if (this._imageProcessor?.supports(data.mimeType)) {
+            fileStream = this._imageProcessor.process(data.stream, data.mimeType, fileConfig.image);
+        }
+        // Tee the stream so the checksum and the stored size are calculated over the
+        // exact bytes written to storage in a single pass, without buffering the file.
+        let storedBytes = 0;
+        const storageStream = new node_stream_1.Transform({
+            transform(chunk, _encoding, callback) {
+                storedBytes += chunk.length;
+                callback(null, chunk);
+            }
+        });
+        const checksumStream = new node_stream_1.PassThrough();
+        fileStream.pipe(storageStream);
+        fileStream.pipe(checksumStream);
+        // pipe() does not forward source errors to destinations, so both branches
+        // must be destroyed manually to avoid hanging on a failed upload stream.
+        fileStream.on('error', (e) => {
+            common_1.logger.error(e, 'Error calculating file checksum');
+            storageStream.destroy(e);
+            checksumStream.destroy(e);
+        });
+        const [fileName, checksum] = await Promise.all([
+            this._storage.store(generatedName, storageStream, {
+                contentType: data.mimeType
+            }),
+            (0, common_1.makeHash)(checksumStream)
+        ]);
+        if (!fileName) {
+            throw new common_1.FileError(common_1.ErrorCode.FileStorageError, 'Error saving file to storage');
+        }
+        (0, internal_1.afterRollback)(() => this._storage.delete(fileName));
+        createFile.name = fileName;
+        createFile.checksum = checksum;
+        // The size of the content in storage, which is the processed one for images
+        createFile.sizeBytes = storedBytes;
+        // The size limit applies to the received content, whose read size and
+        // truncation flag are only known once the stream has been consumed.
+        const maxSizeBytes = (0, file_util_1.sizeInBytes)(fileConfig.maxSize);
+        if (data.truncated() ||
+            (maxSizeBytes > 0 && data.bytesRead() > maxSizeBytes)) {
+            await this._storage.delete(fileName);
+            throw new common_1.FileError(common_1.ErrorCode.FileTooLarge, `File size exceeded limit of ${maxSizeBytes} bytes`, { maxSizeBytes });
+        }
+        try {
+            // Check if a resource already has a file for a single file property and
+            // delete it after successfully creating the new one.
+            let existingFile = null;
+            if (!fileConfig.array) {
+                const resourceWithFile = await client.findFirst({
+                    where: { id: resource.id },
+                    include: { [data.fieldName]: true }
+                });
+                existingFile = resourceWithFile[data.fieldName];
+            }
+            const result = await client.update({
+                where: { id: resource.id },
+                data: {
+                    [data.fieldName]: {
+                        create: createFile
+                    }
+                },
+                include: { [data.fieldName]: true }
+            });
+            if (existingFile !== null) {
+                await this.deleteSafe(existingFile.name);
+            }
+            let file = result[data.fieldName];
+            if ((0, common_1.isArray)(result[data.fieldName])) {
+                file = result[data.fieldName].find((f) => f.name === createFile.name);
+            }
+            file.url = (0, file_util_1.buildFileUrl)(file);
+            common_1.logger.debug({ file }, 'File saved');
+            return file;
+        }
+        catch (e) {
+            await this.deleteSafe(fileName);
+            throw (0, database_error_1.toDatabaseError)(e, 'File');
+        }
+    }
+    /** @internal */
+    assertPathNotReserved(fileName) {
+        const reservedPath = (0, common_1.findReservedStoragePath)(fileName, core_1.storageConfig.RESERVED_PATHS);
+        if (reservedPath !== null) {
+            throw new common_1.FileError(common_1.ErrorCode.FileInvalidPath, `File path '${fileName}' is not allowed`, { fileName });
+        }
+    }
+    /**
+     * Removes a file from storage, or once the current transaction commits, so a
+     * rollback cannot leave a database row pointing at a removed file.
+     *
+     * @internal
+     */
+    async deleteStored(fileName) {
+        if ((0, internal_1.currentTransaction)()) {
+            (0, internal_1.afterCommit)(() => this._storage.delete(fileName));
+            return true;
+        }
+        return this._storage.delete(fileName);
+    }
+    /** @internal */
+    async deleteSafe(fileName) {
+        let success = true;
+        try {
+            const result = await this.deleteStored(fileName);
+            if (!result) {
+                success = false;
+            }
+        }
+        catch {
+            success = false;
+        }
+        try {
+            await this._db.client().file.delete({
+                where: { name: fileName }
+            });
+        }
+        catch {
+            success = false;
+        }
+        return success;
+    }
+    /** @internal */
+    async fileCount(resourceField, resourceName, resourceId) {
+        try {
+            return await this._db.client().file.count({
+                where: { resourceField, resourceName, resourceId }
+            });
+        }
+        catch (e) {
+            throw (0, database_error_1.toDatabaseError)(e, 'File');
+        }
+    }
+    /** Returns undefined when the model has no such file field configured.
+     * @internal */
+    getFileConfig(resourceName, resourceField) {
+        if (!resourceName || !resourceField) {
+            return undefined;
+        }
+        const config = (0, core_1.injectModel)(resourceName, false)?.config.files?.[resourceField];
+        return config ? { ...config } : undefined;
+    }
+    /** @internal */
+    getFilePolicy(resourceName, resourceField) {
+        if (!resourceName || !resourceField) {
+            return {};
+        }
+        const policy = (0, core_1.injectPolicy)(resourceName, false)?.files?.[resourceField] ?? {};
+        // Without an access type, a file is protected, which also runs the custom
+        // access check and the read restrictions of the owning resource
+        return { accessType: 'protected', ...policy };
+    }
+}
+exports.FileService = FileService;

package/storage/image-config.d.ts

@@ -0,0 +1,3 @@
+export declare const imageConfig: Readonly<{
+    PROVIDER: string;
+}>;

package/storage/image-config.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imageConfig = void 0;
+const typebox_1 = require("@sinclair/typebox");
+const common_1 = require("@appweaver/common");
+exports.imageConfig = (0, common_1.defineConfig)('image', {
+    /** Image processor transforming the uploaded images: `auto` (`sharp` when its module is enabled, otherwise none,
+     * keeping the images as they are uploaded), `sharp`, `none`, or the module path of an implementation. Default:
+     * `'auto'`. */
+    PROVIDER: typebox_1.Type.String({ default: 'auto' })
+});

package/storage/resources/file/model.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@appweaver/common").ResourceModel;
+export default _default;

package/storage/resources/file/model.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const create_model_1 = require("../../../factory/create-model");
+const file_util_1 = require("../../../utils/file-util");
+exports.default = (0, create_model_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',
+            maxLength: 1023,
+            unique: true,
+            example: 'image_123.png'
+        },
+        originalName: {
+            type: 'string',
+            maxLength: 255,
+            example: 'image.png'
+        },
+        mimeType: {
+            type: 'string',
+            maxLength: 127
+        },
+        sizeBytes: {
+            type: 'int',
+            minimum: 0,
+            example: 1024
+        },
+        checksum: {
+            type: 'string',
+            maxLength: 127,
+            example: '9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08'
+        },
+        title: {
+            type: 'string',
+            maxLength: 511,
+            required: false
+        },
+        description: {
+            type: 'string',
+            maxLength: 4095,
+            required: false
+        },
+        resourceField: {
+            type: 'string',
+            maxLength: 255,
+            required: false,
+            hidden: true
+        },
+        resourceName: {
+            type: 'string',
+            maxLength: 255,
+            required: false,
+            hidden: true
+        },
+        // Polymorphic reference without a foreign key, stored as text so a file can
+        // belong to a resource with either primary key type
+        resourceId: {
+            type: 'string',
+            maxLength: 36,
+            required: false,
+            hidden: true
+        }
+    },
+    virtual: {
+        url: {
+            type: 'string',
+            input: {
+                type: 'none'
+            },
+            output: {
+                value: (file) => (0, file_util_1.buildFileUrl)(file)
+            }
+        }
+    },
+    // Leads with the exact match columns, so the prefix also serves lookups
+    index: [['resourceName', 'resourceId', 'resourceField']]
+});