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

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

@@ -0,0 +1,300 @@
+"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.CacheEvents = void 0;
+const lru_cache_1 = require("lru-cache");
+const uuid = __importStar(require("uuid"));
+const crypto_1 = require("crypto");
+const p_queue_1 = __importDefault(require("p-queue"));
+const StorageKeyValueAdapter_js_1 = __importDefault(require("./StorageKeyValueAdapter.js"));
+const StorageContentWriter_js_1 = __importStar(require("./StorageContentWriter.js"));
+const StorageMetadataReader_js_1 = __importDefault(require("./StorageMetadataReader.js"));
+const logger_js_1 = __importDefault(require("../../logger.js"));
+const PubSub_js_1 = __importDefault(require("../../utils/PubSub.js"));
+var CacheEvents;
+(function (CacheEvents) {
+    CacheEvents["INSTANCES_CHANGED"] = "INSTANCES_CHANGED";
+    CacheEvents["KEY_DELETED"] = "KEY_DELETED";
+})(CacheEvents || (exports.CacheEvents = CacheEvents = {}));
+const DEFAULT_READ_METADATA_CONCURRENCY = 16;
+class StorageAdapter {
+    logger;
+    storageKeyValueAdapter;
+    cache;
+    encryptionKeys = new Map(); // key -> encryption key (base64)
+    contentWriter;
+    metadataReader;
+    instanceId;
+    timeout = null;
+    readInterval;
+    queues = new Map();
+    queueReadMetadata;
+    isUpdating = new Map();
+    pubSub = new PubSub_js_1.default();
+    eventName = 'storage-adapter';
+    performance;
+    constructor(storageAccess, config) {
+        const { readInterval, writeInterval, lruCache, objectDeletedFlag, readMetadataConcurrency, performance, showLogs = true, hasEncryption = true, instanceId, } = config;
+        this.logger = showLogs ? logger_js_1.default.child({ class: StorageAdapter.name }) : null;
+        this.performance = performance;
+        this.instanceId = instanceId ?? this.generateHash();
+        this.readInterval = readInterval;
+        this.storageKeyValueAdapter = new StorageKeyValueAdapter_js_1.default(storageAccess, {
+            showLogs,
+            hasEncryption,
+        });
+        this.cache = new lru_cache_1.LRUCache(lruCache);
+        this.metadataReader = new StorageMetadataReader_js_1.default({
+            storageKeyValueAdapter: this.storageKeyValueAdapter,
+            objectDeletedFlag,
+            showLogs,
+        });
+        this.contentWriter = new StorageContentWriter_js_1.default({
+            interval: writeInterval,
+            storageKeyValueAdapter: this.storageKeyValueAdapter,
+            instanceId: this.instanceId,
+            objectDeletedFlag,
+            performance: this.performance,
+            showLogs,
+        });
+        this.queueReadMetadata = new p_queue_1.default({
+            concurrency: readMetadataConcurrency || DEFAULT_READ_METADATA_CONCURRENCY,
+        });
+    }
+    generateHash(str) {
+        return (0, crypto_1.createHash)('sha256')
+            .update(str || uuid.v4())
+            .digest('hex');
+    }
+    subscribe(cb) {
+        this.pubSub.subscribe(this.eventName, cb);
+        return () => {
+            this.pubSub.unsubscribe(this.eventName, cb);
+        };
+    }
+    publish(type, message) {
+        this.pubSub.publish(this.eventName, {
+            type,
+            message,
+        });
+    }
+    async has(key) {
+        if (!this.cache.has(key)) {
+            await this.getQueue(key).add(async () => {
+                if (!this.cache.has(key)) {
+                    await this.checkUpdates(key);
+                }
+            });
+        }
+        return this.cache.has(key);
+    }
+    getEncryptionKey(key, encryptionKeyBuffer) {
+        if (!this.encryptionKeys.has(key)) {
+            if (!encryptionKeyBuffer) {
+                return null;
+            }
+            const encryptionKey = encryptionKeyBuffer.toString('base64');
+            this.encryptionKeys.set(key, encryptionKey);
+            return encryptionKey;
+        }
+        return this.encryptionKeys.get(key) || null;
+    }
+    set(key, value, encryptionKeyBuffer) {
+        if (this.contentWriter.storageWrites.get(key)?.type === StorageContentWriter_js_1.ContentWriterType.NEEDS_DELETE) {
+            throw new Error('Object has been deleted');
+        }
+        const encryptionKey = this.getEncryptionKey(key, encryptionKeyBuffer);
+        this.setByInstance(key, this.instanceId, {
+            value,
+            modifiedTs: Number.MAX_SAFE_INTEGER,
+        });
+        this.contentWriter.set(key, StorageContentWriter_js_1.ContentWriterType.NEEDS_UPLOAD, encryptionKey || undefined);
+    }
+    setByInstance(key, instanceId, value) {
+        const instances = this.cache.get(key) || new Map();
+        instances.set(instanceId, value);
+        this.cache.set(key, instances);
+    }
+    delete(key) {
+        this.cache.delete(key);
+        this.isUpdating.delete(key);
+        const encryptionKey = this.getEncryptionKey(key);
+        if (encryptionKey) {
+            this.contentWriter.set(key, StorageContentWriter_js_1.ContentWriterType.NEEDS_DELETE, encryptionKey);
+            this.encryptionKeys.delete(key);
+        }
+        else {
+            this.logger?.error(`Encryption key for key ${key} is not set`);
+        }
+        this.clearQueue(key);
+    }
+    // the first value is always the current instance, if key exists
+    async get(key, encryptionKeyBuffer) {
+        if (this.contentWriter.storageWrites.get(key)?.type === StorageContentWriter_js_1.ContentWriterType.NEEDS_DELETE ||
+            !(await this.has(key))) {
+            return null;
+        }
+        const encryptionKey = this.getEncryptionKey(key, encryptionKeyBuffer);
+        if (this.cacheHasNullInstances(key)) {
+            await this.getQueue(key).add(async () => {
+                if (this.cacheHasNullInstances(key)) {
+                    await this.fetchNullValues(key, encryptionKey || undefined);
+                }
+            });
+        }
+        const map = this.cache.get(key);
+        if (!map?.size)
+            return null;
+        const currentInstance = map.get(this.instanceId)?.value || null;
+        const otherInstances = Array.from(map.entries()).reduce((acc, [instanceId, instance]) => {
+            return instanceId !== this.instanceId ? [...acc, instance?.value || null] : acc;
+        }, []);
+        return [currentInstance, ...otherInstances];
+    }
+    getQueue(key) {
+        let queue = this.queues.get(key);
+        if (!queue) {
+            queue = new p_queue_1.default({ concurrency: 1 });
+            this.queues.set(key, queue);
+        }
+        return queue;
+    }
+    clearQueue(key) {
+        const queue = this.queues.get(key);
+        queue?.clear();
+        this.queues.delete(key);
+    }
+    cacheHasNullInstances(key) {
+        return Array.from(this.cache.get(key)?.values() || []).some((instance) => instance.value === null);
+    }
+    async fetchNullValues(key, encryptionKey) {
+        const promises = [];
+        this.cache.get(key)?.forEach((instance, instanceId) => {
+            if (instance.value === null) {
+                const fileName = `${key}/${instanceId}`;
+                const startDownload = this.performance?.now();
+                promises.push(this.storageKeyValueAdapter
+                    .get(fileName, encryptionKey)
+                    .then((file) => {
+                    if (this.performance && startDownload !== undefined) {
+                        const finishDownload = this.performance.now();
+                        logger_js_1.default.info(`Downloading took ${(finishDownload - startDownload).toFixed(1)} ms`);
+                    }
+                    this.setByInstance(key, instanceId, {
+                        ...instance,
+                        value: file,
+                    });
+                })
+                    .catch((err) => this.logger?.error({ err }, 'Error fetching content')));
+            }
+        });
+        await Promise.all(promises);
+    }
+    clear() {
+        this.cache.clear();
+        this.contentWriter.clear();
+    }
+    run() {
+        this.contentWriter.startActualizeCacheTimer(this.cache);
+        if (this.readInterval) {
+            this.startUpdatesChecking();
+        }
+    }
+    async checkUpdates(key) {
+        if (this.isUpdating.get(key) ||
+            this.contentWriter.storageWrites.get(key)?.type === StorageContentWriter_js_1.ContentWriterType.NEEDS_DELETE) {
+            return;
+        }
+        this.isUpdating.set(key, true);
+        try {
+            if (!this.cache.has(key)) {
+                this.cache.set(key, new Map());
+            }
+            const cachedByKey = this.cache.get(key);
+            const initialSize = cachedByKey.size;
+            const { updated, deleted } = await this.metadataReader.fetchInstancesUpdates(key, cachedByKey);
+            if (deleted.has(key)) {
+                this.delete(key);
+                this.publish(CacheEvents.KEY_DELETED, key);
+                return;
+            }
+            updated.forEach((storageObject, instanceId) => {
+                cachedByKey.set(instanceId, {
+                    value: null,
+                    modifiedTs: storageObject.createdAt.getTime(),
+                });
+            });
+            if (updated.size && initialSize) {
+                this.publish(CacheEvents.INSTANCES_CHANGED, key);
+            }
+            deleted.forEach((instanceId) => {
+                if (instanceId !== this.instanceId) {
+                    cachedByKey.delete(instanceId);
+                }
+            });
+            if (!cachedByKey.size) {
+                this.cache.delete(key);
+            }
+        }
+        catch (err) {
+            this.logger?.error({ err }, 'Error checking updates');
+            return;
+        }
+        finally {
+            this.isUpdating.set(key, false);
+        }
+    }
+    startUpdatesChecking() {
+        this.stopUpdatesChecking();
+        this.timeout = setTimeout(async () => {
+            Array.from(this.cache.keys()).forEach((key) => {
+                void this.queueReadMetadata.add(async () => {
+                    await this.getQueue(key).add(async () => {
+                        await this.checkUpdates(key);
+                    });
+                });
+            });
+            await this.queueReadMetadata.onIdle();
+            this.startUpdatesChecking();
+        }, this.readInterval);
+    }
+    stopUpdatesChecking() {
+        if (this.timeout)
+            clearTimeout(this.timeout);
+    }
+    stop() {
+        this.stopUpdatesChecking();
+        this.contentWriter.stop();
+    }
+    async shutdown() {
+        this.stop();
+        await this.contentWriter.shutdown(this.cache);
+    }
+}
+exports.default = StorageAdapter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StorageAdapter.js","sourceRoot":"","sources":["../../../../src/providers/storage/StorageAdapter.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,46 @@
+import { LRUCache } from 'lru-cache';
+import { CacheRecord, Performance } from './types.js';
+import StorageKeyValueAdapter from './StorageKeyValueAdapter.js';
+export interface StorageContentWriterConfig<V extends object> {
+    interval: number;
+    storageKeyValueAdapter: StorageKeyValueAdapter<V>;
+    instanceId: string;
+    objectDeletedFlag: string;
+    writeContentConcurrency?: number;
+    cacheExpirationTs?: number;
+    performance?: Performance;
+    showLogs?: boolean;
+}
+export declare enum ContentWriterType {
+    NEEDS_UPLOAD = "NEEDS_UPLOAD",
+    NEEDS_DELETE = "NEEDS_DELETE"
+}
+interface StorageWriteRecord {
+    type: ContentWriterType;
+    index: number;
+    encryptionKey?: string;
+}
+export default class StorageContentWriter<K extends string, V extends object> {
+    private timeout;
+    private readonly INTERVAL;
+    private readonly storageKeyValueAdapter;
+    private readonly logger?;
+    private readonly instanceId;
+    private readonly cacheExpirationTs;
+    private readonly objectDeletedFlag;
+    private readonly queueWriteContent;
+    private readonly performance?;
+    readonly storageWrites: Map<K, StorageWriteRecord>;
+    constructor(config: StorageContentWriterConfig<V>);
+    private actualizeCacheDelete;
+    private actualizeCacheUpload;
+    private actualizeCache;
+    private deleteOutdatedInstances;
+    startActualizeCacheTimer(cache: LRUCache<K, Map<string, CacheRecord<V>>>): void;
+    stop(): void;
+    set(key: K, type: ContentWriterType, encryptionKey?: string): void;
+    get(key: K): ContentWriterType | null;
+    clear(): void;
+    shutdown(cache: LRUCache<K, Map<string, CacheRecord<V>>>): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentWriterType = void 0;
+const p_queue_1 = __importDefault(require("p-queue"));
+const logger_js_1 = __importDefault(require("../../logger.js"));
+var ContentWriterType;
+(function (ContentWriterType) {
+    ContentWriterType["NEEDS_UPLOAD"] = "NEEDS_UPLOAD";
+    ContentWriterType["NEEDS_DELETE"] = "NEEDS_DELETE";
+})(ContentWriterType || (exports.ContentWriterType = ContentWriterType = {}));
+const DEFAULT_WRITE_CONTENT_CONCURRENCY = 16;
+const DEFAULT_CACHE_EXPIRATION_TS = 5 * 60 * 1000;
+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_js_1.default.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 p_queue_1.default({
+            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, cache, encryptionKey) {
+        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 }]) => {
+                void 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, cache, encryptionKey);
+                                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);
+    }
+}
+exports.default = StorageContentWriter;
+//# 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/cjs/providers/storage/StorageKeyValueAdapter.d.ts

@@ -0,0 +1,26 @@
+import { Encryption } from '@super-protocol/dto-js';
+import StorageAccess from '../../types/storage/StorageAccess.js';
+import StorageObject from '../../types/storage/StorageObject.js';
+import { IStorageKeyValueAdapter } from './types.js';
+export interface StorageKeyValueAdapterConfig {
+    showLogs?: boolean;
+    hasEncryption?: boolean;
+}
+export default class StorageKeyValueAdapter<V extends object> implements IStorageKeyValueAdapter<V> {
+    private readonly hasEncryption;
+    private readonly storageProvider;
+    private readonly logger?;
+    constructor(storageAccess: StorageAccess, config?: StorageKeyValueAdapterConfig);
+    protected decrypt(encryption: Encryption, key: string): Promise<V | null>;
+    protected encrypt(data: V | null, key: string): 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[]>;
+}