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

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

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+const dto_js_1 = require("@super-protocol/dto-js");
+const getStorageProvider_js_1 = __importDefault(require("./getStorageProvider.js"));
+const logger_js_1 = __importDefault(require("../../logger.js"));
+const Crypto_js_1 = __importDefault(require("../../crypto/Crypto.js"));
+class StorageKeyValueAdapter {
+    hasEncryption;
+    storageProvider;
+    logger;
+    constructor(storageAccess, config) {
+        if (!storageAccess?.credentials) {
+            throw new Error('Credentials is empty');
+        }
+        const { showLogs = true, hasEncryption = true } = config || {};
+        this.hasEncryption = hasEncryption;
+        this.logger = showLogs ? logger_js_1.default.child({ class: StorageKeyValueAdapter.name }) : null;
+        this.storageProvider = (0, getStorageProvider_js_1.default)(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_js_1.default.decrypt(encryption));
+    }
+    encrypt(data, key) {
+        if (data === undefined) {
+            throw new Error('Data cannot be empty!');
+        }
+        if (!key) {
+            throw new Error('Private cannot be empty!');
+        }
+        return Crypto_js_1.default.encrypt(JSON.stringify(data), {
+            algo: dto_js_1.CryptoAlgorithm.AES,
+            encoding: dto_js_1.Encoding.base64,
+            key,
+            cipher: dto_js_1.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) {
+        if (this.hasEncryption && !privateKey) {
+            throw new Error('Invalid private key');
+        }
+        try {
+            const encryptedValue = this.hasEncryption && privateKey ? await this.encrypt(value, privateKey) : value;
+            const buffer = Buffer.from(JSON.stringify(encryptedValue));
+            await this.storageProvider.uploadFile(stream_1.Readable.from(buffer), key, buffer.byteLength);
+            this.logger?.trace({ 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?.trace({ data: key }, 'Success deleting from storage');
+        }
+        catch (err) {
+            this.logger?.trace({ err }, 'Error deleting from storage');
+            throw err;
+        }
+    }
+    async storageDownload(key, privateKey) {
+        if (this.hasEncryption && !privateKey) {
+            throw new Error('Invalid private key');
+        }
+        try {
+            const downloaded = await this.downloadFromStorage(key);
+            this.logger?.trace({ key }, 'Success download data from storage');
+            if (!downloaded) {
+                return null;
+            }
+            const value = JSON.parse(downloaded);
+            return this.hasEncryption && privateKey ? await this.decrypt(value, privateKey) : value;
+        }
+        catch (err) {
+            this.logger?.trace({
+                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?.trace({
+                err,
+                key,
+            }, 'Error list objects from storage');
+            throw err;
+        }
+    }
+    set(key, value, privateKey) {
+        return this.storageUpload(key, value, privateKey);
+    }
+    delete(key) {
+        return this.storageDelete(key);
+    }
+    get(key, privateKey) {
+        return this.storageDownload(key, privateKey);
+    }
+    listFiles(key) {
+        return this.storageListFiles(key);
+    }
+}
+exports.default = StorageKeyValueAdapter;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,20 @@
+import StorageObject from '../../types/storage/StorageObject.js';
+import { CacheRecord } from './types.js';
+import StorageKeyValueAdapter from './StorageKeyValueAdapter.js';
+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/cjs/providers/storage/StorageMetadataReader.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_js_1 = __importDefault(require("../../logger.js"));
+class StorageMetadataReader {
+    logger;
+    storageKeyValueAdapter;
+    objectDeletedFlag;
+    constructor(config) {
+        const { showLogs = true, objectDeletedFlag, storageKeyValueAdapter } = config;
+        this.logger = showLogs ? logger_js_1.default.child({ class: StorageMetadataReader.name }) : null;
+        this.storageKeyValueAdapter = storageKeyValueAdapter;
+        this.objectDeletedFlag = objectDeletedFlag;
+    }
+    async listInstances(key) {
+        const objects = await this.storageKeyValueAdapter.listFiles(`${key}/`);
+        return 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;
+        }
+    }
+}
+exports.default = StorageMetadataReader;
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_js_1 = __importDefault(require("../../logger.js"));
+const StorageAdapter_js_1 = __importDefault(require("./StorageAdapter.js"));
+class StorjAdapter {
+    storageAdapter;
+    logger;
+    constructor(storageAccess, config) {
+        const { showLogs = true } = config || {};
+        this.logger = showLogs ? logger_js_1.default.child({ class: StorjAdapter.name }) : null;
+        this.storageAdapter = new StorageAdapter_js_1.default(storageAccess, config);
+        this.storageAdapter.run();
+    }
+    subscribe(cb) {
+        return this.storageAdapter?.subscribe(cb);
+    }
+    async get(key, encryptionKey) {
+        try {
+            return await 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;
+        }
+    }
+    has(key) {
+        return this.storageAdapter.has(key);
+    }
+    set(key, value, encryptionKey) {
+        try {
+            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;
+        }
+    }
+    del(key) {
+        this.storageAdapter.delete(key);
+    }
+    stop() {
+        this.storageAdapter.stop();
+    }
+    async shutdown() {
+        await this.storageAdapter.shutdown();
+    }
+}
+exports.default = StorjAdapter;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3RvcmpBZGFwdGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3Byb3ZpZGVycy9zdG9yYWdlL1N0b3JqQWRhcHRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUNBLGdFQUFpRDtBQUNqRCw0RUFBd0Y7QUFLeEYsTUFBcUIsWUFBWTtJQUN2QixjQUFjLENBQW9CO0lBQ3pCLE1BQU0sQ0FBaUI7SUFFeEMsWUFBWSxhQUE4QyxFQUFFLE1BQW1CO1FBQzdFLE1BQU0sRUFBRSxRQUFRLEdBQUcsSUFBSSxFQUFFLEdBQUcsTUFBTSxJQUFJLEVBQUUsQ0FBQztRQUN6QyxJQUFJLENBQUMsTUFBTSxHQUFHLFFBQVEsQ0FBQyxDQUFDLENBQUMsbUJBQU0sQ0FBQyxLQUFLLENBQUMsRUFBRSxLQUFLLEVBQUUsWUFBWSxDQUFDLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztRQUMzRSxJQUFJLENBQUMsY0FBYyxHQUFHLElBQUksMkJBQWMsQ0FBQyxhQUFhLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDaEUsSUFBSSxDQUFDLGNBQWMsQ0FBQyxHQUFHLEVBQUUsQ0FBQztJQUM1QixDQUFDO0lBRUQsU0FBUyxDQUFDLEVBQTREO1FBQ3BFLE9BQU8sSUFBSSxDQUFDLGNBQWMsRUFBRSxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDNUMsQ0FBQztJQUVELEtBQUssQ0FBQyxHQUFHLENBQUMsR0FBVyxFQUFFLGFBQXFCO1FBQzFDLElBQUksQ0FBQztZQUNILE9BQU8sTUFBTSxJQUFJLENBQUMsY0FBYyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsYUFBYSxDQUFDLENBQUM7UUFDM0QsQ0FBQztRQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7WUFDYixNQUFNLE9BQU8sR0FBSSxHQUFhLENBQUMsT0FBTyxFQUFFLFdBQVcsRUFBRSxJQUFJLEVBQUUsQ0FBQztZQUM1RCxJQUFJLE9BQU8sQ0FBQyxRQUFRLENBQUMsa0JBQWtCLENBQUMsSUFBSSxPQUFPLENBQUMsUUFBUSxDQUFDLHlCQUF5QixDQUFDLEVBQUUsQ0FBQztnQkFDeEYsSUFBSSxDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsRUFBRSxHQUFHLEVBQUUsRUFBRSxrQkFBa0IsQ0FBQyxDQUFDO2dCQUUvQyxPQUFPLElBQUksQ0FBQztZQUNkLENBQUM7WUFDRCxNQUFNLEdBQUcsQ0FBQztRQUNaLENBQUM7SUFDSCxDQUFDO0lBRUQsR0FBRyxDQUFDLEdBQVc7UUFDYixPQUFPLElBQUksQ0FBQyxjQUFjLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ3RDLENBQUM7SUFFRCxHQUFHLENBQUMsR0FBVyxFQUFFLEtBQVEsRUFBRSxhQUFxQjtRQUM5QyxJQUFJLENBQUM7WUFDSCxJQUFJLENBQUMsY0FBYyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsS0FBSyxFQUFFLGFBQWEsQ0FBQyxDQUFDO1FBQ3JELENBQUM7UUFBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO1lBQ2IsTUFBTSxPQUFPLEdBQUksR0FBYSxDQUFDLE9BQU8sRUFBRSxXQUFXLEVBQUUsSUFBSSxFQUFFLENBQUM7WUFDNUQsSUFBSSxPQUFPLENBQUMsUUFBUSxDQUFDLHlCQUF5QixDQUFDLEVBQUUsQ0FBQztnQkFDaEQsSUFBSSxDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsRUFBRSxHQUFHLEVBQUUsRUFBRSx5QkFBeUIsQ0FBQyxDQUFDO2dCQUV0RCxPQUFPO1lBQ1QsQ0FBQztZQUNELE1BQU0sR0FBRyxDQUFDO1FBQ1osQ0FBQztJQUNILENBQUM7SUFFRCxHQUFHLENBQUMsR0FBVztRQUNiLElBQUksQ0FBQyxjQUFjLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2xDLENBQUM7SUFFRCxJQUFJO1FBQ0YsSUFBSSxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUM3QixDQUFDO0lBRUQsS0FBSyxDQUFDLFFBQVE7UUFDWixNQUFNLElBQUksQ0FBQyxjQUFjLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDdkMsQ0FBQztDQUNGO0FBMURELCtCQTBEQyJ9

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

@@ -0,0 +1,24 @@
+import { S3Credentials, StorjCredentials, StringifiedCredentials } from '@super-protocol/dto-js';
+export declare enum CredentialsPermissions {
+    read = 0,
+    write = 1,
+    list = 2,
+    delete = 3
+}
+export declare class StorjCredentialsManager {
+    private accessToken;
+    private bucket;
+    private access?;
+    private project?;
+    constructor(storageConfig: Pick<StorjCredentials, 'token' | 'bucket'>);
+    getStorageId(entity: string, entityId: string): string;
+    create(): Promise<void>;
+    acquireCredentials(permissions: CredentialsPermissions[], prefix: string): Promise<StringifiedCredentials<StorjCredentials>>;
+    acquireS3Credentials(permissions: CredentialsPermissions[], prefix: string): Promise<S3Credentials>;
+    getS3Credentials(stringifiedCredentials: StringifiedCredentials): Promise<S3Credentials>;
+    getS3Credentials(storjCredentials: StorjCredentials): Promise<S3Credentials>;
+    revokeCredentials(credentialString: StringifiedCredentials<StorjCredentials>): Promise<void>;
+    private lazyStorj;
+    private lazyAccess;
+    private lazyProject;
+}

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

@@ -0,0 +1,114 @@
+"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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorjCredentialsManager = exports.CredentialsPermissions = void 0;
+const path_1 = __importDefault(require("path"));
+var CredentialsPermissions;
+(function (CredentialsPermissions) {
+    CredentialsPermissions[CredentialsPermissions["read"] = 0] = "read";
+    CredentialsPermissions[CredentialsPermissions["write"] = 1] = "write";
+    CredentialsPermissions[CredentialsPermissions["list"] = 2] = "list";
+    CredentialsPermissions[CredentialsPermissions["delete"] = 3] = "delete";
+})(CredentialsPermissions || (exports.CredentialsPermissions = CredentialsPermissions = {}));
+class StorjCredentialsManager {
+    accessToken;
+    bucket;
+    access;
+    project;
+    constructor(storageConfig) {
+        this.accessToken = storageConfig.token;
+        this.bucket = storageConfig.bucket;
+    }
+    getStorageId(entity, entityId) {
+        return `${entity}_${entityId}`;
+    }
+    async create() {
+        const project = await this.lazyProject();
+        await project.ensureBucket(this.bucket);
+    }
+    async acquireCredentials(permissions, prefix) {
+        const readPerm = permissions.includes(CredentialsPermissions.read), writePerm = permissions.includes(CredentialsPermissions.write), listPerm = permissions.includes(CredentialsPermissions.list), deletePerm = permissions.includes(CredentialsPermissions.delete);
+        const storj = await this.lazyStorj();
+        const perm = new storj.Permission(readPerm, writePerm, listPerm, deletePerm, 0, 0);
+        const preparedPrefix = path_1.default.posix.join(prefix, '/');
+        const sharePrefix = new storj.SharePrefix(this.bucket, preparedPrefix);
+        const access = await this.lazyAccess();
+        const share = await access.share(perm, [sharePrefix], 1);
+        return JSON.stringify({
+            bucket: this.bucket,
+            prefix: preparedPrefix,
+            token: await share.serialize(),
+        });
+    }
+    async acquireS3Credentials(permissions, prefix) {
+        const storjCreds = await this.acquireCredentials(permissions, prefix);
+        return this.getS3Credentials(storjCreds);
+    }
+    async getS3Credentials(creds) {
+        const storjCredentials = typeof creds === 'string' ? JSON.parse(creds) : creds;
+        const access = await this.lazyAccess();
+        const s3Credentials = await access.registerS3Credentials(storjCredentials.token);
+        return {
+            accessKeyId: s3Credentials.accessKeyId,
+            secretKey: s3Credentials.secretKey,
+            endpoint: s3Credentials.endpoint,
+            bucket: storjCredentials.bucket,
+            prefix: storjCredentials.prefix,
+        };
+    }
+    async revokeCredentials(credentialString) {
+        const credentials = JSON.parse(credentialString);
+        const storj = await this.lazyStorj();
+        const uplink = new storj.Uplink();
+        const access = await uplink.parseAccess(credentials.token);
+        const project = await this.lazyProject();
+        await project.revokeAccess(access);
+    }
+    async lazyStorj() {
+        return await Promise.resolve().then(() => __importStar(require('@super-protocol/uplink-nodejs')));
+    }
+    async lazyAccess() {
+        if (this.access) {
+            return 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) {
+            return this.project;
+        }
+        const access = await this.lazyAccess();
+        this.project = await access.openProject();
+        return this.project;
+    }
+}
+exports.StorjCredentialsManager = StorjCredentialsManager;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { StorjCredentials } from '@super-protocol/dto-js';
+import IStorageProvider, { DownloadConfig } from './IStorageProvider.js';
+import StorageObject from '../../types/storage/StorageObject.js';
+import stream from 'stream';
+type StorjCredentialsWithLegacyStorageId = StorjCredentials & {
+    storageId?: string;
+};
+export default class StorJStorageProvider implements IStorageProvider {
+    static DOWNLOAD_BUFFER_SIZE: number;
+    private bucket;
+    private prefix;
+    private accessToken;
+    private _access?;
+    private _project?;
+    private _storj?;
+    private maximumConcurrent?;
+    constructor(credentials: StorjCredentialsWithLegacyStorageId, 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;
+}
+export {};

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

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const buffer_1 = require("buffer");
+const helper_js_1 = require("../../utils/helper.js");
+const stream_1 = __importDefault(require("stream"));
+const logger_js_1 = __importDefault(require("../../logger.js"));
+class StorJStorageProvider {
+    static DOWNLOAD_BUFFER_SIZE = 4194304; // 4mb
+    bucket;
+    prefix;
+    accessToken;
+    _access;
+    _project;
+    _storj;
+    maximumConcurrent;
+    constructor(credentials, maximumConcurrent) {
+        if (!(0, helper_js_1.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_js_1.default.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_1.Buffer.alloc(StorJStorageProvider.DOWNLOAD_BUFFER_SIZE);
+            let current = 0;
+            while (current < length) {
+                const downloadResult = (await downloader.read(readBuffer, readBuffer.length));
+                const bytesRead = downloadResult.bytes_read;
+                current += bytesRead;
+                yield readBuffer.subarray(0, bytesRead);
+                if (!!progressListener) {
+                    progressListener(length, current);
+                }
+            }
+        };
+        return stream_1.default.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 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.substring(this.prefix.length),
+                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) {
+            // Keep lazy loading to avoid pulling uplink in browser bundles.
+            const dynamicImport = new Function('modulePath', 'return import(modulePath);');
+            this._storj = await dynamicImport('@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;
+    }
+}
+exports.default = StorJStorageProvider;
+//# sourceMappingURL=data:application/json;base64,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