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

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

@@ -0,0 +1,139 @@
+import { Readable, Transform } from '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 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 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);
+        });
+    }
+}
+export 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;
+};
+export 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
+        }`);
+    };
+};
+export 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 = 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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/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/mjs/providers/storage/IStorageProvider.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSVN0b3JhZ2VQcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wcm92aWRlcnMvc3RvcmFnZS9JU3RvcmFnZVByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/mjs/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/mjs/providers/storage/S3StorageProvider.js

@@ -0,0 +1,203 @@
+import { AbortMultipartUploadCommand, CompleteMultipartUploadCommand, CreateMultipartUploadCommand, PutObjectCommand, DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, S3Client, UploadPartCommand, } from '@aws-sdk/client-s3';
+import { Readable } from 'stream';
+import { getStreamChunks } from '../../utils/helpers/getStreamChunks.js';
+import { streamToBuffer } from '../../utils/helpers/streamToBuffer.js';
+import path from 'path';
+import { isNodeJS } from '../../utils/helper.js';
+export 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 S3Client({
+            credentials: {
+                accessKeyId,
+                secretAccessKey: secretKey,
+            },
+            region: region || this.defaultRegion,
+            endpoint,
+            forcePathStyle: true,
+        });
+    }
+    applyPrefix(key) {
+        return path.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 = isNodeJS()
+            ? await streamToBuffer(inputStream)
+            : new Uint8Array(await inputStream.arrayBuffer());
+        const putObjectCommand = new 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 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 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 Readable) {
+                for await (const streamChunk of 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 CompleteMultipartUploadCommand({
+                Bucket: this.bucket,
+                Key: key,
+                UploadId: multipart.UploadId,
+                MultipartUpload: { Parts: parts },
+            });
+            await this.s3Client.send(completeMultipartUploadCommand);
+        }
+        catch (uploadingError) {
+            const abortMultipartUploadCommand = new 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 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 GetObjectCommand(getObjectParams);
+        const getObjectResult = await this.s3Client.send(getObjectCommand);
+        if (!getObjectResult.Body || !(getObjectResult.Body instanceof 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 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 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;
+    }
+}
+//# 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/mjs/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>;
+}