clhq-s3-module 1.1.0-alpha.90

package/dist/aws-s3.service.d.ts

@@ -0,0 +1,19 @@
+import { ConfigService } from '@nestjs/config';
+import { S3Client } from '@aws-sdk/client-s3';
+export declare class AwsService {
+    private readonly configService;
+    private readonly awsUserKey;
+    private readonly awsUserPassword;
+    private readonly region;
+    private readonly bucket;
+    private readonly logger;
+    constructor(configService: ConfigService);
+    getS3Client(): S3Client;
+    uploadPublicFile(dataBuffer: Buffer, filename: string, mimetype: string): Promise<import("@aws-sdk/client-s3").CompleteMultipartUploadCommandOutput | import("@aws-sdk/client-s3").AbortMultipartUploadCommandOutput>;
+    putObject(params: any): Promise<any>;
+    getObject(params: any): Promise<any>;
+    listObjects(params: any): Promise<any>;
+    deleteObject(params: any): Promise<any>;
+    deleteFile(key: string): Promise<void>;
+    delay(milisec: number): Promise<string>;
+}

package/dist/aws-s3.service.js

@@ -0,0 +1,124 @@
+"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 AwsService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsService = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const lib_storage_1 = require("@aws-sdk/lib-storage");
+let AwsService = AwsService_1 = class AwsService {
+    configService;
+    awsUserKey;
+    awsUserPassword;
+    region;
+    bucket;
+    logger = new common_1.Logger(AwsService_1.name);
+    constructor(configService) {
+        this.configService = configService;
+        this.awsUserKey = this.configService.get('CLIPPY_AWS_USER_KEY');
+        this.awsUserPassword = this.configService.get('CLIPPY_AWS_USER_SECRET');
+        this.region = this.configService.get('CLIPPY_AWS_DEFAULT_REGION');
+        this.bucket = this.configService.get('CLIPPY_S3_BUCKET');
+        if (!this.bucket) {
+            this.logger.error('CLIPPY_S3_BUCKET is not set in environment variables');
+            throw new Error('CLIPPY_S3_BUCKET environment variable is required');
+        }
+        this.logger.debug(`S3 Bucket configured: ${this.bucket}`);
+    }
+    getS3Client() {
+        const region = this.configService.get('CLIPPY_AWS_DEFAULT_REGION');
+        const client = new client_s3_1.S3Client({
+            region: region,
+            credentials: {
+                accessKeyId: this.awsUserKey,
+                secretAccessKey: this.awsUserPassword,
+            },
+        });
+        return client;
+    }
+    async uploadPublicFile(dataBuffer, filename, mimetype) {
+        const params = {
+            Bucket: this.bucket,
+            Key: String(`client/${filename}`),
+            Body: dataBuffer,
+            ContentType: mimetype || 'video/webm',
+            ACL: 'public-read',
+            CreateBucketConfiguration: {
+                LocationConstraint: this.region,
+            },
+        };
+        const parallelUploads3 = new lib_storage_1.Upload({
+            client: this.getS3Client(),
+            params: params,
+            tags: [],
+            queueSize: 4,
+            partSize: 1024 * 1024 * 5,
+            leavePartsOnError: false,
+        });
+        parallelUploads3.on('httpUploadProgress', (progress) => {
+            console.log(progress);
+        });
+        await parallelUploads3.done();
+        await this.delay(2000);
+        this.logger.debug('upload success');
+        const result = await parallelUploads3.done();
+        console.log(`File uploaded successfully: ${JSON.stringify(result)}`);
+        return result;
+    }
+    async putObject(params) {
+        const client = this.getS3Client();
+        const command = new client_s3_1.PutObjectCommand({
+            Bucket: this.bucket,
+            ...params,
+        });
+        return await client.send(command);
+    }
+    async getObject(params) {
+        const client = this.getS3Client();
+        const command = new client_s3_1.GetObjectCommand({
+            Bucket: this.bucket,
+            ...params,
+        });
+        return await client.send(command);
+    }
+    async listObjects(params) {
+        const client = this.getS3Client();
+        const command = new client_s3_1.ListObjectsCommand({
+            Bucket: this.bucket,
+            ...params,
+        });
+        return await client.send(command);
+    }
+    async deleteObject(params) {
+        const client = this.getS3Client();
+        const command = new client_s3_1.DeleteObjectCommand({
+            Bucket: this.bucket,
+            ...params,
+        });
+        return await client.send(command);
+    }
+    async deleteFile(key) {
+        await this.deleteObject({ Key: key });
+    }
+    async delay(milisec) {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve('');
+            }, milisec);
+        });
+    }
+};
+exports.AwsService = AwsService;
+exports.AwsService = AwsService = AwsService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService])
+], AwsService);

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './s3.module';
+export * from './aws-s3.service';
+export * from './s3.service';
+export * from './stream-to-disk-helper';
+export * from './services/timeline-storage.service';
+export * from './utils/compression.util';

package/dist/index.js

@@ -0,0 +1,22 @@
+"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("./s3.module"), exports);
+__exportStar(require("./aws-s3.service"), exports);
+__exportStar(require("./s3.service"), exports);
+__exportStar(require("./stream-to-disk-helper"), exports);
+__exportStar(require("./services/timeline-storage.service"), exports);
+__exportStar(require("./utils/compression.util"), exports);

package/dist/s3.module.d.ts

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

package/dist/s3.module.js

@@ -0,0 +1,30 @@
+"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.S3Module = void 0;
+const common_1 = require("@nestjs/common");
+const aws_s3_service_1 = require("./aws-s3.service");
+const s3_service_1 = require("./s3.service");
+const timeline_storage_service_1 = require("./services/timeline-storage.service");
+let S3Module = class S3Module {
+};
+exports.S3Module = S3Module;
+exports.S3Module = S3Module = __decorate([
+    (0, common_1.Module)({
+        providers: [
+            s3_service_1.S3Service,
+            aws_s3_service_1.AwsService,
+            timeline_storage_service_1.TimelineStorageService,
+        ],
+        exports: [
+            s3_service_1.S3Service,
+            aws_s3_service_1.AwsService,
+            timeline_storage_service_1.TimelineStorageService,
+        ],
+    })
+], S3Module);

package/dist/s3.service.d.ts

@@ -0,0 +1,34 @@
+import { ConfigService } from '@nestjs/config';
+import * as S3 from '@aws-sdk/client-s3';
+import { Readable } from 'stream';
+export declare class S3Service {
+    private readonly configService;
+    private readonly awsUserKey;
+    private readonly awsUserPassword;
+    private readonly region;
+    private readonly bucket;
+    private readonly logger;
+    constructor(configService: ConfigService);
+    getS3Client(): S3.S3Client;
+    getBucketDetails(): {
+        bucket: string;
+        region: string;
+    };
+    listOfObjects(path: string): Promise<any>;
+    getObjectByKey(key: string): Promise<any>;
+    uploadS3(rawData: any, fileKey: any, contentType: any): Promise<any>;
+    streamToString(stream: any): Promise<unknown>;
+    streamToBuffer(stream: any): Promise<unknown>;
+    asStream: (s3Response: any) => Promise<Readable>;
+    getFileStream(fileKey: any): Promise<any>;
+    getFileExtension: (file: any) => any;
+    getFileNameWithoutExtension: (file: any) => any;
+    getStreamFromAws(fileKey: string): Promise<Readable>;
+    getSignedFileUrl(fileName: any, uniqueId: any, parts: number, fileType: any): Promise<{
+        uploadPartSignedUrls: any[];
+        UploadId: string;
+        s3Key: string;
+    }>;
+    uploadPart(fileName: any, uploadId: any, buffer: any, partNumber: any): Promise<S3.UploadPartCommandOutput>;
+    completeMultiPartUplaod(fileName: any, uploadId: any, partsWithETag?: any[]): Promise<S3.CompleteMultipartUploadCommandOutput>;
+}

package/dist/s3.service.js

@@ -0,0 +1,277 @@
+"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 S3Service_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3Service = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const S3 = __importStar(require("@aws-sdk/client-s3"));
+const stream_1 = require("stream");
+const lib_storage_1 = require("@aws-sdk/lib-storage");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+const client_s3_1 = require("@aws-sdk/client-s3");
+let S3Service = S3Service_1 = class S3Service {
+    configService;
+    awsUserKey;
+    awsUserPassword;
+    region;
+    bucket;
+    logger = new common_1.Logger(S3Service_1.name);
+    constructor(configService) {
+        this.configService = configService;
+        this.awsUserKey = this.configService.get('CLIPPY_AWS_USER_KEY');
+        this.awsUserPassword = this.configService.get('CLIPPY_AWS_USER_SECRET');
+        this.region = this.configService.get('CLIPPY_AWS_DEFAULT_REGION');
+        this.bucket = this.configService.get('CLIPPY_S3_BUCKET');
+    }
+    getS3Client() {
+        const client = new S3.S3Client({
+            region: this.region,
+            credentials: {
+                accessKeyId: this.awsUserKey,
+                secretAccessKey: this.awsUserPassword,
+            },
+        });
+        return client;
+    }
+    getBucketDetails() {
+        return {
+            bucket: this.bucket,
+            region: this.region,
+        };
+    }
+    async listOfObjects(path) {
+        const client = this.getS3Client();
+        const params = {
+            Bucket: this.bucket,
+            Prefix: String(`client/${path}`),
+            MaxKeys: 100,
+        };
+        const command = new S3.ListObjectsCommand(params);
+        const response = await client.send(command);
+        return response;
+    }
+    async getObjectByKey(key) {
+        const client = this.getS3Client();
+        const params = {
+            Bucket: this.bucket,
+            Key: String(key),
+        };
+        const command = new S3.GetObjectCommand(params);
+        const response = await client.send(command);
+        const bufferedResponse = await this.streamToString(response.Body);
+        return bufferedResponse;
+    }
+    async uploadS3(rawData, fileKey, contentType) {
+        const client = this.getS3Client();
+        const params = {
+            Bucket: this.bucket,
+            Key: String(`client/${fileKey}`),
+            Body: rawData,
+            ContentType: contentType || 'video/webm',
+        };
+        const parallelUploadS3 = new lib_storage_1.Upload({
+            client: client,
+            partSize: 5242880,
+            leavePartsOnError: false,
+            params: params,
+        });
+        parallelUploadS3.on('httpUploadProgress', (progress) => {
+            this.logger.debug('running progress');
+            this.logger.debug(progress);
+        });
+        const response = await parallelUploadS3.done();
+        const newParams = {
+            ...params,
+            ACL: 'public-read',
+        };
+        try {
+            const aclUpdate = new S3.PutObjectAclCommand(newParams);
+            const putAclResposne = await client.send(aclUpdate);
+            this.logger.debug('putAclResponse');
+            this.logger.debug(putAclResposne);
+        }
+        catch (err) {
+            this.logger.debug('Acl Update failed');
+            this.logger.error(err);
+            this.logger.error(err?.message);
+        }
+        return response;
+    }
+    async streamToString(stream) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            stream.on('data', (chunk) => chunks.push(chunk));
+            stream.on('error', reject);
+            stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        });
+    }
+    async streamToBuffer(stream) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            stream.on('data', (chunk) => chunks.push(chunk));
+            stream.on('error', reject);
+            stream.on('end', () => resolve(Buffer.concat(chunks)));
+        });
+    }
+    asStream = async (s3Response) => {
+        return s3Response.Body;
+    };
+    async getFileStream(fileKey) {
+        const client = this.getS3Client();
+        console.log('s3Key', fileKey);
+        const params = {
+            Bucket: this.bucket,
+            Key: String(fileKey),
+        };
+        const command = new S3.GetObjectCommand(params);
+        const response = await client.send(command);
+        const { Body } = response;
+        return Body;
+    }
+    getFileExtension = (file) => {
+        const fileName = file.originalname;
+        return fileName.split('.').pop();
+    };
+    getFileNameWithoutExtension = (file) => {
+        return file.split('.').slice(0, -1).join('.');
+    };
+    async getStreamFromAws(fileKey) {
+        const s3Client = this.getS3Client();
+        const fileKeyPath = fileKey.startsWith('client')
+            ? fileKey.replace('client/', '')
+            : fileKey;
+        const s3Params = {
+            Bucket: this.bucket,
+            Key: `client/${String(fileKeyPath)}`,
+        };
+        try {
+            const response = await s3Client.send(new S3.GetObjectCommand(s3Params));
+            if (response.Body instanceof stream_1.Readable) {
+                return response.Body;
+            }
+            else {
+                const readable = new stream_1.Readable();
+                readable._read = () => { };
+                response.Body.on('data', (chunk) => readable.push(chunk));
+                response.Body.on('end', () => readable.push(null));
+                return readable;
+            }
+        }
+        catch (error) {
+            console.error('Error getting stream from S3:', error);
+            throw error;
+        }
+    }
+    async getSignedFileUrl(fileName, uniqueId, parts = 1, fileType) {
+        const client = this.getS3Client();
+        const s3Key = `client/${fileName}`;
+        const multipartParams = new S3.CreateMultipartUploadCommand({
+            Bucket: this.bucket,
+            Key: s3Key,
+            ContentType: fileType || 'video/webm',
+            ACL: 'public-read',
+        });
+        const getMultipleUploadId = await client.send(multipartParams);
+        console.log('getMultipartUploadId', getMultipleUploadId);
+        const { UploadId } = getMultipleUploadId;
+        const uploadPartSignedUrls = [];
+        const partsArray = Array.from(Array(parts).keys());
+        for (const part of partsArray) {
+            console.log('partnumber', part + 1);
+            const command = new client_s3_1.UploadPartCommand({
+                Bucket: this.bucket,
+                Key: s3Key,
+                UploadId: UploadId,
+                PartNumber: Number(part + 1),
+            });
+            const uploadSignedUrl = await (0, s3_request_presigner_1.getSignedUrl)(client, command, {
+                expiresIn: 3600,
+            });
+            uploadPartSignedUrls.push(uploadSignedUrl);
+        }
+        return {
+            uploadPartSignedUrls,
+            UploadId,
+            s3Key: s3Key,
+        };
+    }
+    async uploadPart(fileName, uploadId, buffer, partNumber) {
+        const client = this.getS3Client();
+        const params = {
+            Bucket: this.bucket,
+            Key: fileName,
+            Body: buffer,
+            PartNumber: partNumber,
+            UploadId: uploadId,
+        };
+        const command = new S3.UploadPartCommand(params);
+        const response = await client.send(command);
+        return response;
+    }
+    async completeMultiPartUplaod(fileName, uploadId, partsWithETag = []) {
+        const client = this.getS3Client();
+        const completeMultipartUploadCommand = new S3.CompleteMultipartUploadCommand({
+            Bucket: this.bucket,
+            Key: fileName,
+            UploadId: uploadId,
+            MultipartUpload: {
+                Parts: partsWithETag.map((part) => ({
+                    ETag: part.ETag,
+                    PartNumber: part.PartNumber,
+                })),
+            },
+        });
+        this.logger.debug('completeMultipartUploadCommand');
+        this.logger.debug(JSON.stringify(completeMultipartUploadCommand));
+        const getMultipleUploadId = await client.send(completeMultipartUploadCommand);
+        console.log('getMultipartUploadId', getMultipleUploadId);
+        return getMultipleUploadId;
+    }
+};
+exports.S3Service = S3Service;
+exports.S3Service = S3Service = S3Service_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService])
+], S3Service);

package/dist/services/timeline-storage.service.d.ts

@@ -0,0 +1,12 @@
+import { AwsService } from '../aws-s3.service';
+export declare class TimelineStorageService {
+    private s3Service;
+    constructor(s3Service: AwsService);
+    saveTimeline(projectId: string, timeline: any): Promise<string>;
+    loadTimeline(projectId: string): Promise<any>;
+    saveTimelineVersion(projectId: string, version: number, timeline: any): Promise<string>;
+    listVersions(projectId: string): Promise<string[]>;
+    getTimelineVersion(projectId: string, version: number): Promise<any>;
+    deleteTimeline(projectId: string): Promise<void>;
+    private streamToBuffer;
+}

package/dist/services/timeline-storage.service.js

@@ -0,0 +1,139 @@
+"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.TimelineStorageService = void 0;
+const common_1 = require("@nestjs/common");
+const aws_s3_service_1 = require("../aws-s3.service");
+const compression_util_1 = require("../utils/compression.util");
+let TimelineStorageService = class TimelineStorageService {
+    s3Service;
+    constructor(s3Service) {
+        this.s3Service = s3Service;
+    }
+    async saveTimeline(projectId, timeline) {
+        const startTime = Date.now();
+        const compressed = await compression_util_1.CompressionUtil.compressJSON(timeline);
+        const originalSize = JSON.stringify(timeline).length;
+        const ratio = compression_util_1.CompressionUtil.compressionRatio(timeline, compressed);
+        const key = `client/projects/${projectId}/timeline.json.gz`;
+        await this.s3Service.putObject({
+            Key: key,
+            Body: compressed,
+            ContentType: 'application/json',
+            ContentEncoding: 'gzip',
+            Metadata: {
+                'original-size': originalSize.toString(),
+                'compressed-size': compressed.length.toString(),
+                'compression-ratio': ratio,
+                'compressed-at': new Date().toISOString(),
+            },
+        });
+        const duration = Date.now() - startTime;
+        console.log(`✅ Timeline saved: ${key} ` +
+            `(${compression_util_1.CompressionUtil.formatBytes(compressed.length)}, ` +
+            `${ratio}% reduction, ${duration}ms)`);
+        return key;
+    }
+    async loadTimeline(projectId) {
+        const startTime = Date.now();
+        try {
+            const key = `client/projects/${projectId}/timeline.json.gz`;
+            const object = await this.s3Service.getObject({ Key: key });
+            const buffer = await this.streamToBuffer(object.Body);
+            const timeline = await compression_util_1.CompressionUtil.decompressJSON(buffer);
+            const duration = Date.now() - startTime;
+            console.log(`✅ Timeline loaded (compressed): ${key} ` +
+                `(${compression_util_1.CompressionUtil.formatBytes(buffer.length)}, ${duration}ms)`);
+            return timeline;
+        }
+        catch (error) {
+            if (error.name === 'NoSuchKey' || error.statusCode === 404) {
+                try {
+                    const key = `client/projects/${projectId}/timeline.json`;
+                    const object = await this.s3Service.getObject({ Key: key });
+                    const buffer = await this.streamToBuffer(object.Body);
+                    const timeline = JSON.parse(buffer.toString());
+                    const duration = Date.now() - startTime;
+                    console.log(`⚠️  Timeline loaded (uncompressed): ${key} ` +
+                        `(${compression_util_1.CompressionUtil.formatBytes(buffer.length)}, ${duration}ms)`);
+                    return timeline;
+                }
+                catch (uncompressedError) {
+                    console.error(`❌ Timeline not found: ${projectId}`);
+                    throw new Error(`Timeline not found for project: ${projectId}`);
+                }
+            }
+            throw error;
+        }
+    }
+    async saveTimelineVersion(projectId, version, timeline) {
+        const compressed = await compression_util_1.CompressionUtil.compressJSON(timeline);
+        const key = `client/projects/${projectId}/versions/v${version}.json.gz`;
+        await this.s3Service.putObject({
+            Key: key,
+            Body: compressed,
+            ContentType: 'application/json',
+            ContentEncoding: 'gzip',
+            Metadata: {
+                'version': version.toString(),
+                'compressed-size': compressed.length.toString(),
+                'saved-at': new Date().toISOString(),
+            },
+        });
+        console.log(`✅ Timeline version saved: ${key} (v${version})`);
+        return key;
+    }
+    async listVersions(projectId) {
+        const prefix = `client/projects/${projectId}/versions/`;
+        const objects = await this.s3Service.listObjects({ Prefix: prefix });
+        return objects.Contents?.map(obj => obj.Key) || [];
+    }
+    async getTimelineVersion(projectId, version) {
+        const key = `client/projects/${projectId}/versions/v${version}.json.gz`;
+        const object = await this.s3Service.getObject({ Key: key });
+        const buffer = await this.streamToBuffer(object.Body);
+        return await compression_util_1.CompressionUtil.decompressJSON(buffer);
+    }
+    async deleteTimeline(projectId) {
+        const mainKey = `client/projects/${projectId}/timeline.json.gz`;
+        try {
+            await this.s3Service.deleteObject({ Key: mainKey });
+            console.log(`✅ Deleted timeline: ${mainKey}`);
+        }
+        catch (error) {
+            console.warn(`⚠️  Timeline not found: ${mainKey}`);
+        }
+        const fallbackKey = `client/projects/${projectId}/timeline.json`;
+        try {
+            await this.s3Service.deleteObject({ Key: fallbackKey });
+            console.log(`✅ Deleted uncompressed timeline: ${fallbackKey}`);
+        }
+        catch (error) {
+        }
+        const versions = await this.listVersions(projectId);
+        for (const key of versions) {
+            await this.s3Service.deleteObject({ Key: key });
+        }
+        console.log(`✅ Deleted ${versions.length} timeline versions`);
+    }
+    async streamToBuffer(stream) {
+        const chunks = [];
+        for await (const chunk of stream) {
+            chunks.push(Buffer.from(chunk));
+        }
+        return Buffer.concat(chunks);
+    }
+};
+exports.TimelineStorageService = TimelineStorageService;
+exports.TimelineStorageService = TimelineStorageService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [aws_s3_service_1.AwsService])
+], TimelineStorageService);

package/dist/stream-to-disk-helper.d.ts

@@ -0,0 +1,11 @@
+import { ConfigService } from '@nestjs/config';
+import { S3Service } from './s3.service';
+export declare class StreamToDiskHelper {
+    private readonly s3Service;
+    private readonly configService;
+    private readonly isDev;
+    private readonly logger;
+    constructor(s3Service: S3Service, configService: ConfigService);
+    readStreamToDisk(pathToDisk: string, s3FilePath: string): Promise<void>;
+    readAndWriteStream(fileUrl: string, pathToDisk: string): Promise<unknown>;
+}

package/dist/stream-to-disk-helper.js

@@ -0,0 +1,93 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var StreamToDiskHelper_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamToDiskHelper = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const s3_service_1 = require("./s3.service");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const axios_1 = __importDefault(require("axios"));
+let StreamToDiskHelper = StreamToDiskHelper_1 = class StreamToDiskHelper {
+    s3Service;
+    configService;
+    isDev;
+    logger = new common_1.Logger(StreamToDiskHelper_1.name);
+    constructor(s3Service, configService) {
+        this.s3Service = s3Service;
+        this.configService = configService;
+        this.isDev = this.configService.get('isDevelopment');
+    }
+    async readStreamToDisk(pathToDisk, s3FilePath) {
+        if (this.isDev) {
+            if (!pathToDisk.toLowerCase().includes('c:')) {
+                pathToDisk = path_1.default.join(process.cwd(), pathToDisk);
+            }
+        }
+        const readStream = await this.s3Service.getStreamFromAws(s3FilePath);
+        const writeStream = fs_1.default.createWriteStream(path_1.default.join(pathToDisk));
+        const readStreamToFile = () => new Promise((resolve, reject) => {
+            readStream
+                .pipe(writeStream)
+                .on('finish', () => {
+                this.logger.debug('finsihed writing to disk');
+                resolve(null);
+                return;
+            })
+                .on('error', (err) => {
+                this.logger.debug('error in writing to disk');
+                this.logger.error(err.message);
+                return reject(new Error(err.message));
+            });
+        });
+        await readStreamToFile().catch((e) => {
+            throw e;
+        });
+    }
+    async readAndWriteStream(fileUrl, pathToDisk) {
+        if (this.isDev) {
+            if (!pathToDisk.toLowerCase().includes('c:')) {
+                pathToDisk = path_1.default.join(process.cwd(), pathToDisk);
+            }
+        }
+        const writer = fs_1.default.createWriteStream(pathToDisk);
+        return (0, axios_1.default)({
+            method: 'get',
+            url: fileUrl,
+            responseType: 'stream',
+        }).then((response) => {
+            return new Promise((resolve, reject) => {
+                response.data.pipe(writer);
+                let error = null;
+                writer.on('error', (err) => {
+                    error = err;
+                    writer.close();
+                    reject(err);
+                });
+                writer.on('close', () => {
+                    if (!error) {
+                        resolve(true);
+                    }
+                });
+            });
+        });
+    }
+};
+exports.StreamToDiskHelper = StreamToDiskHelper;
+exports.StreamToDiskHelper = StreamToDiskHelper = StreamToDiskHelper_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [s3_service_1.S3Service,
+        config_1.ConfigService])
+], StreamToDiskHelper);

package/dist/utils/compression.util.d.ts

@@ -0,0 +1,7 @@
+export declare class CompressionUtil {
+    static compressJSON(data: any): Promise<Buffer>;
+    static decompressJSON(buffer: Buffer): Promise<any>;
+    static compressionRatio(original: any, compressed: Buffer): string;
+    static formatBytes(bytes: number): string;
+    static testCompression(sampleData: any): Promise<void>;
+}

package/dist/utils/compression.util.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionUtil = void 0;
+const util_1 = require("util");
+const zlib_1 = require("zlib");
+class CompressionUtil {
+    static async compressJSON(data) {
+        const json = JSON.stringify(data);
+        const gzipPromise = (0, util_1.promisify)(zlib_1.gzip);
+        return await gzipPromise(json);
+    }
+    static async decompressJSON(buffer) {
+        const gunzipPromise = (0, util_1.promisify)(zlib_1.gunzip);
+        const decompressed = await gunzipPromise(buffer);
+        return JSON.parse(decompressed.toString());
+    }
+    static compressionRatio(original, compressed) {
+        const originalSize = JSON.stringify(original).length;
+        const compressedSize = compressed.length;
+        return ((1 - compressedSize / originalSize) * 100).toFixed(2);
+    }
+    static formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 Bytes';
+        const k = 1024;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
+    }
+    static async testCompression(sampleData) {
+        console.log('\n🧪 Testing Compression...');
+        const originalSize = JSON.stringify(sampleData).length;
+        console.log(`📦 Original size: ${this.formatBytes(originalSize)}`);
+        const compressed = await this.compressJSON(sampleData);
+        console.log(`🗜️  Compressed size: ${this.formatBytes(compressed.length)}`);
+        const ratio = this.compressionRatio(sampleData, compressed);
+        console.log(`📊 Compression ratio: ${ratio}%`);
+        const decompressed = await this.decompressJSON(compressed);
+        const isValid = JSON.stringify(sampleData) === JSON.stringify(decompressed);
+        console.log(`✅ Decompression valid: ${isValid}`);
+    }
+}
+exports.CompressionUtil = CompressionUtil;

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "clhq-s3-module",
+  "version": "1.1.0-alpha.90",
+  "description": "Reusable S3 service module for NestJS.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/reacthub-pricematch/clhq-api-monorepo"
+  },
+  "registry": "https://registry.npmjs.org/",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/reacthub-pricematch/clhq-api-monorepo/issues"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "yarn exec tsc -p tsconfig.json",
+    "test": "jest",
+    "version:upgrade:alpha": "standard-version --prerelease alpha",
+    "release": "npm publish --tag alpha",
+    "release:alpha": "npm publish --tag alpha",
+    "release:prealpha": "",
+    "clean:build": "rimraf .build",
+    "clean:dist": "rimraf dist",
+    "clean:webpack": "rimraf .webpack",
+    "clean:serverless": "rimraf .serverless",
+    "clean:all": "npm run clean:build&& npm run clean:dist&& npm run clean:webpack&& npm run clean:serverless",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix"
+  },
+  "peerDependencies": {
+    "@nestjs/common": ">=11.0.0",
+    "@nestjs/core": ">=11.0.0"
+  },
+  "devDependencies": {
+    "@aws-sdk/client-s3": "3.128.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "standard-version": "^9.5.0"
+  }
+}