@viardex/viardex-libs 1.0.4 → 1.0.6

package/dist/logger/index.js

@@ -0,0 +1,18 @@
+"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("./logger.module"), exports);
+__exportStar(require("./logging.interceptor"), exports);

package/dist/logger/logger.module.d.ts

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

package/dist/logger/logger.module.js

@@ -0,0 +1,58 @@
+"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.LoggerModule = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const nestjs_pino_1 = require("nestjs-pino");
+let LoggerModule = class LoggerModule {
+};
+exports.LoggerModule = LoggerModule;
+exports.LoggerModule = LoggerModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        imports: [
+            nestjs_pino_1.LoggerModule.forRootAsync({
+                imports: [config_1.ConfigModule],
+                inject: [config_1.ConfigService],
+                useFactory: (configService) => {
+                    const env = configService.get('NODE_ENV', 'development');
+                    const isDevelopment = env === 'development';
+                    return {
+                        pinoHttp: {
+                            level: configService.get('LOG_LEVEL', isDevelopment ? 'debug' : 'info'),
+                            transport: isDevelopment
+                                ? {
+                                    target: 'pino-pretty',
+                                    options: {
+                                        colorize: true,
+                                        singleLine: false,
+                                        translateTime: 'SYS:standard',
+                                        ignore: 'pid,hostname',
+                                    },
+                                }
+                                : undefined,
+                            serializers: {
+                                req: (req) => ({
+                                    id: req.id,
+                                    method: req.method,
+                                    url: req.url,
+                                    remoteAddress: req.ip,
+                                }),
+                                res: (res) => ({
+                                    statusCode: res.statusCode,
+                                }),
+                            },
+                        },
+                    };
+                },
+            }),
+        ],
+        exports: [nestjs_pino_1.LoggerModule],
+    })
+], LoggerModule);

package/dist/logger/logging.interceptor.d.ts

@@ -0,0 +1,8 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { PinoLogger } from 'nestjs-pino';
+export declare class LoggingInterceptor implements NestInterceptor {
+    private readonly logger;
+    constructor(logger: PinoLogger);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+}

package/dist/logger/logging.interceptor.js

@@ -0,0 +1,66 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggingInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const nestjs_pino_1 = require("nestjs-pino");
+let LoggingInterceptor = class LoggingInterceptor {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    intercept(context, next) {
+        if (context.getType() !== 'http') {
+            return next.handle();
+        }
+        const request = context.switchToHttp().getRequest();
+        const response = context.switchToHttp().getResponse();
+        const requestId = request.requestId ?? request.id;
+        const startTime = Date.now();
+        this.logger.debug({
+            requestId,
+            method: request.method,
+            url: request.url,
+        }, 'Incoming request');
+        return next.handle().pipe((0, rxjs_1.tap)({
+            next: () => {
+                this.logger.info({
+                    requestId,
+                    method: request.method,
+                    url: request.url,
+                    statusCode: response.statusCode,
+                    duration: Date.now() - startTime,
+                }, 'Request completed');
+            },
+            error: (error) => {
+                this.logger.error({
+                    requestId,
+                    method: request.method,
+                    url: request.url,
+                    statusCode: error.status ?? 500,
+                    duration: Date.now() - startTime,
+                    error: error.message,
+                    stack: error.stack,
+                }, 'Request failed');
+            },
+        }));
+    }
+};
+exports.LoggingInterceptor = LoggingInterceptor;
+exports.LoggingInterceptor = LoggingInterceptor = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(nestjs_pino_1.PinoLogger)),
+    __metadata("design:paramtypes", [nestjs_pino_1.PinoLogger])
+], LoggingInterceptor);

package/dist/nats/dto/nats-message.dto.js

@@ -5,6 +5,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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.NatsMessageDto = void 0;
 const class_validator_1 = require("class-validator");
@@ -16,12 +19,15 @@ class NatsMessageDto {
 exports.NatsMessageDto = NatsMessageDto;
 __decorate([
     (0, class_validator_1.IsString)(),
-    (0, class_validator_1.IsNotEmpty)()
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
 ], NatsMessageDto.prototype, "pattern", void 0);
 __decorate([
-    (0, class_validator_1.IsNotEmpty)()
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", Object)
 ], NatsMessageDto.prototype, "data", void 0);
 __decorate([
     (0, class_validator_1.IsString)(),
-    (0, class_validator_1.IsOptional)()
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
 ], NatsMessageDto.prototype, "replyTo", void 0);

package/dist/rpc/index.d.ts

@@ -11,44 +11,8 @@ export interface ViardexRPCSuccess<T> {
     data?: T;
 }
 export declare class ViardexRpc {
-    /**
-     * Wraps a promise returned by an RPC request handler.
-     * @param promise - A Promise resolving to the response value.
-     * @param ctx - Optional NatsContext object.
-     * @param successMessage - Optional success message
-     */
     static handleRequest<V>(promise: Promise<V>, ctx?: NatsContext): Promise<ViardexRPCSuccess<V> | RpcException>;
-    /**
-     * Handles errors from an RPC request handler and returns a ViardexRPCError wrapped in RpcException.
-     * @param err - Error to be handled.
-     * @param ctx - A NATS Context.
-     */
     static handleRequestError(err: unknown, ctx: NatsContext): RpcException;
     private static catch;
-    /**
-     * Handles NATS request response.
-     * @param obs - An instance of an Observable.
-     * @param successMessage - Optional success message
-     */
-    static withReply<V>(obs: Observable<V>, successMessage?: string): Promise<ViardexRPCSuccess<V>>;
-}
-export declare class ViardexRpcV2 {
-    /**
-     * Wraps a promise returned by an RPC request handler.
-     * @param promise - A Promise resolving to the response value.
-     * @param ctx - Optional NatsContext object.
-     */
-    static handleRequest<V>(promise: Promise<V>, ctx?: NatsContext): Promise<ViardexRPCSuccess<V> | ViardexRPCError>;
-    /**
-     * Handles errors from an RPC request handler and returns a ViardexRPCError.
-     * @param err - Error to be handled.
-     * @param ctx - A NATS Context.
-     */
-    static handleRequestError(err: unknown, ctx: NatsContext): ViardexRPCError;
-    private static catch;
-    /**
-     * Handles NATS request response.
-     * @param obs - An instance of an Observable.
-     */
     static withReply<V>(obs: Observable<V>): Promise<ViardexRPCSuccess<V>>;
 }

package/dist/rpc/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ViardexRpcV2 = exports.ViardexRpc = void 0;
+exports.ViardexRpc = void 0;
 const common_1 = require("@nestjs/common");
 const microservices_1 = require("@nestjs/microservices");
 class ViardexRpcUtils {
@@ -21,28 +21,15 @@ class ViardexRpcUtils {
         return typeof result === 'object' && result !== null && 'error' in result;
     }
     static formatSuccessResponse(data) {
-        return {
-            data,
-        };
+        return { data };
     }
 }
 class ViardexRpc {
-    /**
-     * Wraps a promise returned by an RPC request handler.
-     * @param promise - A Promise resolving to the response value.
-     * @param ctx - Optional NatsContext object.
-     * @param successMessage - Optional success message
-     */
     static async handleRequest(promise, ctx) {
         return promise
             .then((value) => ViardexRpcUtils.formatSuccessResponse(value))
             .catch((err) => this.catch(err, ctx));
     }
-    /**
-     * Handles errors from an RPC request handler and returns a ViardexRPCError wrapped in RpcException.
-     * @param err - Error to be handled.
-     * @param ctx - A NATS Context.
-     */
     static handleRequestError(err, ctx) {
         return this.catch(err, ctx);
     }
@@ -59,63 +46,6 @@ class ViardexRpc {
         };
         return new microservices_1.RpcException(errorDetails);
     }
-    /**
-     * Handles NATS request response.
-     * @param obs - An instance of an Observable.
-     * @param successMessage - Optional success message
-     */
-    static async withReply(obs, successMessage = 'Operation successful') {
-        const result = await new Promise((resolve, reject) => {
-            obs.subscribe({
-                next: (value) => resolve(value),
-                error: (err) => reject(err instanceof Error ? err : new Error(String(err))),
-            });
-        });
-        if (ViardexRpcUtils.isErrorResponse(result)) {
-            common_1.Logger.error(result.error);
-            throw new common_1.HttpException(result.error, result.error.statusCode, {
-                cause: result.error.errors,
-            });
-        }
-        return ViardexRpcUtils.formatSuccessResponse(result);
-    }
-}
-exports.ViardexRpc = ViardexRpc;
-class ViardexRpcV2 {
-    /**
-     * Wraps a promise returned by an RPC request handler.
-     * @param promise - A Promise resolving to the response value.
-     * @param ctx - Optional NatsContext object.
-     */
-    static async handleRequest(promise, ctx) {
-        return promise
-            .then((value) => ViardexRpcUtils.formatSuccessResponse(value))
-            .catch((err) => this.catch(err, ctx));
-    }
-    /**
-     * Handles errors from an RPC request handler and returns a ViardexRPCError.
-     * @param err - Error to be handled.
-     * @param ctx - A NATS Context.
-     */
-    static handleRequestError(err, ctx) {
-        return this.catch(err, ctx);
-    }
-    static catch(err, ctx) {
-        const subject = ctx ? ctx.getArgs()[0] : null;
-        const error = err instanceof Error ? err : new Error(String(err));
-        const statusCode = err instanceof common_1.HttpException ? err.getStatus() : 500;
-        return {
-            success: false,
-            subject,
-            message: error.message,
-            statusCode,
-            errors: ViardexRpcUtils.getValidationErrors(err),
-        };
-    }
-    /**
-     * Handles NATS request response.
-     * @param obs - An instance of an Observable.
-     */
     static async withReply(obs) {
         const result = await new Promise((resolve, reject) => {
             obs.subscribe({
@@ -132,4 +62,4 @@ class ViardexRpcV2 {
         return ViardexRpcUtils.formatSuccessResponse(result);
     }
 }
-exports.ViardexRpcV2 = ViardexRpcV2;
+exports.ViardexRpc = ViardexRpc;

package/dist/storage/index.d.ts

@@ -0,0 +1,5 @@
+export * from './storage.interface';
+export * from './storage.module';
+export * from './storage.service';
+export * from './r2.service';
+export * from './s3.service';

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.interface"), exports);
+__exportStar(require("./storage.module"), exports);
+__exportStar(require("./storage.service"), exports);
+__exportStar(require("./r2.service"), exports);
+__exportStar(require("./s3.service"), exports);

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

@@ -0,0 +1,20 @@
+import { ConfigService } from '@nestjs/config';
+import { Readable } from 'stream';
+import { IStorageService, MultipartFile, UploadFileOptions, UploadResult } from './storage.interface';
+export declare class R2Service implements IStorageService {
+    private readonly configService;
+    private readonly s3Client;
+    private readonly bucketName;
+    private readonly publicUrl;
+    private readonly cloudflareCdnUrl?;
+    constructor(configService: ConfigService);
+    uploadFile(file: Buffer | Readable, options?: UploadFileOptions): Promise<UploadResult>;
+    uploadMultipartFile(file: MultipartFile, options?: UploadFileOptions): Promise<UploadResult>;
+    getPresignedUploadUrl(key: string, contentType: string, expiresIn?: number): Promise<string>;
+    getPresignedDownloadUrl(key: string, expiresIn?: number): Promise<string>;
+    deleteFile(key: string): Promise<void>;
+    fileExists(key: string): Promise<boolean>;
+    getPublicUrl(key: string): string;
+    private generateFileName;
+    private streamToBuffer;
+}

package/dist/storage/r2.service.js

@@ -0,0 +1,213 @@
+"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.R2Service = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+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 R2Service = class R2Service {
+    configService;
+    s3Client;
+    bucketName;
+    publicUrl;
+    cloudflareCdnUrl;
+    constructor(configService) {
+        this.configService = configService;
+        const r2Config = {
+            accountId: this.configService.get('r2.accountId'),
+            accessKeyId: this.configService.get('r2.accessKeyId'),
+            secretAccessKey: this.configService.get('r2.secretAccessKey'),
+            bucketName: this.configService.get('r2.bucketName'),
+            publicUrl: this.configService.get('r2.publicUrl'),
+            cloudflareCdnUrl: this.configService.get('r2.cloudflareCdnUrl'),
+            region: this.configService.get('r2.region', 'auto'),
+            endpoint: this.configService.get('r2.endpoint'),
+        };
+        if (!r2Config.accountId ||
+            !r2Config.accessKeyId ||
+            !r2Config.secretAccessKey ||
+            !r2Config.bucketName) {
+            throw new Error('R2 configuration is incomplete. Please check your environment variables.');
+        }
+        this.bucketName = r2Config.bucketName;
+        this.cloudflareCdnUrl = r2Config.cloudflareCdnUrl;
+        this.publicUrl =
+            r2Config.cloudflareCdnUrl ||
+                r2Config.publicUrl ||
+                `https://${r2Config.accountId}.r2.cloudflarestorage.com/${r2Config.bucketName}`;
+        this.s3Client = new client_s3_1.S3Client({
+            region: r2Config.region || 'auto',
+            endpoint: r2Config.endpoint ||
+                `https://${r2Config.accountId}.r2.cloudflarestorage.com`,
+            credentials: {
+                accessKeyId: r2Config.accessKeyId,
+                secretAccessKey: r2Config.secretAccessKey,
+            },
+        });
+    }
+    async uploadFile(file, options = {}) {
+        try {
+            const fileName = options.fileName || this.generateFileName();
+            const folder = options.folder ? `${options.folder}/` : '';
+            const key = `${folder}${fileName}`;
+            const contentType = options.contentType || 'application/octet-stream';
+            const body = file instanceof Buffer
+                ? file
+                : await this.streamToBuffer(file);
+            await this.s3Client.send(new client_s3_1.PutObjectCommand({
+                Bucket: this.bucketName,
+                Key: key,
+                Body: body,
+                ContentType: contentType,
+            }));
+            return {
+                key,
+                url: this.getPublicUrl(key),
+                fileName,
+                size: body.length,
+                contentType,
+            };
+        }
+        catch (error) {
+            throw new common_1.InternalServerErrorException(`Failed to upload file: ${error?.message || 'Unknown error'}`);
+        }
+    }
+    async uploadMultipartFile(file, options = {}) {
+        const allowedMimeTypes = [
+            'image/jpeg',
+            'image/png',
+            'image/webp',
+            'image/gif',
+            'application/pdf',
+            'application/msword',
+            'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        ];
+        if (!allowedMimeTypes.includes(file.mimetype)) {
+            throw new common_1.BadRequestException(`File type ${file.mimetype} is not allowed`);
+        }
+        const maxSize = 5 * 1024 * 1024;
+        if (file.data.length > maxSize) {
+            throw new common_1.BadRequestException('File size exceeds 5MB limit');
+        }
+        const fileExtension = path.extname(file.filename);
+        const fileName = options.fileName || `${this.generateFileName()}${fileExtension}`;
+        return this.uploadFile(file.data, {
+            ...options,
+            fileName,
+            contentType: file.mimetype,
+        });
+    }
+    async getPresignedUploadUrl(key, contentType, expiresIn = 3600) {
+        try {
+            return await (0, s3_request_presigner_1.getSignedUrl)(this.s3Client, new client_s3_1.PutObjectCommand({
+                Bucket: this.bucketName,
+                Key: key,
+                ContentType: contentType,
+            }), { expiresIn });
+        }
+        catch (error) {
+            throw new common_1.InternalServerErrorException(`Failed to generate presigned URL: ${error?.message || 'Unknown error'}`);
+        }
+    }
+    async getPresignedDownloadUrl(key, expiresIn = 3600) {
+        try {
+            return await (0, s3_request_presigner_1.getSignedUrl)(this.s3Client, new client_s3_1.GetObjectCommand({
+                Bucket: this.bucketName,
+                Key: key,
+            }), { expiresIn });
+        }
+        catch (error) {
+            throw new common_1.InternalServerErrorException(`Failed to generate presigned URL: ${error?.message || 'Unknown error'}`);
+        }
+    }
+    async deleteFile(key) {
+        try {
+            await this.s3Client.send(new client_s3_1.DeleteObjectCommand({
+                Bucket: this.bucketName,
+                Key: key,
+            }));
+        }
+        catch (error) {
+            throw new common_1.InternalServerErrorException(`Failed to delete file: ${error?.message || 'Unknown error'}`);
+        }
+    }
+    async fileExists(key) {
+        try {
+            await this.s3Client.send(new client_s3_1.HeadObjectCommand({
+                Bucket: this.bucketName,
+                Key: key,
+            }));
+            return true;
+        }
+        catch (error) {
+            if (error?.name === 'NotFound' ||
+                error?.$metadata?.httpStatusCode === 404) {
+                return false;
+            }
+            throw new common_1.InternalServerErrorException(`Failed to check file existence: ${error?.message || 'Unknown error'}`);
+        }
+    }
+    getPublicUrl(key) {
+        const baseUrl = this.cloudflareCdnUrl || this.publicUrl;
+        return baseUrl.endsWith('/') ? `${baseUrl}${key}` : `${baseUrl}/${key}`;
+    }
+    generateFileName() {
+        return `${Date.now()}-${crypto.randomBytes(16).toString('hex')}`;
+    }
+    async streamToBuffer(stream) {
+        const chunks = [];
+        for await (const chunk of stream) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        return Buffer.concat(chunks);
+    }
+};
+exports.R2Service = R2Service;
+exports.R2Service = R2Service = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService])
+], R2Service);

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

@@ -0,0 +1,20 @@
+import { ConfigService } from '@nestjs/config';
+import { Readable } from 'stream';
+import { IStorageService, MultipartFile, UploadFileOptions, UploadResult } from './storage.interface';
+export declare class S3Service implements IStorageService {
+    private readonly configService;
+    private readonly s3Client;
+    private readonly bucketName;
+    private readonly publicUrl;
+    private readonly cloudfrontUrl?;
+    constructor(configService: ConfigService);
+    uploadFile(file: Buffer | Readable, options?: UploadFileOptions): Promise<UploadResult>;
+    uploadMultipartFile(file: MultipartFile, options?: UploadFileOptions): Promise<UploadResult>;
+    getPresignedUploadUrl(key: string, contentType: string, expiresIn?: number): Promise<string>;
+    getPresignedDownloadUrl(key: string, expiresIn?: number): Promise<string>;
+    deleteFile(key: string): Promise<void>;
+    fileExists(key: string): Promise<boolean>;
+    getPublicUrl(key: string): string;
+    private generateFileName;
+    private streamToBuffer;
+}