@devstroupe/devkit-nest 1.0.0 → 1.1.0

package/dist/realtime/realtime.gateway.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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var RealtimeGateway_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeGateway = void 0;
+const websockets_1 = require("@nestjs/websockets");
+const socket_io_1 = require("socket.io");
+const common_1 = require("@nestjs/common");
+const jwt = __importStar(require("jsonwebtoken"));
+let RealtimeGateway = RealtimeGateway_1 = class RealtimeGateway {
+    server;
+    logger = new common_1.Logger(RealtimeGateway_1.name);
+    connectedUsers = new Map();
+    handleConnection(client) {
+        try {
+            const token = client.handshake.auth?.token || client.handshake.headers?.authorization?.split(' ')[1];
+            if (!token) {
+                this.logger.warn(`Conexão rejeitada: Token JWT ausente.`);
+                client.disconnect();
+                return;
+            }
+            const secret = process.env.JWT_SECRET || 'devstroupe-secret-key-12345';
+            const decoded = jwt.verify(token, secret);
+            client.data = {
+                userId: decoded.sub,
+                email: decoded.email,
+                role: decoded.role,
+                tenantId: decoded.tenantId,
+                permissions: decoded.permissions || [],
+            };
+            // Registrar o socket associado ao usuário
+            this.connectedUsers.set(String(decoded.sub), client);
+            // Entrar nas salas padrão do usuário (sala própria, sala do perfil e do tenant)
+            client.join(`user:${decoded.sub}`);
+            if (decoded.role) {
+                client.join(`role:${decoded.role}`);
+            }
+            if (decoded.tenantId) {
+                client.join(`tenant:${decoded.tenantId}`);
+            }
+            this.logger.log(`Cliente conectado: User ID ${decoded.sub} (Socket ${client.id})`);
+        }
+        catch (err) {
+            this.logger.warn(`Conexão rejeitada: Token JWT inválido.`);
+            client.disconnect();
+        }
+    }
+    handleDisconnect(client) {
+        if (client.data?.userId) {
+            this.connectedUsers.delete(String(client.data.userId));
+            this.logger.log(`Cliente desconectado: User ID ${client.data.userId} (Socket ${client.id})`);
+        }
+    }
+    // Notifica uma mudança de entidade para todos os inscritos (respeitando o tenant se houver)
+    emitEntityChange(entityName, action, data, tenantId) {
+        const payload = { entity: entityName, action, data };
+        if (tenantId) {
+            this.server.to(`tenant:${tenantId}`).emit('entity_changed', payload);
+        }
+        else {
+            this.server.emit('entity_changed', payload);
+        }
+    }
+    handleSubscribeEntity(entity, client) {
+        client.join(`entity:${entity}`);
+        return { event: 'subscribed', data: entity };
+    }
+};
+exports.RealtimeGateway = RealtimeGateway;
+__decorate([
+    (0, websockets_1.WebSocketServer)(),
+    __metadata("design:type", socket_io_1.Server)
+], RealtimeGateway.prototype, "server", void 0);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('subscribe_entity'),
+    __param(0, (0, websockets_1.MessageBody)()),
+    __param(1, (0, websockets_1.ConnectedSocket)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, socket_io_1.Socket]),
+    __metadata("design:returntype", void 0)
+], RealtimeGateway.prototype, "handleSubscribeEntity", null);
+exports.RealtimeGateway = RealtimeGateway = RealtimeGateway_1 = __decorate([
+    (0, websockets_1.WebSocketGateway)({
+        cors: {
+            origin: '*',
+        },
+        transports: ['websocket'],
+    }),
+    (0, common_1.Injectable)()
+], RealtimeGateway);

package/dist/realtime/realtime.module.d.ts

@@ -0,0 +1,2 @@
+export declare class RealtimeModule {
+}

package/dist/realtime/realtime.module.js

@@ -0,0 +1,22 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeModule = void 0;
+const common_1 = require("@nestjs/common");
+const realtime_gateway_1 = require("./realtime.gateway");
+const realtime_service_1 = require("./realtime.service");
+let RealtimeModule = class RealtimeModule {
+};
+exports.RealtimeModule = RealtimeModule;
+exports.RealtimeModule = RealtimeModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        providers: [realtime_gateway_1.RealtimeGateway, realtime_service_1.RealtimeService],
+        exports: [realtime_service_1.RealtimeService],
+    })
+], RealtimeModule);

package/dist/realtime/realtime.service.d.ts

@@ -0,0 +1,10 @@
+import { RealtimeGateway } from './realtime.gateway';
+export declare class RealtimeService {
+    private readonly gateway;
+    constructor(gateway: RealtimeGateway);
+    /**
+     * Publica uma mudança de entidade no WebSocket.
+     * Se chamado a partir de um Controller, isso garante que o evento seja publicado pós-commit da transação.
+     */
+    publishEntityChange(entityName: string, action: 'create' | 'update' | 'delete', data: any, tenantId?: string): void;
+}

package/dist/realtime/realtime.service.js

@@ -0,0 +1,32 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeService = void 0;
+const common_1 = require("@nestjs/common");
+const realtime_gateway_1 = require("./realtime.gateway");
+let RealtimeService = class RealtimeService {
+    gateway;
+    constructor(gateway) {
+        this.gateway = gateway;
+    }
+    /**
+     * Publica uma mudança de entidade no WebSocket.
+     * Se chamado a partir de um Controller, isso garante que o evento seja publicado pós-commit da transação.
+     */
+    publishEntityChange(entityName, action, data, tenantId) {
+        this.gateway.emitEntityChange(entityName, action, data, tenantId);
+    }
+};
+exports.RealtimeService = RealtimeService;
+exports.RealtimeService = RealtimeService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [realtime_gateway_1.RealtimeGateway])
+], RealtimeService);

package/dist/storage/drivers/local.storage.d.ts

@@ -0,0 +1,11 @@
+import { StorageService } from '../storage.service';
+import { StorageFile, UploadOptions, UploadResult, LocalStorageOptions } from '../storage.types';
+export declare class LocalStorageService implements StorageService {
+    private readonly storagePath;
+    private readonly baseUrl;
+    constructor(options: LocalStorageOptions);
+    upload(file: StorageFile, options?: UploadOptions): Promise<UploadResult>;
+    delete(key: string): Promise<void>;
+    getUrl(key: string): Promise<string>;
+    getSignedUrl(key: string, expiresIn?: number): Promise<string>;
+}

package/dist/storage/drivers/local.storage.js

@@ -0,0 +1,114 @@
+"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStorageService = void 0;
+const common_1 = require("@nestjs/common");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+let LocalStorageService = class LocalStorageService {
+    storagePath;
+    baseUrl;
+    constructor(options) {
+        this.storagePath = path.resolve(options.storagePath);
+        this.baseUrl = options.baseUrl || '';
+    }
+    async upload(file, options) {
+        // 1. Sanitizar a extensão do arquivo
+        const origExt = path.extname(file.originalname);
+        const sanitizedExt = origExt.replace(/[^a-zA-Z0-9.]/g, '');
+        // 2. Determinar nome do arquivo (UUID v4 por padrão)
+        const filename = options?.filename
+            ? options.filename.replace(/[^a-zA-Z0-9._-]/g, '')
+            : `${crypto.randomUUID()}${sanitizedExt}`;
+        // 3. Resolver caminho da subpasta e mitigar Directory Traversal
+        const subPath = options?.path ? path.normalize(options.path).replace(/^(\.\.(\/|\\|$))+/, '') : '';
+        const targetDir = path.resolve(this.storagePath, subPath);
+        // Adicionamos a barra final para segurança máxima de limite de diretório
+        const rootPrefix = this.storagePath.endsWith(path.sep) ? this.storagePath : this.storagePath + path.sep;
+        if (!targetDir.startsWith(rootPrefix) && targetDir !== this.storagePath) {
+            throw new Error('Directory traversal attempt detected');
+        }
+        const targetFile = path.resolve(targetDir, filename);
+        if (!targetFile.startsWith(rootPrefix)) {
+            throw new Error('File path resolves outside of storage boundary');
+        }
+        // 4. Garantir existência da pasta e escrever o arquivo
+        await fs.mkdir(targetDir, { recursive: true });
+        await fs.writeFile(targetFile, file.buffer);
+        const relativeKey = path.relative(this.storagePath, targetFile).replace(/\\/g, '/');
+        const url = this.baseUrl ? `${this.baseUrl.replace(/\/$/, '')}/${relativeKey}` : relativeKey;
+        return {
+            key: relativeKey,
+            url,
+            size: file.size,
+            mimetype: file.mimetype,
+        };
+    }
+    async delete(key) {
+        const targetFile = path.resolve(this.storagePath, key);
+        const rootPrefix = this.storagePath.endsWith(path.sep) ? this.storagePath : this.storagePath + path.sep;
+        if (!targetFile.startsWith(rootPrefix)) {
+            throw new Error('Directory traversal attempt detected on deletion');
+        }
+        try {
+            await fs.unlink(targetFile);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT')
+                throw err;
+        }
+    }
+    async getUrl(key) {
+        return this.baseUrl ? `${this.baseUrl.replace(/\/$/, '')}/${key}` : key;
+    }
+    async getSignedUrl(key, expiresIn) {
+        return this.getUrl(key);
+    }
+};
+exports.LocalStorageService = LocalStorageService;
+exports.LocalStorageService = LocalStorageService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object])
+], LocalStorageService);

package/dist/storage/drivers/local.storage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/storage/drivers/local.storage.test.js

@@ -0,0 +1,106 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const assert = __importStar(require("node:assert"));
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const local_storage_1 = require("./local.storage");
+(0, node_test_1.describe)('LocalStorageService', () => {
+    const tmpDir = path.resolve(__dirname, '../../../../tmp-storage-test');
+    let service;
+    (0, node_test_1.before)(async () => {
+        await fs.mkdir(tmpDir, { recursive: true });
+        service = new local_storage_1.LocalStorageService({
+            storagePath: tmpDir,
+            baseUrl: 'http://localhost:3000/files',
+        });
+    });
+    (0, node_test_1.after)(async () => {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+    (0, node_test_1.test)('deve realizar upload de arquivo com sucesso', async () => {
+        const file = {
+            originalname: 'test-image.png',
+            mimetype: 'image/png',
+            buffer: Buffer.from('dummy content'),
+            size: 13,
+        };
+        const result = await service.upload(file, { path: 'images' });
+        assert.ok(result.key);
+        assert.ok(result.url.startsWith('http://localhost:3000/files/images/'));
+        assert.strictEqual(result.size, 13);
+        assert.strictEqual(result.mimetype, 'image/png');
+        // Verificar se o arquivo realmente foi criado no sistema de arquivos
+        const filePath = path.resolve(tmpDir, result.key);
+        const content = await fs.readFile(filePath);
+        assert.strictEqual(content.toString(), 'dummy content');
+    });
+    (0, node_test_1.test)('deve deletar arquivo com sucesso', async () => {
+        const file = {
+            originalname: 'to-delete.txt',
+            mimetype: 'text/plain',
+            buffer: Buffer.from('delete me'),
+            size: 9,
+        };
+        const uploadResult = await service.upload(file);
+        const filePath = path.resolve(tmpDir, uploadResult.key);
+        // Verificar que existe
+        await fs.access(filePath);
+        // Deletar
+        await service.delete(uploadResult.key);
+        // Verificar que não existe mais
+        await assert.rejects(async () => {
+            await fs.access(filePath);
+        });
+    });
+    (0, node_test_1.test)('deve rejeitar upload com Directory Traversal em options.path', async () => {
+        const file = {
+            originalname: 'hacker.txt',
+            mimetype: 'text/plain',
+            buffer: Buffer.from('malicious'),
+            size: 9,
+        };
+        // Tenta gravar fora da raiz
+        await assert.rejects(async () => {
+            await service.upload(file, { path: '../../' });
+        }, /Directory traversal attempt detected/);
+    });
+    (0, node_test_1.test)('deve rejeitar exclusão com Directory Traversal em key', async () => {
+        await assert.rejects(async () => {
+            await service.delete('../../../etc/passwd');
+        }, /Directory traversal attempt detected/);
+    });
+});

package/dist/storage/drivers/s3.storage.d.ts

@@ -0,0 +1,12 @@
+import { StorageService } from '../storage.service';
+import { StorageFile, UploadOptions, UploadResult, S3StorageOptions, R2StorageOptions } from '../storage.types';
+export declare class S3StorageService implements StorageService {
+    private readonly client;
+    private readonly bucket;
+    private readonly publicUrl?;
+    constructor(options: S3StorageOptions | R2StorageOptions, isR2?: boolean);
+    upload(file: StorageFile, options?: UploadOptions): Promise<UploadResult>;
+    delete(key: string): Promise<void>;
+    getUrl(key: string): Promise<string>;
+    getSignedUrl(key: string, expiresIn?: number): Promise<string>;
+}

package/dist/storage/drivers/s3.storage.js

@@ -0,0 +1,138 @@
+"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3StorageService = void 0;
+const common_1 = require("@nestjs/common");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+const crypto = __importStar(require("crypto"));
+const path = __importStar(require("path"));
+let S3StorageService = class S3StorageService {
+    client;
+    bucket;
+    publicUrl;
+    constructor(options, isR2 = false) {
+        this.bucket = options.bucket;
+        if (isR2) {
+            const r2Opts = options;
+            this.publicUrl = r2Opts.publicUrl;
+            this.client = new client_s3_1.S3Client({
+                endpoint: `https://${r2Opts.accountId}.r2.cloudflarestorage.com`,
+                region: 'auto',
+                credentials: {
+                    accessKeyId: r2Opts.accessKeyId,
+                    secretAccessKey: r2Opts.secretAccessKey,
+                },
+                forcePathStyle: true,
+            });
+        }
+        else {
+            const s3Opts = options;
+            this.client = new client_s3_1.S3Client({
+                region: s3Opts.region || 'us-east-1',
+                credentials: {
+                    accessKeyId: s3Opts.accessKeyId,
+                    secretAccessKey: s3Opts.secretAccessKey,
+                },
+                endpoint: s3Opts.endpoint,
+                forcePathStyle: s3Opts.forcePathStyle,
+            });
+        }
+    }
+    async upload(file, options) {
+        const origExt = path.extname(file.originalname);
+        const sanitizedExt = origExt.replace(/[^a-zA-Z0-9.]/g, '');
+        const filename = options?.filename
+            ? options.filename.replace(/[^a-zA-Z0-9._-]/g, '')
+            : `${crypto.randomUUID()}${sanitizedExt}`;
+        const subPath = options?.path ? options.path.replace(/^\/+|\/+$/g, '') : '';
+        const key = subPath ? `${subPath}/${filename}` : filename;
+        await this.client.send(new client_s3_1.PutObjectCommand({
+            Bucket: this.bucket,
+            Key: key,
+            Body: file.buffer,
+            ContentType: file.mimetype,
+        }));
+        const url = await this.getUrl(key);
+        return {
+            key,
+            url,
+            size: file.size,
+            mimetype: file.mimetype,
+        };
+    }
+    async delete(key) {
+        await this.client.send(new client_s3_1.DeleteObjectCommand({
+            Bucket: this.bucket,
+            Key: key,
+        }));
+    }
+    async getUrl(key) {
+        if (this.publicUrl) {
+            return `${this.publicUrl.replace(/\/$/, '')}/${key}`;
+        }
+        const endpointFn = this.client.config.endpoint;
+        if (endpointFn && typeof endpointFn === 'function') {
+            const endpoint = await endpointFn();
+            if (endpoint) {
+                const portStr = endpoint.port ? `:${endpoint.port}` : '';
+                const baseHost = `${endpoint.protocol}//${endpoint.hostname}${portStr}`;
+                return `${baseHost}/${this.bucket}/${key}`;
+            }
+        }
+        return `https://${this.bucket}.s3.amazonaws.com/${key}`;
+    }
+    async getSignedUrl(key, expiresIn = 3600) {
+        const command = new client_s3_1.GetObjectCommand({
+            Bucket: this.bucket,
+            Key: key,
+        });
+        return (0, s3_request_presigner_1.getSignedUrl)(this.client, command, { expiresIn });
+    }
+};
+exports.S3StorageService = S3StorageService;
+exports.S3StorageService = S3StorageService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object, Boolean])
+], S3StorageService);

package/dist/storage/index.d.ts

@@ -0,0 +1,5 @@
+export * from './storage.types';
+export * from './storage.service';
+export * from './storage.module';
+export * from './drivers/local.storage';
+export * from './drivers/s3.storage';

package/dist/storage/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./storage.types"), exports);
+__exportStar(require("./storage.service"), exports);
+__exportStar(require("./storage.module"), exports);
+__exportStar(require("./drivers/local.storage"), exports);
+__exportStar(require("./drivers/s3.storage"), exports);

package/dist/storage/storage.module.d.ts

@@ -0,0 +1,11 @@
+import { DynamicModule } from '@nestjs/common';
+import { StorageOptions } from './storage.types';
+export declare const STORAGE_OPTIONS_TOKEN = "STORAGE_OPTIONS_TOKEN";
+export declare class StorageModule {
+    static register(options: StorageOptions): DynamicModule;
+    static registerAsync(options: {
+        useFactory: (...args: any[]) => Promise<StorageOptions> | StorageOptions;
+        inject?: any[];
+    }): DynamicModule;
+    private static createServiceInstance;
+}