@wrcb/cb-common 1.0.383 → 1.0.385

package/build/index.d.ts

@@ -18,3 +18,5 @@ export * from './types/userCategory';
 export * from './types/productTypes';
 export * from './events/subjects';
 export * from './services/TenantDataService';
+export * from './storage/types';
+export * from './storage/interfaces/MediaConfiguration';

package/build/index.js

@@ -34,3 +34,5 @@ __exportStar(require("./types/userCategory"), exports);
 __exportStar(require("./types/productTypes"), exports);
 __exportStar(require("./events/subjects"), exports);
 __exportStar(require("./services/TenantDataService"), exports);
+__exportStar(require("./storage/types"), exports);
+__exportStar(require("./storage/interfaces/MediaConfiguration"), exports);

package/build/middlewares/uploadMedia.d.ts

@@ -0,0 +1,14 @@
+import { Request, Response, NextFunction } from 'express';
+import { UploadResult } from '../storage/types';
+declare global {
+    namespace Express {
+        interface Request {
+            uploadResults?: UploadResult[];
+        }
+    }
+}
+export declare const uploadMiddleware: {
+    single: (fieldName: string) => import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+    multiple: (fieldName: string, maxCount?: number) => import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+    processUpload: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+};

package/build/middlewares/uploadMedia.js

@@ -0,0 +1,60 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadMiddleware = void 0;
+const multer_1 = __importDefault(require("multer"));
+const factory_1 = require("../storage/factory");
+const tenant_1 = require("../types/tenant");
+const storageService_1 = require("../storage/services/storageService");
+const storage = multer_1.default.memoryStorage();
+const upload = (0, multer_1.default)({ storage });
+exports.uploadMiddleware = {
+    single: (fieldName) => upload.single(fieldName),
+    multiple: (fieldName, maxCount) => upload.array(fieldName, maxCount),
+    processUpload: (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const storageService = new storageService_1.StorageService(factory_1.StorageFactory.create());
+            const tenant = req.headers['x-tenant'] || tenant_1.Tenant.PoliticaBet;
+            const files = req.files || (req.file ? [req.file] : []);
+            if (!files.length) {
+                return next();
+            }
+            const uploadPromises = files.map((file) => __awaiter(void 0, void 0, void 0, function* () {
+                var _a;
+                const isVideo = file.mimetype.startsWith('video/');
+                // Solução 1: Declarar o tipo explicitamente
+                const type = isVideo ? 'video' : 'photo';
+                const options = {
+                    tenant,
+                    userId: ((_a = req.currentUser) === null || _a === void 0 ? void 0 : _a.id) || undefined,
+                    targetId: req.body.targetId || undefined,
+                    type,
+                    generateThumbnail: true
+                };
+                if (isVideo) {
+                    return storageService.uploadVideo(file.buffer, file.originalname, options);
+                }
+                else {
+                    return storageService.uploadImage(file.buffer, file.originalname, options);
+                }
+            }));
+            const results = yield Promise.all(uploadPromises);
+            req.uploadResults = results;
+            next();
+        }
+        catch (error) {
+            next(error);
+        }
+    })
+};

package/build/server.d.ts

@@ -21,6 +21,7 @@ export * from './middlewares/requireVerifiedWhatsapp';
 export * from './middlewares/requireProvidedAddress';
 export * from './middlewares/requireProvidedPersonalData';
 export * from './middlewares/standardResponse';
+export * from './middlewares/uploadMedia';
 export * from './events/baseListener';
 export * from './events/basePublisher';
 export * from './events/callStartedEvent';
@@ -44,3 +45,9 @@ export * from './events/linkAndCodeToVerifyEmailCreatedEvent';
 export * from './events/linkAndcodeToVerifyWhatsappCreatedEvent';
 export * from './services/RedisService';
 export * from './services/TenantDataService';
+export * from './storage/services/storageService';
+export * from './storage/factory';
+export * from './storage/types';
+export * from './storage/providers/minio';
+export * from './storage/providers/spaces';
+export * from './storage/interfaces/MediaConfiguration';

package/build/server.js

@@ -37,6 +37,7 @@ __exportStar(require("./middlewares/requireVerifiedWhatsapp"), exports);
 __exportStar(require("./middlewares/requireProvidedAddress"), exports);
 __exportStar(require("./middlewares/requireProvidedPersonalData"), exports);
 __exportStar(require("./middlewares/standardResponse"), exports);
+__exportStar(require("./middlewares/uploadMedia"), exports);
 __exportStar(require("./events/baseListener"), exports);
 __exportStar(require("./events/basePublisher"), exports);
 __exportStar(require("./events/callStartedEvent"), exports);
@@ -60,3 +61,9 @@ __exportStar(require("./events/linkAndCodeToVerifyEmailCreatedEvent"), exports);
 __exportStar(require("./events/linkAndcodeToVerifyWhatsappCreatedEvent"), exports);
 __exportStar(require("./services/RedisService"), exports);
 __exportStar(require("./services/TenantDataService"), exports);
+__exportStar(require("./storage/services/storageService"), exports);
+__exportStar(require("./storage/factory"), exports);
+__exportStar(require("./storage/types"), exports);
+__exportStar(require("./storage/providers/minio"), exports);
+__exportStar(require("./storage/providers/spaces"), exports);
+__exportStar(require("./storage/interfaces/MediaConfiguration"), exports);

package/build/services/TenantDataService.d.ts

@@ -3,6 +3,7 @@ import { Tenant } from '../types/tenant';
 import { UserCategory } from '../types/userCategory';
 import { UserTags } from '../types/userTags';
 import { ProductTypes } from '../types/productTypes';
+import { MediaConfiguration } from '../storage/interfaces/MediaConfiguration';
 export interface CategoryConfiguration {
     allowedTags: UserTags[];
     allowedProducts: ProductTypes[];
@@ -28,6 +29,7 @@ export interface TenantData {
     AUTH_GOOGLE_SECRET: string;
     GOOGLE_ANALYTICS_MEASUREMENT_ID: string;
     GOOGLE_VERIFICATION: string;
+    MEDIA_CONFIG: MediaConfiguration;
 }
 export declare class TenantDataService {
     private static tenantDataMap;

package/build/services/TenantDataService.js

@@ -86,7 +86,18 @@ TenantDataService.tenantDataMap = {
         AUTH_GOOGLE_ID: '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',
         AUTH_GOOGLE_SECRET: '',
         GOOGLE_ANALYTICS_MEASUREMENT_ID: '',
-        GOOGLE_VERIFICATION: 'MxMj1CaliRbJ6G7cp0eIYXug0QF6hyugQ1P74T6sCzc'
+        GOOGLE_VERIFICATION: 'MxMj1CaliRbJ6G7cp0eIYXug0QF6hyugQ1P74T6sCzc',
+        MEDIA_CONFIG: {
+            maxPhotoSizeMB: 3,
+            maxVideoSizeMB: 50,
+            allowedImageFormats: ['jpg', 'jpeg', 'png', 'webp'],
+            allowedVideoFormats: ['mp4', 'webm', 'mov'],
+            imageQualities: {
+                thumbnail: { width: 150, height: 150, quality: 80 },
+                medium: { width: 800, height: 800, quality: 85 },
+                large: { width: 1920, height: 1920, quality: 90 }
+            }
+        }
     },
     [tenant_1.Tenant.TourismApp]: {
         TENANT: tenant_1.Tenant.TourismApp,
@@ -151,7 +162,18 @@ TenantDataService.tenantDataMap = {
         AUTH_GOOGLE_ID: '',
         AUTH_GOOGLE_SECRET: '',
         GOOGLE_ANALYTICS_MEASUREMENT_ID: '',
-        GOOGLE_VERIFICATION: ''
+        GOOGLE_VERIFICATION: '',
+        MEDIA_CONFIG: {
+            maxPhotoSizeMB: 3,
+            maxVideoSizeMB: 50,
+            allowedImageFormats: ['jpg', 'jpeg', 'png', 'webp'],
+            allowedVideoFormats: ['mp4', 'webm', 'mov'],
+            imageQualities: {
+                thumbnail: { width: 150, height: 150, quality: 80 },
+                medium: { width: 800, height: 800, quality: 85 },
+                large: { width: 1920, height: 1920, quality: 90 }
+            }
+        }
     },
     [tenant_1.Tenant.PrivateShow]: {
         TENANT: tenant_1.Tenant.PrivateShow,
@@ -189,6 +211,17 @@ TenantDataService.tenantDataMap = {
         AUTH_GOOGLE_ID: '',
         AUTH_GOOGLE_SECRET: '',
         GOOGLE_ANALYTICS_MEASUREMENT_ID: '',
-        GOOGLE_VERIFICATION: ''
+        GOOGLE_VERIFICATION: '',
+        MEDIA_CONFIG: {
+            maxPhotoSizeMB: 5,
+            maxVideoSizeMB: 100,
+            allowedImageFormats: ['jpg', 'jpeg', 'png', 'webp'],
+            allowedVideoFormats: ['mp4', 'webm', 'mov'],
+            imageQualities: {
+                thumbnail: { width: 150, height: 150, quality: 80 },
+                medium: { width: 800, height: 800, quality: 85 },
+                large: { width: 1920, height: 1920, quality: 90 }
+            }
+        }
     }
 };

package/build/storage/factory.d.ts

@@ -0,0 +1,4 @@
+import { StorageProvider } from './types';
+export declare class StorageFactory {
+    static create(): StorageProvider;
+}

package/build/storage/factory.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageFactory = void 0;
+const minio_1 = require("./providers/minio");
+const spaces_1 = require("./providers/spaces");
+const server_1 = require("../server");
+class StorageFactory {
+    static create() {
+        const provider = process.env.STORAGE_PROVIDER || 'minio';
+        switch (provider) {
+            case 'minio':
+                return new minio_1.MinioProvider({
+                    endPoint: process.env.MINIO_ENDPOINT || 'localhost',
+                    port: parseInt(process.env.MINIO_PORT || '9000'),
+                    useSSL: process.env.MINIO_USE_SSL === 'true',
+                    accessKey: process.env.MINIO_ACCESS_KEY || 'minioadmin',
+                    secretKey: process.env.MINIO_SECRET_KEY || 'minioadmin',
+                    bucket: process.env.MINIO_BUCKET || 'media-dev'
+                });
+            case 'spaces':
+                return new spaces_1.SpacesProvider({
+                    endpoint: process.env.DO_SPACES_ENDPOINT || 'nyc3.digitaloceanspaces.com',
+                    accessKeyId: process.env.DO_SPACES_KEY,
+                    secretAccessKey: process.env.DO_SPACES_SECRET,
+                    bucket: process.env.DO_SPACES_BUCKET
+                });
+            default:
+                throw new server_1.BadRequestError('UnknownStorageProvider');
+        }
+    }
+}
+exports.StorageFactory = StorageFactory;

package/build/storage/interfaces/MediaConfiguration.d.ts

@@ -0,0 +1,23 @@
+export interface MediaConfiguration {
+    maxPhotoSizeMB: number;
+    maxVideoSizeMB: number;
+    allowedImageFormats: string[];
+    allowedVideoFormats: string[];
+    imageQualities: {
+        thumbnail: {
+            width: number;
+            height: number;
+            quality: number;
+        };
+        medium: {
+            width: number;
+            height: number;
+            quality: number;
+        };
+        large: {
+            width: number;
+            height: number;
+            quality: number;
+        };
+    };
+}

package/build/storage/interfaces/MediaConfiguration.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/storage/providers/minio.d.ts

@@ -0,0 +1,19 @@
+import { StorageProvider, UploadResult, MediaMetadata, ListFilters } from '../types';
+export declare class MinioProvider implements StorageProvider {
+    private client;
+    private bucket;
+    constructor(config: {
+        endPoint: string;
+        port: number;
+        useSSL: boolean;
+        accessKey: string;
+        secretKey: string;
+        bucket: string;
+    });
+    private ensureBucket;
+    upload(file: Buffer, path: string): Promise<UploadResult>;
+    delete(id: string): Promise<boolean>;
+    get(id: string): Promise<MediaMetadata | null>;
+    list(filters: ListFilters): Promise<MediaMetadata[]>;
+    private buildPrefix;
+}

package/build/storage/providers/minio.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinioProvider = void 0;
+// src/storage/providers/minio.ts
+const Minio = __importStar(require("minio"));
+class MinioProvider {
+    constructor(config) {
+        this.client = new Minio.Client({
+            endPoint: config.endPoint,
+            port: config.port,
+            useSSL: config.useSSL,
+            accessKey: config.accessKey,
+            secretKey: config.secretKey
+        });
+        this.bucket = config.bucket;
+        this.ensureBucket();
+    }
+    ensureBucket() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exists = yield this.client.bucketExists(this.bucket);
+            if (!exists) {
+                yield this.client.makeBucket(this.bucket, 'us-east-1');
+            }
+        });
+    }
+    upload(file, path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = path;
+            yield this.client.putObject(this.bucket, path, file, file.length);
+            const url = `${process.env.STORAGE_PUBLIC_URL}/${this.bucket}/${path}`;
+            return {
+                id,
+                metadata: {
+                    url,
+                    size: file.length,
+                    type: 'image/jpeg', // Você pode detectar isso melhor
+                    uploadedAt: new Date()
+                }
+            };
+        });
+    }
+    delete(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.client.removeObject(this.bucket, id);
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    }
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const stat = yield this.client.statObject(this.bucket, id);
+                const url = `${process.env.STORAGE_PUBLIC_URL}/${this.bucket}/${id}`;
+                return {
+                    url,
+                    size: stat.size,
+                    type: stat.metaData['content-type'] || 'application/octet-stream',
+                    uploadedAt: stat.lastModified
+                };
+            }
+            catch (_a) {
+                return null;
+            }
+        });
+    }
+    list(filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prefix = this.buildPrefix(filters);
+            const stream = this.client.listObjectsV2(this.bucket, prefix, true);
+            const results = [];
+            return new Promise((resolve, reject) => {
+                stream.on('data', obj => {
+                    if (obj.name) {
+                        results.push({
+                            url: `${process.env.STORAGE_PUBLIC_URL}/${this.bucket}/${obj.name}`,
+                            size: obj.size,
+                            type: 'application/octet-stream',
+                            uploadedAt: obj.lastModified
+                        });
+                    }
+                });
+                stream.on('error', reject);
+                stream.on('end', () => resolve(results));
+            });
+        });
+    }
+    buildPrefix(filters) {
+        const parts = [filters.tenant];
+        if (filters.userId)
+            parts.push('users', filters.userId);
+        if (filters.targetId)
+            parts.push('targets', filters.targetId);
+        if (filters.type)
+            parts.push(filters.type);
+        return parts.join('/');
+    }
+}
+exports.MinioProvider = MinioProvider;

package/build/storage/providers/spaces.d.ts

@@ -0,0 +1,17 @@
+import { StorageProvider, UploadResult, MediaMetadata, ListFilters } from '../types';
+export declare class SpacesProvider implements StorageProvider {
+    private s3;
+    private bucket;
+    constructor(config: {
+        endpoint: string;
+        accessKeyId: string;
+        secretAccessKey: string;
+        bucket: string;
+    });
+    upload(file: Buffer, path: string): Promise<UploadResult>;
+    delete(id: string): Promise<boolean>;
+    get(id: string): Promise<MediaMetadata | null>;
+    list(filters: ListFilters): Promise<MediaMetadata[]>;
+    private detectContentType;
+    private buildPrefix;
+}

package/build/storage/providers/spaces.js

@@ -0,0 +1,128 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpacesProvider = void 0;
+// src/storage/providers/minio.ts
+// DIGITAL OCEAN SPACES
+const aws_sdk_1 = __importDefault(require("aws-sdk"));
+class SpacesProvider {
+    constructor(config) {
+        this.s3 = new aws_sdk_1.default.S3({
+            endpoint: new aws_sdk_1.default.Endpoint(config.endpoint),
+            accessKeyId: config.accessKeyId,
+            secretAccessKey: config.secretAccessKey
+        });
+        this.bucket = config.bucket;
+    }
+    upload(file, path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = {
+                Bucket: this.bucket,
+                Key: path,
+                Body: file,
+                ACL: 'public-read',
+                ContentType: this.detectContentType(path)
+            };
+            const result = yield this.s3.upload(params).promise();
+            return {
+                id: path,
+                metadata: {
+                    url: result.Location,
+                    size: file.length,
+                    type: params.ContentType,
+                    uploadedAt: new Date()
+                }
+            };
+        });
+    }
+    delete(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.s3
+                    .deleteObject({
+                    Bucket: this.bucket,
+                    Key: id
+                })
+                    .promise();
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    }
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const head = yield this.s3
+                    .headObject({
+                    Bucket: this.bucket,
+                    Key: id
+                })
+                    .promise();
+                return {
+                    url: `https://${this.bucket}.${this.s3.endpoint.hostname}/${id}`,
+                    size: head.ContentLength || 0,
+                    type: head.ContentType || 'application/octet-stream',
+                    uploadedAt: head.LastModified || new Date()
+                };
+            }
+            catch (_a) {
+                return null;
+            }
+        });
+    }
+    list(filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prefix = this.buildPrefix(filters);
+            const params = {
+                Bucket: this.bucket,
+                Prefix: prefix,
+                MaxKeys: filters.limit || 1000
+            };
+            const result = yield this.s3.listObjectsV2(params).promise();
+            return (result.Contents || []).map(obj => ({
+                url: `https://${this.bucket}.${this.s3.endpoint.hostname}/${obj.Key}`,
+                size: obj.Size || 0,
+                type: 'application/octet-stream',
+                uploadedAt: obj.LastModified || new Date()
+            }));
+        });
+    }
+    detectContentType(path) {
+        var _a;
+        const ext = (_a = path.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        const types = {
+            jpg: 'image/jpeg',
+            jpeg: 'image/jpeg',
+            png: 'image/png',
+            webp: 'image/webp',
+            mp4: 'video/mp4',
+            webm: 'video/webm',
+            mov: 'video/quicktime'
+        };
+        return types[ext || ''] || 'application/octet-stream';
+    }
+    buildPrefix(filters) {
+        const parts = [filters.tenant];
+        if (filters.userId)
+            parts.push('users', filters.userId);
+        if (filters.targetId)
+            parts.push('targets', filters.targetId);
+        if (filters.type)
+            parts.push(filters.type);
+        return parts.join('/');
+    }
+}
+exports.SpacesProvider = SpacesProvider;

package/build/storage/services/storageService.d.ts

@@ -0,0 +1,11 @@
+import { StorageProvider, UploadOptions, UploadResult } from '../types';
+export declare class StorageService {
+    private provider;
+    constructor(provider: StorageProvider);
+    uploadImage(file: Buffer, filename: string, options: UploadOptions): Promise<UploadResult>;
+    uploadVideo(file: Buffer, filename: string, options: UploadOptions): Promise<UploadResult>;
+    private processImage;
+    private generatePath;
+    private getVideoMetadata;
+    private generateVideoThumbnail;
+}

package/build/storage/services/storageService.js

@@ -0,0 +1,156 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageService = void 0;
+// src/storage/services/storageService.ts
+const sharp_1 = __importDefault(require("sharp"));
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+const fs_1 = require("fs"); // Importar promises do fs
+const uuid_1 = require("uuid");
+const TenantDataService_1 = require("../../services/TenantDataService");
+const badRequestError_1 = require("src/errors/badRequestError");
+class StorageService {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    uploadImage(file, filename, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tenantData = TenantDataService_1.TenantDataService.getTenantData(options.tenant);
+            const config = tenantData.MEDIA_CONFIG;
+            // Validar tamanho
+            const sizeMB = file.length / (1024 * 1024);
+            if (sizeMB > config.maxPhotoSizeMB) {
+                throw new badRequestError_1.BadRequestError('ImageSizeExceeds');
+            }
+            // Validar formato
+            const metadata = yield (0, sharp_1.default)(file).metadata();
+            const format = metadata.format;
+            if (!format || !config.allowedImageFormats.includes(format)) {
+                throw new badRequestError_1.BadRequestError('InvalidImageFormat');
+            }
+            // Processar imagem - criar versões otimizadas
+            const versions = yield this.processImage(file, config);
+            // Upload de cada versão
+            const uploadPromises = Object.entries(versions).map(([size, buffer]) => {
+                const path = this.generatePath(options, filename, size);
+                return this.provider.upload(buffer, path, options);
+            });
+            const results = yield Promise.all(uploadPromises);
+            // Retornar a versão large como principal, com thumbnail
+            const mainResult = results.find(r => r.id.includes('large'));
+            const thumbResult = results.find(r => r.id.includes('thumbnail'));
+            return Object.assign(Object.assign({}, mainResult), { metadata: Object.assign(Object.assign({}, mainResult.metadata), { thumbnailUrl: thumbResult === null || thumbResult === void 0 ? void 0 : thumbResult.metadata.url }) });
+        });
+    }
+    uploadVideo(file, filename, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tenantData = TenantDataService_1.TenantDataService.getTenantData(options.tenant);
+            const config = tenantData.MEDIA_CONFIG;
+            // Validar tamanho
+            const sizeMB = file.length / (1024 * 1024);
+            if (sizeMB > config.maxVideoSizeMB) {
+                throw new badRequestError_1.BadRequestError('VideoSizeExceeds');
+            }
+            // Salvar temporariamente para processar com ffmpeg
+            const tempPath = `/tmp/${(0, uuid_1.v4)()}-${filename}`;
+            yield fs_1.promises.writeFile(tempPath, file);
+            try {
+                // Obter metadados do vídeo
+                const metadata = yield this.getVideoMetadata(tempPath);
+                // Gerar thumbnail se solicitado
+                let thumbnailUrl;
+                if (options.generateThumbnail) {
+                    const thumbnail = yield this.generateVideoThumbnail(tempPath);
+                    const thumbPath = this.generatePath(options, filename, 'thumbnail');
+                    const thumbResult = yield this.provider.upload(thumbnail, thumbPath, options);
+                    thumbnailUrl = thumbResult.metadata.url;
+                }
+                // Upload do vídeo
+                const videoPath = this.generatePath(options, filename, 'original');
+                const result = yield this.provider.upload(file, videoPath, options);
+                return Object.assign(Object.assign({}, result), { metadata: Object.assign(Object.assign(Object.assign({}, result.metadata), metadata), { thumbnailUrl }) });
+            }
+            finally {
+                // Limpar arquivo temporário
+                yield fs_1.promises.unlink(tempPath).catch(() => { });
+            }
+        });
+    }
+    processImage(file, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const versions = {};
+            for (const [size, settings] of Object.entries(config.imageQualities)) {
+                versions[size] = yield (0, sharp_1.default)(file)
+                    .resize(settings.width, settings.height, {
+                    fit: 'inside',
+                    withoutEnlargement: true
+                })
+                    .jpeg({ quality: settings.quality })
+                    .toBuffer();
+            }
+            return versions;
+        });
+    }
+    generatePath(options, filename, variant) {
+        const parts = [options.tenant]; // Declarar como array de strings
+        if (options.userId) {
+            parts.push('users', options.userId);
+        }
+        else if (options.targetId) {
+            parts.push('targets', options.targetId);
+        }
+        parts.push(options.type);
+        parts.push(variant);
+        parts.push(`${(0, uuid_1.v4)()}-${filename}`);
+        return parts.join('/');
+    }
+    getVideoMetadata(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                fluent_ffmpeg_1.default.ffprobe(path, (err, metadata) => {
+                    if (err)
+                        reject(err);
+                    else {
+                        const video = metadata.streams.find(s => s.codec_type === 'video');
+                        resolve({
+                            duration: metadata.format.duration,
+                            width: video === null || video === void 0 ? void 0 : video.width,
+                            height: video === null || video === void 0 ? void 0 : video.height
+                        });
+                    }
+                });
+            });
+        });
+    }
+    generateVideoThumbnail(videoPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const outputPath = `/tmp/thumb-${(0, uuid_1.v4)()}.jpg`;
+            return new Promise((resolve, reject) => {
+                (0, fluent_ffmpeg_1.default)(videoPath)
+                    .screenshots({
+                    timestamps: ['50%'],
+                    filename: outputPath,
+                    size: '320x240'
+                })
+                    .on('end', () => __awaiter(this, void 0, void 0, function* () {
+                    const buffer = yield fs_1.promises.readFile(outputPath);
+                    yield fs_1.promises.unlink(outputPath).catch(() => { });
+                    resolve(buffer);
+                }))
+                    .on('error', reject);
+            });
+        });
+    }
+}
+exports.StorageService = StorageService;

package/build/storage/types/index.d.ts

@@ -0,0 +1,37 @@
+import { Tenant } from '../../types/tenant';
+export type MediaType = 'photo' | 'video';
+export interface UploadOptions {
+    tenant: Tenant;
+    userId?: string;
+    targetId?: string;
+    type: MediaType;
+    generateThumbnail?: boolean;
+}
+export interface MediaMetadata {
+    url: string;
+    thumbnailUrl?: string;
+    size: number;
+    type: string;
+    width?: number;
+    height?: number;
+    duration?: number;
+    uploadedAt: Date;
+}
+export interface UploadResult {
+    id: string;
+    metadata: MediaMetadata;
+}
+export interface StorageProvider {
+    upload(file: Buffer, filename: string, options: UploadOptions): Promise<UploadResult>;
+    delete(id: string): Promise<boolean>;
+    get(id: string): Promise<MediaMetadata | null>;
+    list(filters: ListFilters): Promise<MediaMetadata[]>;
+}
+export interface ListFilters {
+    tenant: Tenant;
+    userId?: string;
+    targetId?: string;
+    type?: MediaType;
+    limit?: number;
+    offset?: number;
+}

package/build/storage/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrcb/cb-common",
-  "version": "1.0.383",
+  "version": "1.0.385",
   "description": "Common resources between services",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -28,6 +28,8 @@
   "license": "ISC",
   "devDependencies": {
     "@types/express-rate-limit": "^5.1.3",
+    "@types/fluent-ffmpeg": "^2.1.27",
+    "@types/multer": "^2.0.0",
     "@typescript-eslint/eslint-plugin": "^8.29.1",
     "@typescript-eslint/parser": "^8.29.1",
     "eslint": "^9.24.0",
@@ -42,15 +44,20 @@
     "@types/express": "^4.17.21",
     "@types/jsonwebtoken": "^9.0.6",
     "@types/supertest": "^6.0.2",
+    "aws-sdk": "^2.1692.0",
     "cookie-session": "^2.1.0",
     "express": "^4.21.0",
     "express-rate-limit": "^7.5.0",
     "express-validator": "^7.1.0",
+    "fluent-ffmpeg": "^2.1.3",
     "ioredis": "^5.6.1",
     "jsonwebtoken": "^9.0.2",
+    "minio": "^8.0.5",
     "mongoose": "^8.6.3",
+    "multer": "^2.0.2",
     "node-nats-streaming": "^0.3.2",
     "rate-limit-redis": "^4.2.0",
+    "sharp": "^0.34.3",
     "uuid": "^11.1.0"
   }
 }