@super-protocol/sdk-js 0.15.1 → 0.15.2-beta.0

package/build/providers/storage/ChunksDownloadDecorator.d.ts

@@ -32,5 +32,5 @@ export declare class DownloadDecorator implements IStorageProvider {
     deleteObject(remotePath: string): Promise<void>;
     listObjects(remotePath: string): Promise<StorageObject[]>;
     getObjectSize(remotePath: string): Promise<number>;
-    getLastModified(remotePath: string): Promise<Date>;
+    getLastModified(remotePath: string): Promise<Date | null>;
 }

package/build/providers/storage/IStorageProvider.d.ts

@@ -11,5 +11,5 @@ export default interface IStorageProvider {
     deleteObject(remotePath: string): Promise<void>;
     listObjects(remotePath: string): Promise<StorageObject[]>;
     getObjectSize(remotePath: string): Promise<number>;
-    getLastModified(remotePath: string): Promise<Date>;
+    getLastModified(remotePath: string): Promise<Date | null>;
 }

package/build/providers/storage/StorageAdapter.d.ts

@@ -11,17 +11,17 @@ export interface StorageAdapterConfig {
     objectDeletedFlag: string;
     readMetadataConcurrency?: number;
     performance?: Performance;
+    showLogs?: boolean;
 }
 export declare enum CacheEvents {
-    INSTANCES_CHANGED = "MESSAGES_CHANGED",
+    INSTANCES_CHANGED = "INSTANCES_CHANGED",
     KEY_DELETED = "KEY_DELETED"
 }
 export default class StorageAdapter<V extends object> {
-    private readonly logger;
+    private readonly logger?;
     private readonly storageKeyValueAdapter;
     private readonly cache;
     private readonly encryptionKeys;
-    private readonly deleted;
     private readonly contentWriter;
     private readonly metadataReader;
     private readonly instanceId;

package/build/providers/storage/StorageAdapter.js

@@ -46,29 +46,29 @@ const logger_1 = __importDefault(require("../../logger"));
 const PubSub_1 = __importDefault(require("../../utils/PubSub"));
 var CacheEvents;
 (function (CacheEvents) {
-    CacheEvents["INSTANCES_CHANGED"] = "MESSAGES_CHANGED";
+    CacheEvents["INSTANCES_CHANGED"] = "INSTANCES_CHANGED";
     CacheEvents["KEY_DELETED"] = "KEY_DELETED";
 })(CacheEvents = exports.CacheEvents || (exports.CacheEvents = {}));
 const DEFAULT_READ_METADATA_CONCUREENCY = 16;
 class StorageAdapter {
     constructor(storageAccess, config) {
         this.encryptionKeys = new Map(); // key -> encryption key (base64)
-        this.deleted = new Set();
         this.timeout = null;
         this.queues = new Map();
         this.isUpdating = new Map();
         this.pubSub = new PubSub_1.default();
         this.eventName = "storage-adapter";
-        this.logger = logger_1.default.child({ class: StorageAdapter.name });
-        const { readInterval, writeInterval, lruCache, objectDeletedFlag, readMetadataConcurrency, performance } = config;
+        const { readInterval, writeInterval, lruCache, objectDeletedFlag, readMetadataConcurrency, performance, showLogs = true, } = config;
+        this.logger = showLogs ? logger_1.default.child({ class: StorageAdapter.name }) : null;
         this.performance = performance;
         this.instanceId = this.generateHash();
         this.readInterval = readInterval;
-        this.storageKeyValueAdapter = new StorageKeyValueAdapter_1.default(storageAccess);
+        this.storageKeyValueAdapter = new StorageKeyValueAdapter_1.default(storageAccess, { showLogs });
         this.cache = new lru_cache_1.LRUCache(lruCache);
         this.metadataReader = new StorageMetadataReader_1.default({
             storageKeyValueAdapter: this.storageKeyValueAdapter,
             objectDeletedFlag,
+            showLogs,
         });
         this.contentWriter = new StorageContentWriter_1.default({
             interval: writeInterval,
@@ -76,6 +76,7 @@ class StorageAdapter {
             instanceId: this.instanceId,
             objectDeletedFlag,
             performance: this.performance,
+            showLogs,
         });
         this.queueReadMetadata = new p_queue_1.default({
             concurrency: readMetadataConcurrency || DEFAULT_READ_METADATA_CONCUREENCY,
@@ -123,8 +124,9 @@ class StorageAdapter {
         return this.encryptionKeys.get(key) || null;
     }
     set(key, value, encryptionKeyBuffer) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.deleted.has(key)) {
+            if (((_a = this.contentWriter.storageWrites.get(key)) === null || _a === void 0 ? void 0 : _a.type) === StorageContentWriter_1.ContentWriterType.NEEDS_DELETE) {
                 throw new Error("Object has been deleted");
             }
             const encryptionKey = this.getEnryptionKey(key, encryptionKeyBuffer);
@@ -143,8 +145,8 @@ class StorageAdapter {
         this.cache.set(key, instances);
     }
     delete(key) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.deleted.add(key);
             this.cache.delete(key);
             this.isUpdating.delete(key);
             const encryptionKey = this.getEnryptionKey(key);
@@ -153,18 +155,19 @@ class StorageAdapter {
                 this.encryptionKeys.delete(key);
             }
             else {
-                this.logger.error(`Encryption key for key ${key} is not set`);
+                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error(`Encryption key for key ${key} is not set`);
             }
             this.clearQueue(key);
         });
     }
     // the first value is always the current instance, if key exists
     get(key, encryptionKeyBuffer) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (!encryptionKeyBuffer)
                 throw new Error("Encryption key required");
-            if (this.deleted.has(key) || !(yield this.has(key))) {
+            if (((_a = this.contentWriter.storageWrites.get(key)) === null || _a === void 0 ? void 0 : _a.type) === StorageContentWriter_1.ContentWriterType.NEEDS_DELETE ||
+                !(yield this.has(key))) {
                 return null;
             }
             const encryptionKey = this.getEnryptionKey(key, encryptionKeyBuffer);
@@ -180,7 +183,7 @@ class StorageAdapter {
             const map = this.cache.get(key);
             if (!(map === null || map === void 0 ? void 0 : map.size))
                 return null;
-            const currentInstance = ((_a = map.get(this.instanceId)) === null || _a === void 0 ? void 0 : _a.value) || null;
+            const currentInstance = ((_b = map.get(this.instanceId)) === null || _b === void 0 ? void 0 : _b.value) || null;
             const otherInstances = Array.from(map.entries()).reduce((acc, [instanceId, instance]) => {
                 return instanceId !== this.instanceId ? [...acc, (instance === null || instance === void 0 ? void 0 : instance.value) || null] : acc;
             }, []);
@@ -222,7 +225,7 @@ class StorageAdapter {
                         }
                         this.setByInstance(key, instanseId, Object.assign(Object.assign({}, instance), { value: file }));
                     })
-                        .catch((err) => this.logger.error({ err }, "Error fetching content")));
+                        .catch((err) => { var _a; return (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error({ err }, "Error fetching content"); }));
                 }
             });
             yield Promise.all(promises);
@@ -239,8 +242,10 @@ class StorageAdapter {
         }
     }
     checkUpdates(key) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.isUpdating.get(key) || this.deleted.has(key)) {
+            if (this.isUpdating.get(key) ||
+                ((_a = this.contentWriter.storageWrites.get(key)) === null || _a === void 0 ? void 0 : _a.type) === StorageContentWriter_1.ContentWriterType.NEEDS_DELETE) {
                 return;
             }
             this.isUpdating.set(key, true);
@@ -275,7 +280,7 @@ class StorageAdapter {
                 }
             }
             catch (err) {
-                this.logger.error({ err }, "Error checking updates");
+                (_b = this.logger) === null || _b === void 0 ? void 0 : _b.error({ err }, "Error checking updates");
                 return;
             }
             finally {

package/build/providers/storage/StorageContentWriter.d.ts

@@ -9,22 +9,28 @@ export interface StorageContentWriterConfig<V extends object> {
     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 storageWrites;
+    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;
@@ -37,3 +43,4 @@ export default class StorageContentWriter<K extends string, V extends object> {
     clear(): void;
     shutdown(cache: LRUCache<K, Map<string, CacheRecord<V>>>): Promise<void>;
 }
+export {};

package/build/providers/storage/StorageContentWriter.js

@@ -26,8 +26,8 @@ class StorageContentWriter {
     constructor(config) {
         this.timeout = null;
         this.storageWrites = new Map();
-        this.logger = logger_1.default.child({ class: StorageContentWriter.name });
-        const { writeContentConcurrency, interval, storageKeyValueAdapter, instanceId, objectDeletedFlag, cacheExpirationTs, performance, } = config || {};
+        const { writeContentConcurrency, interval, storageKeyValueAdapter, instanceId, objectDeletedFlag, cacheExpirationTs, performance, showLogs = true, } = config || {};
+        this.logger = showLogs ? logger_1.default.child({ class: StorageContentWriter.name }) : null;
         this.performance = performance;
         this.INTERVAL = interval;
         this.cacheExpirationTs = cacheExpirationTs || DEFAULT_CACHE_EXPIRATION_TS;
@@ -49,12 +49,12 @@ class StorageContentWriter {
         });
     }
     actualizeCacheUpload(key, encryptionKey, cache) {
-        var _a;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const instances = cache.get(key);
             const instance = instances === null || instances === void 0 ? void 0 : instances.get(this.instanceId);
             if (!instances || !instance) {
-                logger_1.default.error({
+                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error({
                     key,
                     instancesSize: instances === null || instances === void 0 ? void 0 : instances.size,
                     value: instance,
@@ -62,19 +62,20 @@ class StorageContentWriter {
                 return;
             }
             if (instance.value) {
-                const startUpload = (_a = this.performance) === null || _a === void 0 ? void 0 : _a.now();
+                const startUpload = (_b = this.performance) === null || _b === void 0 ? void 0 : _b.now();
                 yield this.storageKeyValueAdapter.set(`${key}/${this.instanceId}`, instance.value, encryptionKey);
                 if (this.performance && startUpload !== undefined) {
                     const finishUpload = this.performance.now();
-                    logger_1.default.info(`Uploading took ${(finishUpload - startUpload).toFixed(1)} ms`);
+                    (_c = this.logger) === null || _c === void 0 ? void 0 : _c.info(`Uploading took ${(finishUpload - startUpload).toFixed(1)} ms`);
                 }
             }
             yield this.deleteOutdatedInstances(key, instances);
         });
     }
     actualizeCache(cache) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const logger = this.logger.child({ method: this.actualizeCache.name });
+            const logger = (_a = this.logger) === null || _a === void 0 ? void 0 : _a.child({ method: this.actualizeCache.name });
             if (this.storageWrites.size) {
                 Array.from(this.storageWrites.entries()).forEach(([key, { type, index, encryptionKey }]) => {
                     this.queueWriteContent.add(() => __awaiter(this, void 0, void 0, function* () {
@@ -96,7 +97,7 @@ class StorageContentWriter {
                             }
                         }
                         catch (err) {
-                            logger.error({
+                            logger === null || logger === void 0 ? void 0 : logger.error({
                                 err,
                                 size: this.storageWrites.size,
                             }, `Error storage writing ${key}`);
@@ -104,7 +105,7 @@ class StorageContentWriter {
                     }));
                 });
                 yield this.queueWriteContent.onIdle();
-                logger.info({ size: this.storageWrites.size }, "Success storage writing");
+                logger === null || logger === void 0 ? void 0 : logger.info({ size: this.storageWrites.size }, "Success storage writing");
             }
         });
     }
@@ -138,7 +139,7 @@ class StorageContentWriter {
                 .then(() => {
                 instances.delete(instanceId);
             })
-                .catch((err) => this.logger.error({ err }, "Error deleting outdated instance"))));
+                .catch((err) => { var _a; return (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error({ err }, "Error deleting outdated instance"); })));
         });
     }
     startActualizeCacheTimer(cache) {

package/build/providers/storage/StorageKeyValueAdapter.d.ts

@@ -1,10 +1,13 @@
 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);
+    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;

package/build/providers/storage/StorageKeyValueAdapter.js

@@ -18,10 +18,11 @@ const getStorageProvider_1 = __importDefault(require("./getStorageProvider"));
 const logger_1 = __importDefault(require("../../logger"));
 const Crypto_1 = __importDefault(require("../../crypto/Crypto"));
 class StorageKeyValueAdapter {
-    constructor(storageAccess) {
+    constructor(storageAccess, config) {
         if (!(storageAccess === null || storageAccess === void 0 ? void 0 : storageAccess.credentials))
             throw new Error("Credentials is empty");
-        this.logger = logger_1.default.child({ class: StorageKeyValueAdapter.name });
+        const { showLogs = true } = config || {};
+        this.logger = showLogs ? logger_1.default.child({ class: StorageKeyValueAdapter.name }) : null;
         this.storageProvider = (0, getStorageProvider_1.default)(storageAccess);
     }
     decrypt(encryption, key) {
@@ -65,43 +66,46 @@ class StorageKeyValueAdapter {
         });
     }
     storageUpload(key, value, privateKey) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const encryptedValue = yield this.encrypt(value, privateKey);
                 const buffer = Buffer.from(JSON.stringify(encryptedValue));
                 yield this.storageProvider.uploadFile(stream_1.Readable.from(buffer), key, buffer.byteLength);
-                this.logger.info({ data: key }, "Success uploading to storage");
+                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info({ data: key }, "Success uploading to storage");
             }
             catch (err) {
-                this.logger.error({ err }, "Error uploading to storage");
+                (_b = this.logger) === null || _b === void 0 ? void 0 : _b.error({ err }, "Error uploading to storage");
                 throw err;
             }
         });
     }
     storageDelete(key) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 yield this.storageProvider.deleteObject(key);
-                this.logger.info({ data: key }, "Success deleting from storage");
+                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info({ data: key }, "Success deleting from storage");
             }
             catch (err) {
-                this.logger.info({ err }, "Error deleting from storage");
+                (_b = this.logger) === null || _b === void 0 ? void 0 : _b.info({ err }, "Error deleting from storage");
                 throw err;
             }
         });
     }
     storageDownload(key, privateKey) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const downloaded = yield this.downloadFromStorage(key);
-                this.logger.info({ key }, "Success download data from storage");
+                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info({ key }, "Success download data from storage");
                 if (!downloaded)
                     return null;
                 const decryptedValue = yield this.decrypt(JSON.parse(downloaded), privateKey);
                 return decryptedValue;
             }
             catch (err) {
-                this.logger.info({
+                (_b = this.logger) === null || _b === void 0 ? void 0 : _b.info({
                     err,
                     key,
                 }, "Error download data from storage");
@@ -110,17 +114,18 @@ class StorageKeyValueAdapter {
         });
     }
     storageListFiles(key) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const listObjects = yield this.storageProvider.listObjects(key);
-                this.logger.trace({
+                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.trace({
                     data: listObjects,
                     key,
                 }, "Success list objects from storage");
                 return listObjects.filter((obj) => !obj.isFolder);
             }
             catch (err) {
-                this.logger.info({
+                (_b = this.logger) === null || _b === void 0 ? void 0 : _b.info({
                     err,
                     key,
                 }, "Error list objects from storage");

package/build/providers/storage/StorageMetadataReader.d.ts

@@ -8,9 +8,10 @@ export interface InstancesUpdates {
 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 logger?;
     private readonly storageKeyValueAdapter;
     private readonly objectDeletedFlag;
     constructor(config: StorageMetadataReaderConfig<V>);

package/build/providers/storage/StorageMetadataReader.js

@@ -15,9 +15,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const logger_1 = __importDefault(require("../../logger"));
 class StorageMetadataReader {
     constructor(config) {
-        this.logger = logger_1.default.child({ class: StorageMetadataReader.name });
-        this.storageKeyValueAdapter = config.storageKeyValueAdapter;
-        this.objectDeletedFlag = config.objectDeletedFlag;
+        const { showLogs = true, objectDeletedFlag, storageKeyValueAdapter } = config;
+        this.logger = showLogs ? logger_1.default.child({ class: StorageMetadataReader.name }) : null;
+        this.storageKeyValueAdapter = storageKeyValueAdapter;
+        this.objectDeletedFlag = objectDeletedFlag;
     }
     listInstances(key) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -27,6 +28,7 @@ class StorageMetadataReader {
         });
     }
     fetchInstancesUpdates(key, currentInstances) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const result = {
                 updated: new Map(),
@@ -49,14 +51,14 @@ class StorageMetadataReader {
                         result.deleted.add(instanceId);
                     }
                 });
-                this.logger.trace({
+                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.trace({
                     updated: result.updated.size,
                     deleted: result.deleted.size,
                 }, "Check result");
                 return result;
             }
             catch (error) {
-                this.logger.error({ error }, "Error fetching remote copy");
+                (_b = this.logger) === null || _b === void 0 ? void 0 : _b.error({ error }, "Error fetching remote copy");
                 return result;
             }
         });

package/build/providers/storage/StorjAdapter.d.ts

@@ -4,7 +4,7 @@ import { StorageAdapterConfig, CacheEvents } from "./StorageAdapter";
 export type StorjConfig = StorageAdapterConfig;
 export default class StorjAdapter<V extends object> {
     private storageAdapter;
-    private readonly logger;
+    private readonly logger?;
     constructor(storageAccess: StorageAccess, config: StorjConfig);
     subscribe(cb: (props: {
         type: CacheEvents;

package/build/providers/storage/StorjAdapter.js

@@ -16,7 +16,8 @@ const logger_1 = __importDefault(require("../../logger"));
 const StorageAdapter_1 = __importDefault(require("./StorageAdapter"));
 class StorjAdapter {
     constructor(storageAccess, config) {
-        this.logger = logger_1.default.child({ class: StorjAdapter.name });
+        const { showLogs = true } = config || {};
+        this.logger = showLogs ? logger_1.default.child({ class: StorjAdapter.name }) : null;
         this.storageAdapter = new StorageAdapter_1.default(storageAccess, config);
         this.storageAdapter.run();
     }
@@ -27,8 +28,10 @@ class StorjAdapter {
     get(key, encryptionKey) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.storageAdapter.get(key, encryptionKey).catch((err) => {
-                if (err.message.includes("object not found")) {
-                    this.logger.info({ key }, "Object not found");
+                var _a, _b;
+                const message = ((_a = err.message) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || "";
+                if (message.includes("object not found") || message.includes("object has been deleted")) {
+                    (_b = this.logger) === null || _b === void 0 ? void 0 : _b.info({ key }, "Object not found");
                     return null;
                 }
                 throw err;
@@ -42,7 +45,15 @@ class StorjAdapter {
     }
     set(key, value, encryptionKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.storageAdapter.set(key, value, encryptionKey);
+            return this.storageAdapter.set(key, value, encryptionKey).catch((err) => {
+                var _a, _b;
+                const message = ((_a = err.message) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || "";
+                if (message.includes("object has been deleted")) {
+                    (_b = this.logger) === null || _b === void 0 ? void 0 : _b.info({ key }, "Object has been deleted");
+                    return;
+                }
+                throw err;
+            });
         });
     }
     del(key) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@super-protocol/sdk-js",
-  "version": "0.15.1",
+  "version": "0.15.2-beta.0",
   "main": "build/index.js",
   "license": "MIT",
   "files": [