@super-protocol/swarm-contracts-sdk 0.0.1-beta.1

package/dist/cjs/providers/storage/ChunksDownloadDecorator.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DownloadDecorator = exports.createDownloadChunkMethodWithRetry = exports.downloadChunkMethod = void 0;
+const stream_1 = require("stream");
+function* generateChunks(dataSize, chunkSize, startOffset = BigInt(0)) {
+    let chunk = 0;
+    let offset = startOffset;
+    while (dataSize > offset) {
+        yield {
+            offset,
+            length: chunkSize > dataSize - offset ? Number(dataSize - offset) : chunkSize,
+            dataSize,
+            chunk: chunk++,
+            chunkCount: Math.ceil(Number(dataSize / BigInt(chunkSize))),
+        };
+        offset += BigInt(chunkSize);
+    }
+}
+class ChunkedReadableTransform extends stream_1.Transform {
+    downloadChunk;
+    constructor(downloadChunk, params) {
+        super({
+            objectMode: true,
+            highWaterMark: params.concurrency,
+        });
+        this.downloadChunk = downloadChunk;
+    }
+    _transform(chunk, _encoding, callback) {
+        const resultPromise = this.downloadChunk(chunk);
+        callback(null, {
+            resultPromise,
+            chunk,
+        });
+    }
+}
+class ChainedChunksReadableTransform extends stream_1.Transform {
+    progressListener;
+    constructor(progressListener) {
+        super({
+            objectMode: true,
+            highWaterMark: 1,
+        });
+        this.progressListener = progressListener;
+    }
+    _transform(obj, _encoding, callback) {
+        obj.resultPromise.then((data) => {
+            callback(null, data);
+            if (this.progressListener) {
+                this.progressListener(Number(obj.chunk.dataSize), Number(obj.chunk.offset) + obj.chunk.length);
+            }
+        }, (err) => {
+            callback(err);
+        });
+    }
+}
+const downloadChunkMethod = async (provider, objectPath, chunk) => {
+    let position = 0;
+    const buffer = Buffer.alloc(chunk.length);
+    const dataStream = await provider.downloadFile(objectPath, {
+        offset: Number(chunk.offset),
+        length: chunk.length,
+    });
+    for await (const data of dataStream) {
+        data.copy(buffer, position);
+        position += data.length;
+        if (position > chunk.length) {
+            throw new Error('Chunk buffer is overflow, read data is more than requested for chunk');
+        }
+    }
+    return buffer;
+};
+exports.downloadChunkMethod = downloadChunkMethod;
+const createDownloadChunkMethodWithRetry = (downloadChunkMethod, { retryMaxCount = 3, retryWaitTimeFactory = () => () => 1000, onRetry, } = {}) => {
+    return async (provider, objectPath, chunk) => {
+        const retryWaitTime = retryWaitTimeFactory();
+        //let lastError: unknown = null;
+        let retryCount = retryMaxCount;
+        while (retryCount > 0) {
+            try {
+                return await downloadChunkMethod(provider, objectPath, chunk);
+            }
+            catch (error) {
+                //lastError = error;
+            }
+            retryCount--;
+            if (onRetry) {
+                onRetry(null, chunk, retryCount);
+            }
+            if (retryCount !== 0) {
+                await new Promise((resolve) => setTimeout(resolve, retryWaitTime()));
+            }
+        }
+        throw new Error(`Max retry attempts was reached for object path ${objectPath}, offset ${chunk.offset}, length ${chunk.length
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }`);
+    };
+};
+exports.createDownloadChunkMethodWithRetry = createDownloadChunkMethodWithRetry;
+class DownloadDecorator {
+    provider;
+    chunkDownloaderMethod;
+    options;
+    constructor(provider, chunkDownloaderMethod, options) {
+        this.provider = provider;
+        this.chunkDownloaderMethod = chunkDownloaderMethod;
+        this.options = options;
+    }
+    uploadFile(inputStream, remotePath, contentLength, progressListener) {
+        return this.provider.uploadFile(inputStream, remotePath, contentLength, progressListener);
+    }
+    async downloadFile(remotePath, config, progressListener) {
+        if (config?.length) {
+            return this.provider.downloadFile(remotePath, config, progressListener);
+        }
+        const offset = BigInt(this.options.offset ?? 0);
+        const objectSize = await this.provider.getObjectSize(remotePath);
+        const chunksStream = stream_1.Readable.from(generateChunks(BigInt(objectSize), this.options.chunkSize, offset));
+        const downloadStream = new ChunkedReadableTransform((chunk) => {
+            return this.chunkDownloaderMethod(this.provider, remotePath, chunk);
+        }, {
+            concurrency: this.options.concurrency,
+        });
+        const chainedStream = new ChainedChunksReadableTransform(progressListener);
+        return chunksStream
+            .pipe(downloadStream)
+            .on('error', (error) => {
+            chainedStream.emit('error', error);
+        })
+            .pipe(chainedStream);
+    }
+    deleteObject(remotePath) {
+        return this.provider.deleteObject(remotePath);
+    }
+    listObjects(remotePath) {
+        return this.provider.listObjects(remotePath);
+    }
+    getObjectSize(remotePath) {
+        return this.provider.getObjectSize(remotePath);
+    }
+    getLastModified(remotePath) {
+        return this.provider.getLastModified(remotePath);
+    }
+}
+exports.DownloadDecorator = DownloadDecorator;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/providers/storage/IStorageProvider.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import StorageObject from '../../types/storage/StorageObject.js';
+import stream from 'stream';
+export type DownloadConfig = {
+    offset?: number;
+    length?: number;
+};
+export default interface IStorageProvider {
+    uploadFile(inputStream: stream.Readable | Blob, remotePath: string, contentLength: number, progressListener?: (total: number, current: number) => void): Promise<void>;
+    downloadFile(remotePath: string, config: DownloadConfig, progressListener?: (total: number, current: number) => void): Promise<stream.Readable>;
+    deleteObject(remotePath: string): Promise<void>;
+    listObjects(remotePath: string): Promise<StorageObject[]>;
+    getObjectSize(remotePath: string): Promise<number>;
+    getLastModified(remotePath: string): Promise<Date | null>;
+}

package/dist/cjs/providers/storage/IStorageProvider.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSVN0b3JhZ2VQcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wcm92aWRlcnMvc3RvcmFnZS9JU3RvcmFnZVByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/cjs/providers/storage/S3StorageProvider.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import IStorageProvider, { DownloadConfig } from './IStorageProvider.js';
+import { Readable } from 'stream';
+import StorageObject from '../../types/storage/StorageObject.js';
+import { S3Credentials } from '@super-protocol/dto-js';
+export type S3ClientConfig = Omit<S3Credentials, 'prefix'> & {
+    region?: string;
+    prefix?: string;
+};
+export declare class S3StorageProvider implements IStorageProvider {
+    private readonly s3Client;
+    private readonly bucket;
+    private readonly prefix;
+    private readonly multipartChunkSizeInBytes;
+    private readonly defaultRegion;
+    constructor(storageAccess: S3ClientConfig);
+    private applyPrefix;
+    uploadFile(inputStream: Readable | Blob, remotePath: string, contentLength: number, progressListener?: ((total: number, current: number) => void) | undefined): Promise<void>;
+    private multipartUpload;
+    deleteObject(remotePath: string): Promise<void>;
+    downloadFile(remotePath: string, config: DownloadConfig, progressListener?: ((total: number, current: number) => void) | undefined): Promise<Readable>;
+    listObjects(remotePath: string): Promise<StorageObject[]>;
+    private getMetadata;
+    getObjectSize(remotePath: string): Promise<number>;
+    getLastModified(remotePath: string): Promise<Date>;
+}

package/dist/cjs/providers/storage/S3StorageProvider.js

@@ -0,0 +1,210 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3StorageProvider = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const stream_1 = require("stream");
+const getStreamChunks_js_1 = require("../../utils/helpers/getStreamChunks.js");
+const streamToBuffer_js_1 = require("../../utils/helpers/streamToBuffer.js");
+const path_1 = __importDefault(require("path"));
+const helper_js_1 = require("../../utils/helper.js");
+class S3StorageProvider {
+    s3Client;
+    bucket;
+    prefix;
+    multipartChunkSizeInBytes = 64 * 1024 * 1024; // 64MB
+    defaultRegion = 'us-east-1';
+    constructor(storageAccess) {
+        const { accessKeyId, secretKey, endpoint, bucket, region, prefix } = storageAccess;
+        if (!accessKeyId)
+            throw new Error('Access key id is undefined');
+        if (!secretKey)
+            throw new Error('Secret access is undefined');
+        if (!endpoint)
+            throw new Error('Endpoint is undefined');
+        if (!bucket)
+            throw new Error('Bucket is undefined');
+        if (prefix && (prefix.startsWith('/') || !prefix.endsWith('/'))) {
+            throw new Error(`Prefix is invalid: it must not start with "/" and must end with "/" (prefix=${prefix})`);
+        }
+        this.bucket = bucket;
+        this.prefix = prefix || '';
+        this.s3Client = new client_s3_1.S3Client({
+            credentials: {
+                accessKeyId,
+                secretAccessKey: secretKey,
+            },
+            region: region || this.defaultRegion,
+            endpoint,
+            forcePathStyle: true,
+        });
+    }
+    applyPrefix(key) {
+        return path_1.default.join(this.prefix, '/', key);
+    }
+    async uploadFile(inputStream, remotePath, contentLength, progressListener) {
+        // For performance & cost optimization
+        // https://docs.storj.io/dcs/api-reference/s3-compatible-gateway/multipart-upload/multipart-part-size
+        const key = this.applyPrefix(remotePath);
+        if (contentLength >= this.multipartChunkSizeInBytes) {
+            return this.multipartUpload(inputStream, key, contentLength, progressListener);
+        }
+        const body = (0, helper_js_1.isNodeJS)()
+            ? await (0, streamToBuffer_js_1.streamToBuffer)(inputStream)
+            : new Uint8Array(await inputStream.arrayBuffer());
+        const putObjectCommand = new client_s3_1.PutObjectCommand({
+            Body: body,
+            Bucket: this.bucket,
+            Key: key,
+        });
+        progressListener?.(contentLength, 0);
+        await this.s3Client.send(putObjectCommand);
+        progressListener?.(contentLength, contentLength);
+    }
+    async multipartUpload(inputStream, remotePath, contentLength, progressListener) {
+        const key = this.applyPrefix(remotePath);
+        let transformedStream;
+        if (inputStream instanceof Blob) {
+            transformedStream = new Uint8Array(await inputStream.arrayBuffer());
+        }
+        else {
+            transformedStream = inputStream;
+        }
+        const createMultipartUploadCommand = new client_s3_1.CreateMultipartUploadCommand({
+            Bucket: this.bucket,
+            Key: key,
+        });
+        const multipart = await this.s3Client.send(createMultipartUploadCommand);
+        if (!multipart.UploadId) {
+            throw new Error('UploadId property is empty');
+        }
+        let totalWritten = 0;
+        const uploadId = multipart.UploadId;
+        const parts = [];
+        const uploadPart = async (chunk, partNumber) => {
+            const uploadPartCommand = new client_s3_1.UploadPartCommand({
+                Body: chunk,
+                Bucket: this.bucket,
+                Key: key,
+                UploadId: uploadId,
+                PartNumber: partNumber,
+            });
+            const response = await this.s3Client.send(uploadPartCommand);
+            parts.push({
+                ETag: response.ETag,
+                PartNumber: partNumber,
+            });
+            totalWritten += chunk.length;
+            progressListener?.(contentLength, totalWritten);
+        };
+        try {
+            if (transformedStream instanceof stream_1.Readable) {
+                for await (const streamChunk of (0, getStreamChunks_js_1.getStreamChunks)(transformedStream, this.multipartChunkSizeInBytes)) {
+                    await uploadPart(streamChunk.data, streamChunk.partNumber);
+                }
+            }
+            else {
+                const chunkSize = this.multipartChunkSizeInBytes;
+                let partNumber = 1;
+                for (let offset = 0; offset < transformedStream.length; offset += chunkSize) {
+                    const chunk = transformedStream.slice(offset, offset + chunkSize);
+                    await uploadPart(chunk, partNumber);
+                    partNumber++;
+                }
+            }
+            const completeMultipartUploadCommand = new client_s3_1.CompleteMultipartUploadCommand({
+                Bucket: this.bucket,
+                Key: key,
+                UploadId: multipart.UploadId,
+                MultipartUpload: { Parts: parts },
+            });
+            await this.s3Client.send(completeMultipartUploadCommand);
+        }
+        catch (uploadingError) {
+            const abortMultipartUploadCommand = new client_s3_1.AbortMultipartUploadCommand({
+                Bucket: this.bucket,
+                Key: key,
+                UploadId: multipart.UploadId,
+            });
+            await this.s3Client.send(abortMultipartUploadCommand);
+            throw uploadingError;
+        }
+    }
+    async deleteObject(remotePath) {
+        const key = this.applyPrefix(remotePath);
+        const deleteObjectCommand = new client_s3_1.DeleteObjectCommand({
+            Bucket: this.bucket,
+            Key: key,
+        });
+        await this.s3Client.send(deleteObjectCommand);
+    }
+    async downloadFile(remotePath, config, progressListener) {
+        const key = this.applyPrefix(remotePath);
+        const getObjectParams = {
+            Bucket: this.bucket,
+            Key: key,
+        };
+        if (config) {
+            const start = config.offset || 0;
+            const end = start + (config.length || 0);
+            getObjectParams.Range = `bytes=${start}-${end || ''}`;
+        }
+        const getObjectCommand = new client_s3_1.GetObjectCommand(getObjectParams);
+        const getObjectResult = await this.s3Client.send(getObjectCommand);
+        if (!getObjectResult.Body || !(getObjectResult.Body instanceof stream_1.Readable)) {
+            throw new Error('download Body is undefined');
+        }
+        let current = 0;
+        if (progressListener && getObjectResult.Body) {
+            const fileBytesSize = getObjectResult.ContentLength || config.length || (await this.getObjectSize(remotePath));
+            getObjectResult.Body.on('data', (chunk) => {
+                current += chunk.length;
+                progressListener(fileBytesSize, current);
+            });
+        }
+        return getObjectResult.Body;
+    }
+    async listObjects(remotePath) {
+        const key = this.applyPrefix(remotePath.endsWith('/') || remotePath === '' ? remotePath : `${remotePath}/`);
+        const listObjectsCommand = new client_s3_1.ListObjectsV2Command({
+            Bucket: this.bucket,
+            Prefix: key,
+        });
+        const listObjects = await this.s3Client.send(listObjectsCommand);
+        let result = [];
+        if (listObjects.Contents) {
+            result = listObjects.Contents.map((object) => ({
+                name: object.Key?.substring(this.prefix.length) || '',
+                createdAt: object.LastModified || new Date(),
+                size: object.Size || 0,
+            }));
+        }
+        return result;
+    }
+    async getMetadata(remotePath) {
+        const key = this.applyPrefix(remotePath);
+        const headObjectCommand = new client_s3_1.HeadObjectCommand({
+            Bucket: this.bucket,
+            Key: key,
+        });
+        return await this.s3Client.send(headObjectCommand);
+    }
+    async getObjectSize(remotePath) {
+        const metadata = await this.getMetadata(remotePath);
+        if (metadata.ContentLength === undefined) {
+            throw new Error('ContentLength property is empty');
+        }
+        return metadata.ContentLength || 0;
+    }
+    async getLastModified(remotePath) {
+        const metadata = await this.getMetadata(remotePath);
+        if (!metadata.LastModified) {
+            throw new Error('LastModified property is empty');
+        }
+        return metadata.LastModified;
+    }
+}
+exports.S3StorageProvider = S3StorageProvider;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"S3StorageProvider.js","sourceRoot":"","sources":["../../../../src/providers/storage/S3StorageProvider.ts"],"names":[],"mappings":"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"}

package/dist/cjs/providers/storage/StorageAdapter.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="node" />
+import StorageAccess from '../../types/storage/StorageAccess.js';
+import { IStorageAdapter, Performance } from './types.js';
+export interface LRUCacheConfig {
+    max: number;
+}
+export interface StorageAdapterConfig {
+    lruCache: LRUCacheConfig;
+    writeInterval: number;
+    readInterval: number;
+    objectDeletedFlag: string;
+    readMetadataConcurrency?: number;
+    performance?: Performance;
+    showLogs?: boolean;
+    hasEncryption?: boolean;
+    instanceId?: string;
+}
+export declare enum CacheEvents {
+    INSTANCES_CHANGED = "INSTANCES_CHANGED",
+    KEY_DELETED = "KEY_DELETED"
+}
+export default class StorageAdapter<V extends object> implements IStorageAdapter<V> {
+    private readonly logger?;
+    private readonly storageKeyValueAdapter;
+    private readonly cache;
+    private readonly encryptionKeys;
+    private readonly contentWriter;
+    private readonly metadataReader;
+    private readonly instanceId;
+    private timeout;
+    private readonly readInterval;
+    private readonly queues;
+    private readonly queueReadMetadata;
+    private readonly isUpdating;
+    private readonly pubSub;
+    private readonly eventName;
+    private readonly performance?;
+    constructor(storageAccess: StorageAccess, config: StorageAdapterConfig);
+    private generateHash;
+    subscribe(cb: (props: {
+        type: CacheEvents;
+        message: unknown;
+    }) => void): () => void;
+    private publish;
+    has(key: string): Promise<boolean>;
+    private getEncryptionKey;
+    set(key: string, value: V, encryptionKeyBuffer?: Buffer): void;
+    private setByInstance;
+    delete(key: string): void;
+    get(key: string, encryptionKeyBuffer?: Buffer): Promise<(V | null)[] | null>;
+    private getQueue;
+    private clearQueue;
+    private cacheHasNullInstances;
+    private fetchNullValues;
+    clear(): void;
+    run(): void;
+    private checkUpdates;
+    private startUpdatesChecking;
+    private stopUpdatesChecking;
+    stop(): void;
+    shutdown(): Promise<void>;
+}