@lilaquadrat/studio 9.20.3 → 10.0.0-beta.10

package/lib/src/services/storage.service.js

@@ -0,0 +1,881 @@
+import fs from 'fs';
+import { pipeline } from 'stream/promises';
+import { createHash, createHmac } from 'crypto';
+import { mkdir } from 'fs/promises';
+import { spawn } from 'child_process';
+import Immutable from '../Immutable.class.js';
+import StorageModel from '../models/storage.model.js';
+import JetStreamService from './jetstream.service.js';
+import UploadService from './upload.service.js';
+import filenameHelper from '../helpers/filenameHelper.js';
+export class StorageService extends Immutable {
+    constructor(options) {
+        super();
+        this.buckets = {
+            cdn: {
+                public: true,
+                overwrite: false,
+                cache: 31536000,
+            },
+            hosting: {
+                public: false,
+                overwrite: true,
+                cache: 0,
+            },
+            secure: {
+                public: false,
+                overwrite: false,
+                cache: 31536000,
+            },
+            internal: {
+                public: false,
+                overwrite: false,
+                cache: 31536000,
+            },
+        };
+        this.model = StorageModel;
+        this.options = options;
+    }
+    /**
+     * Generates a secure, time-limited token for accessing files in secure storage buckets.
+     *
+     * The token is cryptographically signed using HMAC-SHA256 and base64url-encoded to be
+     * non-human readable and URL-safe.
+     *
+     * @param fileId - The file identifier (ObjectId or string) to grant access to
+     * @param expiresIn - Time in seconds until the token expires (default: 3600 = 1 hour)
+     * @param limits - Optional restrictions to apply to the token
+     * @param limits.company - Restrict token to specific company
+     * @param limits.project - Restrict token to specific project
+     * @param limits.app - Restrict token to specific app
+     * @param limits.url - Restrict token to specific URL path prefix
+     * @param limits.prefix - Restrict token to specific file prefix
+     *
+     * @returns Base64url-encoded token containing: fileId:expires[:limits]:signature
+     *
+     * @example
+     * // Generate token valid for 1 hour with no restrictions
+     * const { token } = getSecureToken('507f1f77bcf86cd799439011', 3600);
+     *
+     * @example
+     * // Generate token limited to specific company and project
+     * const { token } = getSecureToken('507f1f77bcf86cd799439011', 3600, {
+     *   company: 'acme',
+     *   project: 'website'
+     * });
+     *
+     * @example
+     * // Generate token limited to specific URL path
+     * const { token } = getSecureToken('507f1f77bcf86cd799439011', 3600, {
+     *   url: '/company/project/files/'
+     * });
+     */
+    getSecureToken(fileId, expiresIn = 3600, limits) {
+        const secret = process.env.SERVER_SECRET || 'secret';
+        const now = Math.floor(Date.now() / 1000);
+        const expires = now + expiresIn;
+        // Build payload: fileId:expires[:base64(limits)]
+        let payload = `${fileId}:${expires}`;
+        if (limits && Object.keys(limits).length > 0) {
+            // Base64 encode the JSON to avoid : separator conflicts
+            const limitsJson = JSON.stringify(limits);
+            const limitsBase64 = Buffer.from(limitsJson).toString('base64');
+            payload += `:${limitsBase64}`;
+        }
+        // Sign the payload with HMAC-SHA256
+        const signature = createHmac('sha256', secret).update(payload).digest('hex');
+        const combined = `${payload}:${signature}`;
+        // Encode as base64url for URL-safe, non-human readable format
+        const token = Buffer.from(combined).toString('base64url');
+        return {
+            token,
+            expiresIn,
+            createdAt: now,
+            expiresAt: expires,
+        };
+    }
+    /**
+     * Validates a secure token and optionally checks if it matches provided limits.
+     *
+     * Performs validations:
+     * 1. Signature verification using HMAC-SHA256
+     * 2. Expiration timestamp check
+     * 3. Optional limit validation against provided check values
+     *
+     * @param token - The base64url-encoded token to validate
+     * @param checkLimits - Optional values to verify against token's restrictions
+     * @param checkLimits.company - Company to check against token limit
+     * @param checkLimits.project - Project to check against token limit
+     * @param checkLimits.app - App to check against token limit
+     * @param checkLimits.url - URL path to check against token limit
+     * @param checkLimits.prefix - File prefix to check against token limit
+     *
+     * @returns true if token is valid and all checks pass, false otherwise
+     *
+     * @example
+     * // Validate token without checking limits
+     * const isValid = validateSecureToken(token);
+     *
+     * @example
+     * // Validate token and check company/project access
+     * const isValid = validateSecureToken(token, {
+     *   company: 'acme',
+     *   project: 'website'
+     * });
+     */
+    validateSecureToken(token, checkLimits) {
+        const secret = process.env.SERVER_SECRET || 'secret';
+        let decoded;
+        // Decode from base64url format
+        try {
+            decoded = Buffer.from(token, 'base64url').toString('utf-8');
+        }
+        catch {
+            return false;
+        }
+        // Extract payload and signature (signature is after last colon)
+        const lastColonIndex = decoded.lastIndexOf(':');
+        if (lastColonIndex === -1)
+            return false;
+        const payload = decoded.substring(0, lastColonIndex);
+        const signature = decoded.substring(lastColonIndex + 1);
+        // Verify signature matches expected HMAC
+        const expectedSignature = createHmac('sha256', secret).update(payload).digest('hex');
+        if (signature !== expectedSignature)
+            return false;
+        // Parse payload structure: fileId:expires[:base64(limits)]
+        const parts = payload.split(':');
+        // parts[0] is fileId
+        // parts[1] is expires timestamp
+        // parts[2] is optional base64-encoded JSON limits object
+        if (parts.length < 2)
+            return false;
+        // Check if token has expired
+        const expires = parseInt(parts[1], 10);
+        if (Date.now() / 1000 > expires)
+            return false;
+        // If token has limits, validate against checkLimits
+        if (parts.length > 2) {
+            let tokenLimits;
+            try {
+                // Decode from base64 first, then parse JSON
+                const limitsJson = Buffer.from(parts[2], 'base64').toString('utf-8');
+                tokenLimits = JSON.parse(limitsJson);
+            }
+            catch {
+                return false;
+            }
+            // Token has limits but no values provided to check
+            if (!checkLimits)
+                return false;
+            // Validate each limit field if present in token
+            if (tokenLimits.company && tokenLimits.company !== checkLimits.company)
+                return false;
+            if (tokenLimits.project && tokenLimits.project !== checkLimits.project)
+                return false;
+            if (tokenLimits.app && tokenLimits.app !== checkLimits.app)
+                return false;
+            if (tokenLimits.prefix && tokenLimits.prefix !== checkLimits.prefix)
+                return false;
+            // For URL limit, check if requested URL starts with the token's allowed prefix
+            if (tokenLimits.url && checkLimits.url && !checkLimits.url.startsWith(tokenLimits.url))
+                return false;
+        }
+        else if (checkLimits) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Creates a secure download URL with time-limited token for a storage file.
+     *
+     * @param fileId - The ObjectId of the storage document
+     * @param options - Required options containing company, project
+     * @param expiresIn - Time in seconds until the token expires (default: 3600 = 1 hour)
+     * @param limits - Optional additional restrictions for the token
+     *
+     * @returns Object containing the full download URL with token and expiration timestamp
+     *
+     * @example
+     * const download = await createSecureDownload(
+     *   new ObjectId('507f1f77bcf86cd799439011'),
+     *   { company: 'acme', project: 'website' },
+     *   3600
+     * );
+     * // Returns: { url: 'https://...?token=...', expiresAt: 1234567890 }
+     */
+    async createSecureDownload(fileId, options, expiresIn = 3600, limits) {
+        // Fetch storage document to get file details
+        const storage = await this.getByInternalId(fileId, options);
+        if (!storage)
+            throw new Error('STORAGE_FILE_NOT_FOUND');
+        // Merge provided limits with storage document context
+        const tokenLimits = {
+            company: limits?.company || storage.company,
+            project: limits?.project || storage.project,
+            app: limits?.app || storage.app,
+            prefix: limits?.prefix || storage.prefix,
+            url: limits?.url,
+        };
+        // Generate secure token
+        const tokenData = this.getSecureToken(fileId, expiresIn, tokenLimits);
+        // Construct download URL
+        const baseUrl = process.env.SECURE_URL;
+        const path = storage.prefix ? `${storage.prefix}/${storage.filename}` : storage.filename;
+        const url = `${baseUrl}/${storage.app}/${storage.company}/${storage.project}/${path}?token=${tokenData.token}`;
+        return {
+            url,
+            expiresAt: tokenData.expiresAt,
+        };
+    }
+    async handleFile(uploadInternalId, index, file) {
+        if (!file)
+            throw new Error('FILE_MISSING');
+        /**
+         * each uploads needs to be registered with createUpload before uploading an actual file
+         */
+        const uploadFile = await UploadService.single(uploadInternalId);
+        if (!uploadFile)
+            throw new Error('UPLOAD_NOT_FOUND');
+        /**
+         * write the file to the disk.
+         * after writing the stream we can check if the filesize was exceeded und truncated
+         */
+        const path = await this.writeFile(file.file, index, uploadInternalId, 'upload');
+        if (file.file.truncated) {
+            await fs.promises.unlink(path.file);
+            throw new Error('FILE_SIZE');
+        }
+        const updloadState = await UploadService.addPathToUpload(uploadInternalId, index, path.file);
+        /**
+        * if all chunks are there, complete the file and the upload
+        */
+        if (updloadState.chunks === updloadState.paths?.length) {
+            await UploadService.setState(updloadState._id, 'waiting');
+            await JetStreamService.publish('actions.files.uploaded', updloadState);
+        }
+        return updloadState;
+    }
+    complete(upload, options) {
+        return this.writeFile(upload.paths, undefined, upload._id, 'file', options);
+    }
+    async writeFile(data, index, internalId, type, options) {
+        const pathAndFile = type === 'upload' && index || index === 0
+            ? this.uploadPath(internalId.toString(), index)
+            : this.fanoutPath(internalId.toString());
+        await mkdir(`${pathAndFile.dir}`, { recursive: true });
+        if (Array.isArray(data)) {
+            if (options?.useNode) {
+                await this.concatenateFiles(data, pathAndFile.file);
+            }
+            else {
+                await this.concatenateFilesWithCat(data, pathAndFile.file);
+            }
+        }
+        else {
+            const writeStream = fs.createWriteStream(pathAndFile.file);
+            await pipeline(data, writeStream);
+        }
+        return pathAndFile;
+    }
+    async writeFileVersion(data, internalId, version) {
+        const pathAndFile = this.fanoutPath(internalId.toString(), version);
+        await mkdir(`${pathAndFile.dir}`, { recursive: true });
+        await fs.promises.writeFile(pathAndFile.file, Uint8Array.from(data));
+        return pathAndFile;
+    }
+    async concatenateFiles(paths, outputPath) {
+        const writeStream = fs.createWriteStream(outputPath);
+        const sortedPaths = paths.sort((a, b) => a.index - b.index);
+        for (const single of sortedPaths) {
+            const readStream = fs.createReadStream(single.path);
+            await pipeline(readStream, writeStream, { end: false });
+        }
+        writeStream.end();
+        await new Promise((resolve, reject) => {
+            writeStream.on('finish', resolve);
+            writeStream.on('error', reject);
+        });
+    }
+    async concatenateFilesWithCat(paths, outputPath) {
+        const sortedPaths = paths.sort((a, b) => a.index - b.index);
+        const filePaths = sortedPaths.map(single => single.path);
+        return new Promise((resolve, reject) => {
+            const outputStream = fs.createWriteStream(outputPath);
+            const stderrChunks = [];
+            const cat = spawn('cat', filePaths, { stdio: ['ignore', 'pipe', 'pipe'] });
+            cat.stderr?.on('data', (chunk) => {
+                stderrChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+            });
+            cat.stdout.on('error', (error) => {
+                outputStream.destroy();
+                reject(new Error(`cat stdout error: ${error.message}`));
+            });
+            cat.on('error', (error) => {
+                const stderr = Buffer.concat(stderrChunks).toString('utf8').trim();
+                const preview = filePaths.slice(0, 5).join(', ');
+                outputStream.destroy();
+                reject(new Error([
+                    `cat process error: ${error.message}`,
+                    error.code ? `code=${error.code}` : undefined,
+                    stderr ? `stderr="${stderr}"` : undefined,
+                    `files=${filePaths.length}${filePaths.length ? ` (first: ${preview}${filePaths.length > 5 ? ', ...' : ''})` : ''}`,
+                ].filter(Boolean).join(' | ')));
+            });
+            cat.stdout.pipe(outputStream);
+            cat.on('close', (code, signal) => {
+                const stderr = Buffer.concat(stderrChunks).toString('utf8').trim();
+                if (code === 0 && !signal) {
+                    outputStream.end(() => resolve());
+                }
+                else {
+                    const preview = filePaths.slice(0, 5).join(', ');
+                    outputStream.destroy();
+                    reject(new Error([
+                        `cat process exited`,
+                        `code=${code}`,
+                        signal ? `signal=${signal}` : undefined,
+                        stderr ? `stderr="${stderr}"` : undefined,
+                        `files=${filePaths.length}${filePaths.length ? ` (first: ${preview}${filePaths.length > 5 ? ', ...' : ''})` : ''}`,
+                    ].filter(Boolean).join(' | ')));
+                }
+            });
+            outputStream.on('error', (error) => {
+                cat.kill('SIGKILL');
+                reject(new Error(`write stream error: ${error.message}`));
+            });
+        });
+    }
+    async removeUploadFiles(upload) {
+        const promises = upload.paths?.map(async (single) => {
+            try {
+                await fs.promises.unlink(single.path);
+            }
+            catch (error) {
+                console.error(`failed to remove ${single.path}:`, error);
+            }
+        });
+        if (promises) {
+            await Promise.all(promises);
+            await fs.promises.rmdir(`${this.options.uploadFolder}/${upload._id}`);
+        }
+    }
+    async removeLocalFile(relativePath) {
+        const fullPath = `${this.options.dataFolder}/${relativePath}`;
+        try {
+            await fs.promises.access(fullPath);
+            return await fs.promises.unlink(fullPath);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                console.warn(`File not found: ${fullPath}`);
+                return;
+            }
+            throw error;
+        }
+    }
+    /**
+     * creata directory structure for the given file
+     * e.g. ``/b1/f1/68fb87d6db4fb20117bcd3ce.000001``
+     */
+    fanoutPath(uploadId, version) {
+        const baseFolder = this.options.dataFolder;
+        /**
+         * upload needs to have the part and index in the filename
+         */
+        const filename = uploadId;
+        // Stable, uniform fan-out from the id (or use sha256 of expected filename+size)
+        const hash = createHash('sha256').update(`${version || ''}${uploadId}`).digest('hex');
+        const lvl1 = hash.slice(0, 2);
+        const lvl2 = hash.slice(2, 4);
+        const dir = [baseFolder, lvl1, lvl2].join('/');
+        const file = [dir, filename].join('/');
+        const relativePath = [lvl1, lvl2, filename].join('/');
+        return { dir, file, relativePath };
+    }
+    uploadPath(uploadId, index) {
+        const baseFolder = `${this.options.uploadFolder}/${uploadId}`;
+        const filename = `${uploadId}.${index?.toString().padStart(6, '0')}`;
+        const file = [baseFolder, filename].join('/');
+        return { dir: baseFolder, file, relativePath: file };
+    }
+    // async createUpload(filename: string, size: number, chunks: number, mimetype: string, options: UserAppOptionsRequired) {
+    //   const useFilename = this.sanitizeName(filename);
+    //   if (await this.exists(options.company, options.project, useFilename)) throw new Error('FILE_EXISTS');
+    //   if (await UploadService.uploadExists(options.company, options.project, useFilename)) throw new Error('UPLOAD_EXISTS');
+    //   return UploadService.createUpload(useFilename, size, chunks, mimetype, options);
+    // }
+    static sanitizeName(name) {
+        return name.replace(/[^a-z0-9-_.]/gi, '').toLowerCase();
+    }
+    getMetadata(upload, metadata) {
+        const useMetadata = metadata || {};
+        useMetadata.size = upload.size;
+        useMetadata.mimetype = upload.mimetype;
+        if (upload.mimetype) {
+            if (upload.mimetype.match(/^image/)) {
+                if (!Array.isArray(useMetadata.tags))
+                    useMetadata.tags = [];
+                useMetadata.tags?.push('image');
+            }
+            if (upload.mimetype.match(/^video/)) {
+                if (!Array.isArray(useMetadata.tags))
+                    useMetadata.tags = [];
+                useMetadata.tags?.push('video');
+            }
+        }
+        return useMetadata;
+    }
+    get(company, project, app, query, limit) {
+        const realQuery = { company, project, app, parent: { $exists: false } };
+        let tags;
+        if (query.tags) {
+            if (!Array.isArray(query.tags)) {
+                tags = [query.tags];
+            }
+            else {
+                tags = query.tags;
+            }
+            realQuery['metadata.tags'] = { $in: tags };
+        }
+        if (query.search) {
+            realQuery.filename = { $regex: query.search, $options: 'i' };
+        }
+        // If ignorePrefix is given, return all matching files without prefix filtering
+        if (query.ignorePrefix) {
+            return StorageModel.db.aggregate([
+                {
+                    $match: realQuery,
+                },
+                {
+                    $facet: {
+                        metadata: [{ $count: 'all' }],
+                        data: [
+                            { $sort: { _id: -1 } },
+                            { $skip: limit?.skip || 0 },
+                            { $limit: limit?.limit || 50 },
+                            { $project: { path: 0, bucket: 0 } },
+                            { $addFields: { type: 'file' } },
+                        ],
+                    },
+                },
+                {
+                    $project: {
+                        all: { $arrayElemAt: ['$metadata.all', 0] },
+                        data: 1,
+                        count: { $size: '$data' },
+                    },
+                },
+            ])
+                .toArray()
+                .then((result) => result[0] || { all: 0, data: [], count: 0 });
+        }
+        // If search or tags are given, show only files at the current level (no folders)
+        if (query.search || query.tags) {
+            const isRootLevel = query.prefix === undefined || query.prefix === '';
+            if (isRootLevel) {
+                // Root level: only files without prefix
+                realQuery.$or = [
+                    { prefix: { $exists: false } },
+                    { prefix: null },
+                    { prefix: '' },
+                ];
+            }
+            else {
+                // Non-root: only files with exact prefix match
+                realQuery.prefix = query.prefix;
+            }
+            return StorageModel.db.aggregate([
+                {
+                    $match: realQuery,
+                },
+                {
+                    $facet: {
+                        metadata: [{ $count: 'all' }],
+                        data: [
+                            { $sort: { _id: -1 } },
+                            { $skip: limit?.skip || 0 },
+                            { $limit: limit?.limit || 50 },
+                            { $project: { path: 0, bucket: 0 } },
+                            { $addFields: { type: 'file' } },
+                        ],
+                    },
+                },
+                {
+                    $project: {
+                        all: { $arrayElemAt: ['$metadata.all', 0] },
+                        data: 1,
+                        count: { $size: '$data' },
+                    },
+                },
+            ])
+                .toArray()
+                .then((result) => result[0] || { all: 0, data: [], count: 0 });
+        }
+        // Treat undefined prefix same as empty string (root level)
+        const isRootLevel = query.prefix === undefined || query.prefix === '';
+        if (isRootLevel) {
+            // Root level: show files without prefix and extract virtual folders
+            return StorageModel.db.aggregate([
+                {
+                    $match: realQuery,
+                },
+                {
+                    $addFields: {
+                        // Extract first segment of prefix for root-level folders
+                        immediateSubfolder: {
+                            $cond: {
+                                if: {
+                                    $or: [
+                                        { $eq: ['$prefix', null] },
+                                        { $eq: ['$prefix', ''] },
+                                        { $eq: [{ $type: '$prefix' }, 'missing'] },
+                                    ],
+                                },
+                                then: null, // File at root level (no prefix)
+                                else: {
+                                    // Extract first segment of prefix
+                                    $arrayElemAt: [{ $split: ['$prefix', '/'] }, 0],
+                                },
+                            },
+                        },
+                    },
+                },
+                {
+                    $facet: {
+                        files: [
+                            { $match: { immediateSubfolder: null } }, // Files at root level
+                            { $sort: { _id: -1 } },
+                            { $skip: limit?.skip || 0 },
+                            { $limit: limit?.limit || 50 },
+                            { $project: { path: 0, bucket: 0, immediateSubfolder: 0 } },
+                            { $addFields: { type: 'file' } },
+                        ],
+                        folders: [
+                            { $match: { immediateSubfolder: { $ne: null } } },
+                            { $group: { _id: '$immediateSubfolder' } }, // Unique folder names
+                            { $sort: { _id: 1 } },
+                            {
+                                $project: {
+                                    _id: 0,
+                                    prefix: '$_id',
+                                    name: '$_id',
+                                    type: { $literal: 'folder' },
+                                },
+                            },
+                        ],
+                        metadata: [
+                            { $match: { immediateSubfolder: null } },
+                            { $count: 'all' },
+                        ],
+                    },
+                },
+                {
+                    $project: {
+                        all: { $arrayElemAt: ['$metadata.all', 0] },
+                        data: { $concatArrays: ['$folders', '$files'] },
+                        count: { $add: [{ $size: '$folders' }, { $size: '$files' }] },
+                    },
+                },
+            ])
+                .toArray()
+                .then((result) => result[0] || { all: 0, data: [], count: 0 });
+        }
+        // Non-root: show exact prefix match and extract subfolders
+        const prefixWithSlash = query.prefix.endsWith('/') ? query.prefix : `${query.prefix}/`;
+        const escapedPrefix = prefixWithSlash.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // Build non-root query by adding prefix conditions to realQuery
+        const nonRootQuery = {
+            ...realQuery,
+            $or: [
+                { prefix: query.prefix }, // Exact match files
+                { prefix: { $regex: `^${escapedPrefix}` } }, // Deeper files for folder extraction
+            ],
+        };
+        return StorageModel.db.aggregate([
+            {
+                $match: nonRootQuery,
+            },
+            {
+                $addFields: {
+                    // Extract immediate subfolder name after current prefix
+                    immediateSubfolder: {
+                        $cond: {
+                            if: { $eq: ['$prefix', query.prefix] },
+                            then: null, // File at exact level
+                            else: {
+                                // Extract first segment after prefix
+                                $arrayElemAt: [
+                                    { $split: [{ $substr: ['$prefix', prefixWithSlash.length, -1] }, '/'] },
+                                    0,
+                                ],
+                            },
+                        },
+                    },
+                },
+            },
+            {
+                $facet: {
+                    files: [
+                        { $match: { immediateSubfolder: null } }, // Files at exact level
+                        { $sort: { _id: -1 } },
+                        { $skip: limit?.skip || 0 },
+                        { $limit: limit?.limit || 50 },
+                        { $project: { path: 0, bucket: 0, immediateSubfolder: 0 } },
+                        { $addFields: { type: 'file' } },
+                    ],
+                    folders: [
+                        { $match: { immediateSubfolder: { $ne: null } } },
+                        { $group: { _id: '$immediateSubfolder' } }, // Unique folder names
+                        { $sort: { _id: 1 } },
+                        {
+                            $project: {
+                                _id: 0,
+                                prefix: { $concat: [prefixWithSlash, '$_id'] },
+                                name: '$_id',
+                                type: { $literal: 'folder' },
+                            },
+                        },
+                    ],
+                    metadata: [
+                        { $match: { immediateSubfolder: null } },
+                        { $count: 'all' },
+                    ],
+                },
+            },
+            {
+                $project: {
+                    all: { $arrayElemAt: ['$metadata.all', 0] },
+                    data: { $concatArrays: ['$folders', '$files'] },
+                    count: { $add: [{ $size: '$folders' }, { $size: '$files' }] },
+                },
+            },
+        ])
+            .toArray()
+            .then((result) => result[0] || { all: 0, data: [], count: 0 });
+    }
+    getTags(company, project, search) {
+        let cleanSearch = search.toLowerCase().trim();
+        let sortString = cleanSearch;
+        let splitSearch = [];
+        if (cleanSearch.includes(':')) {
+            splitSearch = cleanSearch.split(':');
+            cleanSearch = new RegExp(`^${splitSearch[0]}:.*?(${splitSearch[1]})`);
+            sortString = cleanSearch[1];
+        }
+        else {
+            cleanSearch = new RegExp(`^(?!([a-z]+):).*(${cleanSearch}).*`);
+        }
+        return StorageModel.db.find({ company, project, tags: { $regex: cleanSearch, $options: 'i' } }, { projection: { tags: 1 } })
+            .toArray()
+            .then((matchedDocuments) => this.matchSortTags(matchedDocuments, cleanSearch, sortString));
+    }
+    single(company, project, filename) {
+        return StorageModel.db.aggregate([
+            {
+                $match: {
+                    company,
+                    project,
+                    id: filename,
+                },
+            },
+            {
+                $lookup: {
+                    from: 'editor',
+                    as: 'baseContentData',
+                    let: {
+                        pid: '$baseContent.id',
+                        company: '$company',
+                        project: '$project',
+                    },
+                    pipeline: [
+                        {
+                            $match: {
+                                $and: [
+                                    {
+                                        $expr: { $eq: ['$_id', '$$pid'] },
+                                    },
+                                    {
+                                        $expr: { $eq: ['$company', '$$company'] },
+                                    },
+                                    {
+                                        $expr: { $eq: ['$project', '$$project'] },
+                                    },
+                                ],
+                            },
+                        },
+                        {
+                            $project: {
+                                id: 1,
+                                history: 1,
+                            },
+                        },
+                    ],
+                },
+            },
+            {
+                $unwind: {
+                    path: '$baseContentData',
+                    preserveNullAndEmptyArrays: true,
+                },
+            },
+            {
+                $addFields: {
+                    'baseContent.content': '$baseContentData',
+                },
+            },
+            {
+                $project: {
+                    baseContentData: 0,
+                },
+            },
+        ])
+            .toArray()
+            .then((data) => (data.length ? data[0] : null));
+    }
+    content(company, project, id) {
+        return StorageModel.db.aggregate([
+            {
+                $match: {
+                    company,
+                    project,
+                    'baseContent.id': id,
+                },
+            },
+            {
+                $setWindowFields: {
+                    partitionBy: '$baseContent.id',
+                    sortBy: {
+                        'baseContent.version': -1,
+                    },
+                    output: {
+                        availableVersions: {
+                            $count: {},
+                            window: {
+                                documents: [
+                                    'unbounded', 'unbounded',
+                                ],
+                            },
+                        },
+                    },
+                },
+            },
+            {
+                $limit: 1,
+            },
+        ])
+            .toArray()
+            .then((data) => (data.length ? data[0] : null));
+    }
+    /**
+     * checks if the file was already successfully uploaded
+     */
+    exists(filename, prefix, app, options) {
+        return StorageModel.db.countDocuments({
+            company: options.company,
+            project: options.project,
+            filename,
+            prefix,
+            app,
+        })
+            .then((exists) => exists >= 1);
+    }
+    matchSortTags(documents, search, sort) {
+        const mergedArray = [];
+        const returnArray = [];
+        documents.forEach((document) => {
+            document.tags.forEach((tag) => {
+                if (mergedArray.find((tagArray) => tagArray.tag === tag))
+                    return;
+                if (!tag.match(search))
+                    return;
+                mergedArray.push({ tag, rating: tag.indexOf(sort) });
+            });
+        });
+        mergedArray.sort((a, b) => (a.rating > b.rating ? 1 : -1));
+        mergedArray.forEach((tag) => {
+            returnArray.push(tag.tag);
+        });
+        return returnArray;
+    }
+    checkAllowedSize(filesize, allowedSize) {
+        return filesize < allowedSize;
+    }
+    stats(company, project) {
+        const aggregation = [
+            {
+                $match: {
+                    company,
+                    project,
+                    parent: { $exists: false },
+                },
+            },
+            {
+                $group: {
+                    _id: null,
+                    used: {
+                        $sum: '$metadata.size',
+                    },
+                    files: {
+                        $sum: 1,
+                    },
+                },
+            },
+            {
+                $project: {
+                    _id: 0,
+                    used: 1,
+                    files: 1,
+                },
+            },
+        ];
+        return StorageModel.db.aggregate(aggregation).toArray()
+            .then((value) => value[0] || { files: 0, size: 0 });
+    }
+    getByInternalId(internalId, options) {
+        return StorageModel.db.findOne({ _id: internalId, company: options.company, project: options.project });
+    }
+    getPathByFilename(filename, app, options) {
+        const filenameObject = filenameHelper(filename);
+        return StorageModel.db.findOne({
+            filename: filenameObject.filename,
+            prefix: filenameObject.directory,
+            company: options.company,
+            project: options.project,
+            app,
+        }, {
+            projection: { path: 1, metadata: 1 },
+        });
+    }
+    getByFilename(filename, prefix, bucket, options) {
+        return StorageModel.db.findOne({
+            filename,
+            prefix,
+            company: options.company,
+            project: options.project,
+            bucket,
+        });
+    }
+    async removeBlob(internalId, options) {
+        const storage = await this.model.db.findOne({ _id: internalId, company: options.company, project: options.project });
+        if (!storage)
+            throw new Error('BLOB_NOT_FOUND');
+        await fs.promises.unlink(`${this.options.dataFolder}/${storage.path}`);
+        await this.removeBlobVersion(internalId, options);
+        return this.delete(internalId, options.user, options.app);
+    }
+    async removeBlobVersion(parentId, options) {
+        const versions = await this.model.db.find({ parent: parentId, company: options.company, project: options.project }).toArray();
+        if (versions.length) {
+            await Promise.allSettled(versions.map(async (single) => {
+                await fs.promises.unlink(`${this.options.dataFolder}/${single.path}`);
+                return this.delete(single._id, options.user, options.app);
+            }));
+        }
+    }
+}
+export default new StorageService({
+    dataFolder: process.env.MEDIA_FOLDERS_DATA,
+    uploadFolder: process.env.MEDIA_FOLDERS_UPLOAD,
+});
+//# sourceMappingURL=storage.service.js.map