@super-protocol/sdk-js 0.15.0 → 0.15.1

package/build/providers/storage/StorageKeyValueAdapter.js

@@ -0,0 +1,152 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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_1 = __importDefault(require("./getStorageProvider"));
+const logger_1 = __importDefault(require("../../logger"));
+const Crypto_1 = __importDefault(require("../../crypto/Crypto"));
+class StorageKeyValueAdapter {
+    constructor(storageAccess) {
+        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 });
+        this.storageProvider = (0, getStorageProvider_1.default)(storageAccess);
+    }
+    decrypt(encryption, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!encryption)
+                return null;
+            if (!key)
+                throw new Error("Key cannot be empty!");
+            encryption.key = key;
+            return JSON.parse(yield Crypto_1.default.decrypt(encryption));
+        });
+    }
+    encrypt(data, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (data === undefined)
+                throw new Error("Data cannot be empty!");
+            if (!key)
+                throw new Error("Private cannot be empty!");
+            return Crypto_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,
+            });
+        });
+    }
+    downloadFromStorage(filepath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const downloadStream = yield 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")));
+        });
+    }
+    storageUpload(key, value, privateKey) {
+        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");
+            }
+            catch (err) {
+                this.logger.error({ err }, "Error uploading to storage");
+                throw err;
+            }
+        });
+    }
+    storageDelete(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield 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;
+            }
+        });
+    }
+    storageDownload(key, privateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const downloaded = yield this.downloadFromStorage(key);
+                this.logger.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({
+                    err,
+                    key,
+                }, "Error download data from storage");
+                throw err;
+            }
+        });
+    }
+    storageListFiles(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const listObjects = yield 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;
+            }
+        });
+    }
+    set(key, value, privateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storageUpload(key, value, privateKey);
+        });
+    }
+    delete(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storageDelete(key);
+        });
+    }
+    get(key, privateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storageDownload(key, privateKey);
+        });
+    }
+    listFiles(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storageListFiles(key);
+        });
+    }
+}
+exports.default = StorageKeyValueAdapter;

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

@@ -0,0 +1,19 @@
+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;
+}
+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/build/providers/storage/StorageMetadataReader.js

@@ -0,0 +1,65 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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;
+    }
+    listInstances(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storageKeyValueAdapter
+                .listFiles(`${key}/`)
+                .then((objects) => new Map(objects.map((obj) => { var _a; return [((_a = obj.name.split("/")) === null || _a === void 0 ? void 0 : _a.pop()) || obj.name, obj]; })));
+        });
+    }
+    fetchInstancesUpdates(key, currentInstances) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {
+                updated: new Map(),
+                deleted: new Set(),
+            };
+            try {
+                const directoryInstances = yield 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;

package/build/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/build/providers/storage/StorjAdapter.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 });
+        this.storageAdapter = new StorageAdapter_1.default(storageAccess, config);
+        this.storageAdapter.run();
+    }
+    subscribe(cb) {
+        var _a;
+        return (_a = this.storageAdapter) === null || _a === void 0 ? void 0 : _a.subscribe(cb);
+    }
+    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");
+                    return null;
+                }
+                throw err;
+            });
+        });
+    }
+    has(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storageAdapter.has(key);
+        });
+    }
+    set(key, value, encryptionKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storageAdapter.set(key, value, encryptionKey);
+        });
+    }
+    del(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storageAdapter.delete(key);
+        });
+    }
+    stop() {
+        this.storageAdapter.stop();
+    }
+    shutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.storageAdapter.shutdown();
+        });
+    }
+}
+exports.default = StorjAdapter;