@devstroupe/devkit-nest 1.0.0 → 1.1.0

package/dist/storage/storage.module.js

@@ -0,0 +1,81 @@
+"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 StorageModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageModule = exports.STORAGE_OPTIONS_TOKEN = void 0;
+const common_1 = require("@nestjs/common");
+const storage_service_1 = require("./storage.service");
+const local_storage_1 = require("./drivers/local.storage");
+const s3_storage_1 = require("./drivers/s3.storage");
+exports.STORAGE_OPTIONS_TOKEN = 'STORAGE_OPTIONS_TOKEN';
+let StorageModule = StorageModule_1 = class StorageModule {
+    static register(options) {
+        const storageServiceProvider = {
+            provide: storage_service_1.StorageService,
+            useFactory: () => {
+                return this.createServiceInstance(options);
+            },
+        };
+        return {
+            module: StorageModule_1,
+            providers: [
+                { provide: exports.STORAGE_OPTIONS_TOKEN, useValue: options },
+                storageServiceProvider,
+            ],
+            exports: [storage_service_1.StorageService],
+        };
+    }
+    static registerAsync(options) {
+        const storageServiceProvider = {
+            provide: storage_service_1.StorageService,
+            useFactory: async (opts) => {
+                return this.createServiceInstance(opts);
+            },
+            inject: [exports.STORAGE_OPTIONS_TOKEN],
+        };
+        return {
+            module: StorageModule_1,
+            imports: [],
+            providers: [
+                {
+                    provide: exports.STORAGE_OPTIONS_TOKEN,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                },
+                storageServiceProvider,
+            ],
+            exports: [storage_service_1.StorageService],
+        };
+    }
+    static createServiceInstance(options) {
+        switch (options.driver) {
+            case 'local':
+                if (!options.local) {
+                    throw new Error('Configuração de "local" não fornecida para o driver local.');
+                }
+                return new local_storage_1.LocalStorageService(options.local);
+            case 's3':
+                if (!options.s3) {
+                    throw new Error('Configuração de "s3" não fornecida para o driver s3.');
+                }
+                return new s3_storage_1.S3StorageService(options.s3, false);
+            case 'r2':
+                if (!options.r2) {
+                    throw new Error('Configuração de "r2" não fornecida para o driver r2.');
+                }
+                return new s3_storage_1.S3StorageService(options.r2, true);
+            default:
+                throw new Error(`Driver de storage não suportado: ${options.driver}`);
+        }
+    }
+};
+exports.StorageModule = StorageModule;
+exports.StorageModule = StorageModule = StorageModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], StorageModule);

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

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

package/dist/storage/storage.module.test.js

@@ -0,0 +1,113 @@
+"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 storage_module_1 = require("./storage.module");
+const storage_service_1 = require("./storage.service");
+const local_storage_1 = require("./drivers/local.storage");
+const s3_storage_1 = require("./drivers/s3.storage");
+(0, node_test_1.describe)('StorageModule', () => {
+    (0, node_test_1.test)('deve instanciar LocalStorageService quando configurado driver local', () => {
+        const dynamicModule = storage_module_1.StorageModule.register({
+            driver: 'local',
+            local: {
+                storagePath: './tmp-test-module',
+            },
+        });
+        assert.ok(dynamicModule.providers);
+        const serviceProvider = dynamicModule.exports?.find(e => e === storage_service_1.StorageService);
+        assert.ok(serviceProvider);
+        const factoryProvider = dynamicModule.providers?.find((p) => p.provide === storage_service_1.StorageService);
+        assert.ok(factoryProvider);
+        assert.ok(factoryProvider.useFactory);
+        const instance = factoryProvider.useFactory();
+        assert.ok(instance instanceof local_storage_1.LocalStorageService);
+    });
+    (0, node_test_1.test)('deve instanciar S3StorageService quando configurado driver s3', () => {
+        const dynamicModule = storage_module_1.StorageModule.register({
+            driver: 's3',
+            s3: {
+                bucket: 'test-bucket',
+                accessKeyId: 'key',
+                secretAccessKey: 'secret',
+                region: 'us-east-1',
+            },
+        });
+        const factoryProvider = dynamicModule.providers?.find((p) => p.provide === storage_service_1.StorageService);
+        assert.ok(factoryProvider);
+        const instance = factoryProvider.useFactory();
+        assert.ok(instance instanceof s3_storage_1.S3StorageService);
+    });
+    (0, node_test_1.test)('deve instanciar S3StorageService quando configurado driver r2', () => {
+        const dynamicModule = storage_module_1.StorageModule.register({
+            driver: 'r2',
+            r2: {
+                bucket: 'test-bucket',
+                accountId: 'account-id',
+                accessKeyId: 'key',
+                secretAccessKey: 'secret',
+            },
+        });
+        const factoryProvider = dynamicModule.providers?.find((p) => p.provide === storage_service_1.StorageService);
+        assert.ok(factoryProvider);
+        const instance = factoryProvider.useFactory();
+        assert.ok(instance instanceof s3_storage_1.S3StorageService);
+    });
+    (0, node_test_1.test)('deve lançar erro se configurações do driver local não forem fornecidas', () => {
+        const dynamicModule = storage_module_1.StorageModule.register({ driver: 'local' });
+        const factoryProvider = dynamicModule.providers?.find((p) => p.provide === storage_service_1.StorageService);
+        assert.ok(factoryProvider);
+        assert.throws(() => {
+            factoryProvider.useFactory();
+        }, /Configuração de "local" não fornecida/);
+    });
+    (0, node_test_1.test)('deve lançar erro se configurações do driver s3 não forem fornecidas', () => {
+        const dynamicModule = storage_module_1.StorageModule.register({ driver: 's3' });
+        const factoryProvider = dynamicModule.providers?.find((p) => p.provide === storage_service_1.StorageService);
+        assert.ok(factoryProvider);
+        assert.throws(() => {
+            factoryProvider.useFactory();
+        }, /Configuração de "s3" não fornecida/);
+    });
+    (0, node_test_1.test)('deve lançar erro se configurações do driver r2 não forem fornecidas', () => {
+        const dynamicModule = storage_module_1.StorageModule.register({ driver: 'r2' });
+        const factoryProvider = dynamicModule.providers?.find((p) => p.provide === storage_service_1.StorageService);
+        assert.ok(factoryProvider);
+        assert.throws(() => {
+            factoryProvider.useFactory();
+        }, /Configuração de "r2" não fornecida/);
+    });
+});

package/dist/storage/storage.service.d.ts

@@ -0,0 +1,7 @@
+import { StorageFile, UploadOptions, UploadResult } from './storage.types';
+export declare abstract class StorageService {
+    abstract upload(file: StorageFile, options?: UploadOptions): Promise<UploadResult>;
+    abstract delete(key: string): Promise<void>;
+    abstract getUrl(key: string): Promise<string>;
+    abstract getSignedUrl(key: string, expiresIn?: number): Promise<string>;
+}

package/dist/storage/storage.service.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageService = void 0;
+class StorageService {
+}
+exports.StorageService = StorageService;

package/dist/storage/storage.types.d.ts

@@ -0,0 +1,42 @@
+export type StorageDriver = 'local' | 's3' | 'r2';
+export interface LocalStorageOptions {
+    storagePath: string;
+    baseUrl?: string;
+}
+export interface S3StorageOptions {
+    bucket: string;
+    region?: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    endpoint?: string;
+    forcePathStyle?: boolean;
+}
+export interface R2StorageOptions {
+    bucket: string;
+    accountId: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    publicUrl?: string;
+}
+export interface StorageOptions {
+    driver: StorageDriver;
+    local?: LocalStorageOptions;
+    s3?: S3StorageOptions;
+    r2?: R2StorageOptions;
+}
+export interface StorageFile {
+    originalname: string;
+    mimetype: string;
+    buffer: Buffer;
+    size: number;
+}
+export interface UploadOptions {
+    path?: string;
+    filename?: string;
+}
+export interface UploadResult {
+    key: string;
+    url: string;
+    size: number;
+    mimetype: string;
+}

package/dist/storage/storage.types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devstroupe/devkit-nest",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "DevsTroupe Development Kit — NestJS base classes: BaseRepository, BaseCrudController and query parsers",
   "license": "MIT",
   "keywords": [
@@ -29,12 +29,18 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "@devstroupe/devkit-core": "^1.0.0"
+    "@aws-sdk/client-s3": "^3.500.0",
+    "@aws-sdk/s3-request-presigner": "^3.500.0",
+    "jsonwebtoken": "^9.0.2",
+    "@devstroupe/devkit-core": "1.1.0"
   },
   "peerDependencies": {
     "@nestjs/common": "^10.0.0 || ^11.0.0",
     "@nestjs/core": "^10.0.0 || ^11.0.0",
     "@nestjs/swagger": "^7.0.0 || ^8.0.0 || ^9.0.0 || ^10.0.0 || ^11.0.0",
+    "@nestjs/websockets": "^10.0.0 || ^11.0.0",
+    "socket.io": "^4.7.0",
+    "rxjs": "^7.0.0",
     "typeorm": "^0.3.0",
     "reflect-metadata": "^0.1.13 || ^0.2.0"
   },
@@ -42,7 +48,11 @@
     "@nestjs/common": "^10.3.8",
     "@nestjs/core": "^10.3.8",
     "@nestjs/swagger": "^7.3.1",
+    "@nestjs/websockets": "^10.3.8",
+    "@types/jsonwebtoken": "^9.0.6",
     "@types/node": "^20.11.0",
+    "rxjs": "^7.8.1",
+    "socket.io": "^4.7.5",
     "typeorm": "^0.3.17",
     "reflect-metadata": "^0.1.13",
     "typescript": "^5.4.5"