@super-protocol/sdk-js 2.1.4-beta.1 → 2.1.4-beta.3

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

@@ -0,0 +1,161 @@
+import Queue from 'p-queue';
+import logger from '../../logger';
+export var ContentWriterType;
+(function (ContentWriterType) {
+    ContentWriterType["NEEDS_UPLOAD"] = "NEEDS_UPLOAD";
+    ContentWriterType["NEEDS_DELETE"] = "NEEDS_DELETE";
+})(ContentWriterType || (ContentWriterType = {}));
+const DEFAULT_WRITE_CONTENT_CONCURRENCY = 16;
+const DEFAULT_CACHE_EXPIRATION_TS = 5 * 60 * 1000;
+export default class StorageContentWriter {
+    timeout = null;
+    INTERVAL;
+    storageKeyValueAdapter;
+    logger;
+    instanceId;
+    cacheExpirationTs;
+    objectDeletedFlag;
+    queueWriteContent;
+    performance;
+    storageWrites = new Map();
+    constructor(config) {
+        const { writeContentConcurrency, interval, storageKeyValueAdapter, instanceId, objectDeletedFlag, cacheExpirationTs, performance, showLogs = true, } = config || {};
+        this.logger = showLogs ? logger.child({ class: StorageContentWriter.name }) : null;
+        this.performance = performance;
+        this.INTERVAL = interval;
+        this.cacheExpirationTs = cacheExpirationTs || DEFAULT_CACHE_EXPIRATION_TS;
+        this.storageKeyValueAdapter = storageKeyValueAdapter;
+        this.instanceId = instanceId;
+        this.objectDeletedFlag = objectDeletedFlag;
+        this.queueWriteContent = new Queue({
+            concurrency: writeContentConcurrency || DEFAULT_WRITE_CONTENT_CONCURRENCY,
+        });
+    }
+    async actualizeCacheDelete(key, encryptionKey) {
+        const objects = await this.storageKeyValueAdapter.listFiles(key);
+        const objectsToDelete = objects.filter((object) => !object.name.endsWith(this.objectDeletedFlag));
+        await Promise.all(objectsToDelete.map((object) => this.storageKeyValueAdapter.delete(object.name)));
+        if (objectsToDelete.length === objects.length) {
+            await this.storageKeyValueAdapter.set(`${key}/${this.objectDeletedFlag}`, null, encryptionKey);
+        }
+    }
+    async actualizeCacheUpload(key, encryptionKey, cache) {
+        const instances = cache.get(key);
+        const instance = instances?.get(this.instanceId);
+        if (!instances || !instance) {
+            this.logger?.error({
+                key,
+                instancesSize: instances?.size,
+                value: instance,
+            }, 'Attempted to upload non-existing value');
+            return;
+        }
+        if (instance.value) {
+            const startUpload = this.performance?.now();
+            await this.storageKeyValueAdapter.set(`${key}/${this.instanceId}`, instance.value, encryptionKey);
+            if (this.performance && startUpload !== undefined) {
+                const finishUpload = this.performance.now();
+                this.logger?.info(`Uploading took ${(finishUpload - startUpload).toFixed(1)} ms`);
+            }
+        }
+        await this.deleteOutdatedInstances(key, instances);
+    }
+    async actualizeCache(cache) {
+        const logger = this.logger?.child({ method: this.actualizeCache.name });
+        if (this.storageWrites.size) {
+            Array.from(this.storageWrites.entries()).forEach(([key, { type, index, encryptionKey }]) => {
+                this.queueWriteContent.add(async () => {
+                    try {
+                        switch (type) {
+                            case ContentWriterType.NEEDS_DELETE:
+                                await this.actualizeCacheDelete(key, encryptionKey);
+                                break;
+                            case ContentWriterType.NEEDS_UPLOAD:
+                                await this.actualizeCacheUpload(key, encryptionKey, cache);
+                                break;
+                            default:
+                                break;
+                        }
+                        // delete only if the current index is up to date
+                        if (index === this.storageWrites.get(key)?.index) {
+                            this.storageWrites.delete(key);
+                        }
+                    }
+                    catch (err) {
+                        logger?.error({
+                            err,
+                            size: this.storageWrites.size,
+                        }, `Error storage writing ${key}`);
+                    }
+                });
+            });
+            await this.queueWriteContent.onIdle();
+            logger?.info({ size: this.storageWrites.size }, 'Success storage writing');
+        }
+    }
+    async deleteOutdatedInstances(key, instances) {
+        const expiredTs = Date.now() - this.cacheExpirationTs;
+        const instancesToDelete = [];
+        instances?.forEach((instance, instanceId) => {
+            const isOutdated = instance.modifiedTs < expiredTs;
+            const isNotNull = Boolean(instance.value);
+            if (instanceId !== this.instanceId && isNotNull && isOutdated) {
+                instancesToDelete.push([instanceId, instance]);
+            }
+        });
+        // For safety, always preserve one additional copy in storage
+        if (instancesToDelete.length <= 1) {
+            return;
+        }
+        // Finding the most up-to-date instance to preserve
+        instancesToDelete
+            .sort((a, b) => {
+            const diff = a[1].modifiedTs - b[1].modifiedTs;
+            if (diff === 0) {
+                return a[0] >= b[0] ? 1 : -1;
+            }
+            return diff;
+        })
+            .pop();
+        await Promise.allSettled(instancesToDelete.map(([instanceId]) => this.storageKeyValueAdapter
+            .delete(`${key}/${instanceId}`)
+            .then(() => {
+            instances.delete(instanceId);
+        })
+            .catch((err) => this.logger?.error({ err }, 'Error deleting outdated instance'))));
+    }
+    startActualizeCacheTimer(cache) {
+        if (this.INTERVAL) {
+            if (this.timeout)
+                clearTimeout(this.timeout);
+            this.timeout = setTimeout(async () => {
+                await this.actualizeCache(cache);
+                this.startActualizeCacheTimer(cache);
+            }, this.INTERVAL);
+        }
+    }
+    stop() {
+        if (this.timeout)
+            clearTimeout(this.timeout);
+        this.timeout = null;
+    }
+    set(key, type, encryptionKey) {
+        const oldValue = this.storageWrites.get(key);
+        this.storageWrites.set(key, {
+            type,
+            index: oldValue?.index ? oldValue.index + 1 : 1,
+            encryptionKey,
+        });
+    }
+    get(key) {
+        return this.storageWrites.get(key)?.type || null;
+    }
+    clear() {
+        this.storageWrites.clear();
+    }
+    async shutdown(cache) {
+        this.stop();
+        await this.actualizeCache(cache);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StorageContentWriter.js","sourceRoot":"","sources":["../../../../src/providers/storage/StorageContentWriter.ts"],"names":[],"mappings":"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"}

package/dist/mjs/providers/storage/StorageKeyValueAdapter.d.ts

@@ -0,0 +1,23 @@
+import { Encryption } from '@super-protocol/dto-js';
+import StorageAccess from '../../types/storage/StorageAccess';
+import StorageObject from '../../types/storage/StorageObject';
+export interface StorageKeyValueAdapterConfig {
+    showLogs?: boolean;
+}
+export default class StorageKeyValueAdapter<V extends object> {
+    private readonly storageProvider;
+    private readonly logger?;
+    constructor(storageAccess: StorageAccess, config?: StorageKeyValueAdapterConfig);
+    decrypt(encryption: Encryption, key: string): Promise<V | null>;
+    encrypt(data: V | null, key: string): Promise<Encryption>;
+    private downloadFromStorage;
+    private streamToString;
+    private storageUpload;
+    private storageDelete;
+    private storageDownload;
+    private storageListFiles;
+    set(key: string, value: V | null, privateKey: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    get(key: string, privateKey: string): Promise<V | null>;
+    listFiles(key: string): Promise<StorageObject[]>;
+}

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

@@ -0,0 +1,119 @@
+import { Readable } from 'stream';
+import { CryptoAlgorithm, Encoding, Cipher } from '@super-protocol/dto-js';
+import getStorageProvider from './getStorageProvider';
+import logger from '../../logger';
+import Crypto from '../../crypto/Crypto';
+export default class StorageKeyValueAdapter {
+    storageProvider;
+    logger;
+    constructor(storageAccess, config) {
+        if (!storageAccess?.credentials)
+            throw new Error('Credentials is empty');
+        const { showLogs = true } = config || {};
+        this.logger = showLogs ? logger.child({ class: StorageKeyValueAdapter.name }) : null;
+        this.storageProvider = getStorageProvider(storageAccess);
+    }
+    async decrypt(encryption, key) {
+        if (!encryption)
+            return null;
+        if (!key)
+            throw new Error('Key cannot be empty!');
+        encryption.key = key;
+        return JSON.parse(await Crypto.decrypt(encryption));
+    }
+    async encrypt(data, key) {
+        if (data === undefined)
+            throw new Error('Data cannot be empty!');
+        if (!key)
+            throw new Error('Private cannot be empty!');
+        return Crypto.encrypt(JSON.stringify(data), {
+            algo: CryptoAlgorithm.AES,
+            encoding: Encoding.base64,
+            key,
+            cipher: Cipher.AES_256_GCM,
+        });
+    }
+    async downloadFromStorage(filepath) {
+        const downloadStream = await this.storageProvider.downloadFile(filepath, {});
+        return this.streamToString(downloadStream);
+    }
+    streamToString(stream) {
+        const chunks = [];
+        return new Promise((resolve, reject) => {
+            stream.on('data', (chunk) => {
+                chunks.push(Buffer.from(chunk));
+            });
+            stream.on('error', (err) => reject(err));
+            stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        });
+    }
+    async storageUpload(key, value, privateKey) {
+        try {
+            const encryptedValue = await this.encrypt(value, privateKey);
+            const buffer = Buffer.from(JSON.stringify(encryptedValue));
+            await this.storageProvider.uploadFile(Readable.from(buffer), key, buffer.byteLength);
+            this.logger?.info({ data: key }, 'Success uploading to storage');
+        }
+        catch (err) {
+            this.logger?.error({ err }, 'Error uploading to storage');
+            throw err;
+        }
+    }
+    async storageDelete(key) {
+        try {
+            await this.storageProvider.deleteObject(key);
+            this.logger?.info({ data: key }, 'Success deleting from storage');
+        }
+        catch (err) {
+            this.logger?.info({ err }, 'Error deleting from storage');
+            throw err;
+        }
+    }
+    async storageDownload(key, privateKey) {
+        try {
+            const downloaded = await this.downloadFromStorage(key);
+            this.logger?.info({ key }, 'Success download data from storage');
+            if (!downloaded)
+                return null;
+            const decryptedValue = await this.decrypt(JSON.parse(downloaded), privateKey);
+            return decryptedValue;
+        }
+        catch (err) {
+            this.logger?.info({
+                err,
+                key,
+            }, 'Error download data from storage');
+            throw err;
+        }
+    }
+    async storageListFiles(key) {
+        try {
+            const listObjects = await this.storageProvider.listObjects(key);
+            this.logger?.trace({
+                data: listObjects,
+                key,
+            }, 'Success list objects from storage');
+            return listObjects.filter((obj) => !obj.isFolder);
+        }
+        catch (err) {
+            this.logger?.info({
+                err,
+                key,
+            }, 'Error list objects from storage');
+            throw err;
+        }
+    }
+    async set(key, value, privateKey) {
+        return this.storageUpload(key, value, privateKey);
+    }
+    async delete(key) {
+        return this.storageDelete(key);
+    }
+    async get(key, privateKey) {
+        return this.storageDownload(key, privateKey);
+    }
+    async listFiles(key) {
+        return this.storageListFiles(key);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/providers/storage/StorageMetadataReader.d.ts

@@ -0,0 +1,20 @@
+import StorageObject from '../../types/storage/StorageObject';
+import { CacheRecord } from './types';
+import StorageKeyValueAdapter from './StorageKeyValueAdapter';
+export interface InstancesUpdates {
+    updated: Map<string, StorageObject>;
+    deleted: Set<string>;
+}
+export interface StorageMetadataReaderConfig<V extends object> {
+    storageKeyValueAdapter: StorageKeyValueAdapter<V>;
+    objectDeletedFlag: string;
+    showLogs?: boolean;
+}
+export default class StorageMetadataReader<K extends string, V extends object> {
+    private readonly logger?;
+    private readonly storageKeyValueAdapter;
+    private readonly objectDeletedFlag;
+    constructor(config: StorageMetadataReaderConfig<V>);
+    private listInstances;
+    fetchInstancesUpdates(key: K, currentInstances: Map<string, CacheRecord<V>>): Promise<InstancesUpdates>;
+}

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

@@ -0,0 +1,51 @@
+import logger from '../../logger';
+export default class StorageMetadataReader {
+    logger;
+    storageKeyValueAdapter;
+    objectDeletedFlag;
+    constructor(config) {
+        const { showLogs = true, objectDeletedFlag, storageKeyValueAdapter } = config;
+        this.logger = showLogs ? logger.child({ class: StorageMetadataReader.name }) : null;
+        this.storageKeyValueAdapter = storageKeyValueAdapter;
+        this.objectDeletedFlag = objectDeletedFlag;
+    }
+    async listInstances(key) {
+        return this.storageKeyValueAdapter
+            .listFiles(`${key}/`)
+            .then((objects) => new Map(objects.map((obj) => [obj.name.split('/')?.pop() || obj.name, obj])));
+    }
+    async fetchInstancesUpdates(key, currentInstances) {
+        const result = {
+            updated: new Map(),
+            deleted: new Set(),
+        };
+        try {
+            const directoryInstances = await this.listInstances(key);
+            if (directoryInstances.has(this.objectDeletedFlag)) {
+                result.deleted.add(key);
+                return result;
+            }
+            directoryInstances.forEach((instance, instanceId) => {
+                const currentInstance = currentInstances.get(instanceId);
+                if (!currentInstance || currentInstance.modifiedTs < instance.createdAt.getTime()) {
+                    result.updated.set(instanceId, instance);
+                }
+            });
+            currentInstances.forEach((_, instanceId) => {
+                if (!directoryInstances.has(instanceId)) {
+                    result.deleted.add(instanceId);
+                }
+            });
+            this.logger?.trace({
+                updated: result.updated.size,
+                deleted: result.deleted.size,
+            }, 'Check result');
+            return result;
+        }
+        catch (error) {
+            this.logger?.error({ error }, 'Error fetching remote copy');
+            return result;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/providers/storage/StorjAdapter.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import StorageAccess from '../../types/storage/StorageAccess';
+import { StorageAdapterConfig, CacheEvents } from './StorageAdapter';
+export type StorjConfig = StorageAdapterConfig;
+export default class StorjAdapter<V extends object> {
+    private storageAdapter;
+    private readonly logger?;
+    constructor(storageAccess: StorageAccess, config: StorjConfig);
+    subscribe(cb: (props: {
+        type: CacheEvents;
+        message: unknown;
+    }) => void): Promise<() => Promise<void>>;
+    get(key: string, encryptionKey: Buffer): Promise<(V | null)[] | null>;
+    has(key: string): Promise<boolean>;
+    set(key: string, value: V, encryptionKey: Buffer): Promise<void>;
+    del(key: string): Promise<void>;
+    stop(): void;
+    shutdown(): Promise<void>;
+}

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

@@ -0,0 +1,48 @@
+import logger from '../../logger';
+import StorageAdapter from './StorageAdapter';
+export default class StorjAdapter {
+    storageAdapter;
+    logger;
+    constructor(storageAccess, config) {
+        const { showLogs = true } = config || {};
+        this.logger = showLogs ? logger.child({ class: StorjAdapter.name }) : null;
+        this.storageAdapter = new StorageAdapter(storageAccess, config);
+        this.storageAdapter.run();
+    }
+    subscribe(cb) {
+        return this.storageAdapter?.subscribe(cb);
+    }
+    async get(key, encryptionKey) {
+        return this.storageAdapter.get(key, encryptionKey).catch((err) => {
+            const message = err.message?.toLowerCase() || '';
+            if (message.includes('object not found') || message.includes('object has been deleted')) {
+                this.logger?.info({ key }, 'Object not found');
+                return null;
+            }
+            throw err;
+        });
+    }
+    async has(key) {
+        return this.storageAdapter.has(key);
+    }
+    async set(key, value, encryptionKey) {
+        return this.storageAdapter.set(key, value, encryptionKey).catch((err) => {
+            const message = err.message?.toLowerCase() || '';
+            if (message.includes('object has been deleted')) {
+                this.logger?.info({ key }, 'Object has been deleted');
+                return;
+            }
+            throw err;
+        });
+    }
+    async del(key) {
+        return this.storageAdapter.delete(key);
+    }
+    stop() {
+        this.storageAdapter.stop();
+    }
+    async shutdown() {
+        await this.storageAdapter.shutdown();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/providers/storage/StorjStorageProvider.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import IStorageProvider, { DownloadConfig } from './IStorageProvider';
+import StorageObject from '../../types/storage/StorageObject';
+import stream from 'stream';
+export default class StorJStorageProvider implements IStorageProvider {
+    static DOWNLOAD_BUFFER_SIZE: number;
+    private logger;
+    private bucket;
+    private prefix;
+    private accessToken;
+    private _access?;
+    private _project?;
+    private _storj?;
+    private maximumConcurrent?;
+    constructor(credentials: any, maximumConcurrent?: number);
+    uploadFile(inputStream: stream.Readable, 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>;
+    private lazyStorj;
+    private lazyAccess;
+    private lazyProject;
+}

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

@@ -0,0 +1,141 @@
+import { Buffer } from 'buffer';
+import { isNodeJS } from '../../utils/helper';
+import stream from 'stream';
+import logger from '../../logger';
+export default class StorJStorageProvider {
+    static DOWNLOAD_BUFFER_SIZE = 4194304; // 4mb
+    logger = logger.child({ className: 'StorJStorageProvider' });
+    bucket;
+    prefix;
+    accessToken;
+    _access;
+    _project;
+    _storj;
+    maximumConcurrent;
+    constructor(credentials, maximumConcurrent) {
+        if (!isNodeJS()) {
+            throw Error('StorageProvider: StorJ is supported only in the node.js execution environment');
+        }
+        this.bucket = '';
+        this.prefix = '';
+        if (credentials.bucket) {
+            this.bucket = credentials.bucket;
+            this.prefix = credentials.prefix;
+        }
+        else if (credentials.storageId) {
+            // back compatibility
+            this.bucket = credentials.storageId;
+        }
+        this.accessToken = credentials.token;
+        this.maximumConcurrent = maximumConcurrent;
+    }
+    async uploadFile(inputStream, remotePath, contentLength, progressListener) {
+        const storj = await this.lazyStorj();
+        const options = new storj.UploadOptions();
+        const project = await this.lazyProject();
+        const uploader = await project.uploadObject(this.bucket, this.prefix + remotePath, options);
+        let totalWritten = 0;
+        try {
+            for await (const buffer of inputStream) {
+                await uploader.write(buffer, buffer.length);
+                totalWritten += buffer.length;
+                if (!!progressListener) {
+                    progressListener(contentLength, totalWritten);
+                }
+            }
+            await uploader.commit();
+        }
+        catch (uploadingError) {
+            try {
+                await uploader.abort();
+            }
+            catch (abortingError) {
+                logger.error({ err: abortingError }, 'Failed to abort file uploading');
+            }
+            throw uploadingError;
+        }
+    }
+    async downloadFile(remotePath, config, progressListener) {
+        const storj = await this.lazyStorj();
+        const project = await this.lazyProject();
+        const length = config.length || (await this.getObjectSize(remotePath));
+        const options = new storj.DownloadOptions(config.offset || 0, length);
+        const downloader = await project.downloadObject(this.bucket, this.prefix + remotePath, options);
+        const loader = async function* () {
+            const readBuffer = Buffer.alloc(StorJStorageProvider.DOWNLOAD_BUFFER_SIZE);
+            let current = 0;
+            while (current < length) {
+                // We have to cast result to any, because of the wrong type declartion in uplink-nodejs.
+                const downloadResult = await downloader.read(readBuffer, readBuffer.length);
+                const bytesRead = downloadResult.bytes_read;
+                current += bytesRead;
+                yield Buffer.from(readBuffer.subarray(0, bytesRead));
+                if (!!progressListener) {
+                    progressListener(length, current);
+                }
+            }
+        };
+        return stream.Readable.from(loader()).on('close', async () => {
+            await downloader.close();
+        });
+    }
+    async deleteObject(remotePath) {
+        const project = await this.lazyProject();
+        await project.deleteObject(this.bucket, this.prefix + remotePath);
+    }
+    async listObjects(remotePath) {
+        const storj = await this.lazyStorj();
+        const project = await this.lazyProject();
+        const objects = await project.listObjects(this.bucket, {
+            recursive: true,
+            cursor: '',
+            prefix: this.prefix + remotePath,
+            system: true,
+            custom: true,
+        });
+        const result = [];
+        for (const key in Object.keys(objects)) {
+            const value = objects[key];
+            result.push({
+                name: value.key,
+                size: value.system.content_length,
+                isFolder: value.is_prefix == 1,
+                childrenCount: value.custom.count,
+                createdAt: new Date(value.system.created * 1000), // TODO: check timezone
+            });
+        }
+        return result;
+    }
+    async getObjectSize(remotePath) {
+        const project = await this.lazyProject();
+        const objectInfo = await project.statObject(this.bucket, this.prefix + remotePath);
+        return objectInfo.system.content_length;
+    }
+    async getLastModified(remotePath) {
+        const project = await this.lazyProject();
+        const objectInfo = await project.statObject(this.bucket, this.prefix + remotePath);
+        return new Date(objectInfo.system.created * 1000);
+    }
+    async lazyStorj() {
+        if (!this._storj) {
+            this._storj = await require('@super-protocol/uplink-nodejs');
+        }
+        return this._storj;
+    }
+    async lazyAccess() {
+        if (!this._access) {
+            const storj = await this.lazyStorj();
+            const uplink = new storj.Uplink();
+            this._access = await uplink.parseAccess(this.accessToken);
+        }
+        return this._access;
+    }
+    async lazyProject() {
+        if (!this._project) {
+            const access = await this.lazyAccess();
+            this._project = await access.openProject(this.maximumConcurrent);
+        }
+        return this._project;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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