s3db.js 1.0.0

package/build/cache/avro.serializer.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvroSerializer = exports.CacheAvroSchema = void 0;
+const avsc_1 = __importDefault(require("avsc"));
+exports.CacheAvroSchema = avsc_1.default.Type.forSchema({
+    name: "Cache",
+    type: "record",
+    fields: [{ name: "data", type: ["string"] }],
+});
+exports.AvroSerializer = {
+    serialize: (data) => String(exports.CacheAvroSchema.toBuffer(data)),
+    unserialize: (data) => exports.CacheAvroSchema.fromBuffer(Buffer.from(data)),
+};

package/build/cache/json.serializer.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonSerializer = void 0;
+exports.JsonSerializer = {
+    serialize: (data) => JSON.stringify(data),
+    unserialize: (data) => JSON.parse(data),
+};

package/build/cache/s3-cache.class.js

@@ -0,0 +1,157 @@
+"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 __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 zlib_1 = __importDefault(require("zlib"));
+const path = __importStar(require("path"));
+const lodash_1 = require("lodash");
+const serializers_type_1 = __importDefault(require("./serializers.type"));
+const json_serializer_1 = require("./json.serializer");
+const avro_serializer_1 = require("./avro.serializer");
+class S3Cache {
+    constructor({ s3Client, compressData = true, serializer = serializers_type_1.default.json, }) {
+        this.s3Client = s3Client;
+        this.serializer = serializer;
+        this.compressData = compressData;
+        this.serializers = {
+            [serializers_type_1.default.json]: json_serializer_1.JsonSerializer,
+            [serializers_type_1.default.avro]: avro_serializer_1.AvroSerializer,
+        };
+    }
+    getKey({ params, hashed = true, additionalPrefix = "", }) {
+        let filename = Object.keys(params || {})
+            .sort()
+            .map((x) => `${x}:${params[x]}`)
+            .join("|");
+        if (filename.length === 0)
+            filename = `empty`;
+        if (additionalPrefix.length > 0) {
+            filename = additionalPrefix + `|` + filename;
+        }
+        if (hashed) {
+            filename = Buffer.from(filename)
+                .toString("base64")
+                .split("")
+                .reverse()
+                .join("");
+        }
+        filename = filename + "." + this.serializer;
+        if (this.compressData)
+            filename += ".gz";
+        return path.join("cache", filename);
+    }
+    _put({ key, data }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lengthRaw = (0, lodash_1.isString)(data)
+                ? data.length
+                : JSON.stringify(data).length;
+            let body = this.serialize({ data });
+            const lengthSerialized = body.length;
+            if (this.compressData) {
+                body = zlib_1.default.gzipSync(body);
+            }
+            const metadata = {
+                compressor: "zlib",
+                "client-id": this.s3Client.id,
+                serializer: String(this.serializer),
+                compressed: String(this.compressData),
+                "length-raw": String(lengthRaw),
+                "length-serialized": String(lengthSerialized),
+                "length-compressed": String(body.length),
+            };
+            return this.s3Client.putObject({
+                key,
+                body,
+                metadata,
+                contentEncoding: this.compressData ? "gzip" : null,
+                contentType: this.compressData
+                    ? "application/gzip"
+                    : `application/${this.serializer}`,
+            });
+        });
+    }
+    _get({ key }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.s3Client.getObject({ key });
+                if (!res.Body)
+                    return "";
+                let content = res.Body;
+                if (res.Metadata) {
+                    const { serializer, compressor, compressed } = res.Metadata;
+                    if (["true", true].includes(compressed)) {
+                        if (compressor === `zlib`) {
+                            content = zlib_1.default.unzipSync(content);
+                        }
+                    }
+                    const { data } = this.serializers[serializer].unserialize(content);
+                    return data;
+                }
+                return this.unserialize(content);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    if (error.name !== "ClientNoSuchKey") {
+                        return Promise.reject(error);
+                    }
+                }
+            }
+            return null;
+        });
+    }
+    _delete({ key }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.s3Client.deleteObject(key);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    if (error.name !== "ClientNoSuchKey") {
+                        return Promise.reject(error);
+                    }
+                }
+            }
+            return true;
+        });
+    }
+    serialize(data) {
+        return this.serializers[this.serializer].serialize(data);
+    }
+    unserialize(data) {
+        return this.serializers[this.serializer].unserialize(data);
+    }
+}
+exports.default = S3Cache;

package/build/cache/s3-resource-cache.class.js

@@ -0,0 +1,77 @@
+"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 s3_cache_class_1 = __importDefault(require("./s3-cache.class"));
+const serializers_type_1 = __importDefault(require("./serializers.type"));
+class S3ResourceCache extends s3_cache_class_1.default {
+    constructor({ resource, compressData = true, serializer = serializers_type_1.default.json, }) {
+        super({
+            s3Client: resource.s3Client,
+            compressData: compressData,
+            serializer: serializer,
+        });
+        this.resource = resource;
+    }
+    getKey({ action = "list", params }) {
+        return super.getKey({
+            params,
+            additionalPrefix: `${this.resource.name}|${action}`,
+        });
+    }
+    put({ action = "list", params, data, }) {
+        const _super = Object.create(null, {
+            _put: { get: () => super._put }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._put.call(this, {
+                data,
+                key: this.getKey({ action, params }),
+            });
+        });
+    }
+    get({ action = "list", params }) {
+        const _super = Object.create(null, {
+            _get: { get: () => super._get }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super._get.call(this, {
+                key: this.getKey({ action, params }),
+            });
+        });
+    }
+    delete({ action = "list", params }) {
+        const _super = Object.create(null, {
+            _delete: { get: () => super._delete }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this.getKey({ action, params });
+            return _super._delete.call(this, {
+                key: this.getKey({ action, params }),
+            });
+        });
+    }
+    purge() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let keys = yield this.s3Client.getAllKeys({ prefix: "cache" });
+            const key = Buffer.from(this.resource.name)
+                .toString("base64")
+                .split("")
+                .reverse()
+                .join("");
+            keys = keys.filter((k) => k.includes(key));
+            yield this.s3Client.deleteObjects(keys);
+        });
+    }
+}
+exports.default = S3ResourceCache;

package/build/cache/serializers.type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Serializers = void 0;
+exports.Serializers = {
+    json: "json",
+    avro: "avro",
+};
+exports.default = exports.Serializers;

package/build/errors.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3dbInvalidResource = exports.S3dbMissingMetadata = exports.BaseS3dbError = exports.ClientNoSuchKey = exports.BaseS3Error = exports.BaseError = void 0;
+class BaseError extends Error {
+    constructor({ bucket, message, cause }) {
+        super(message);
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        else {
+            this.stack = (new Error(message)).stack;
+        }
+        super.name = this.constructor.name;
+        this.name = this.constructor.name;
+        this.cause = cause;
+        this.thrownAt = new Date();
+    }
+    toJson() {
+        return Object.assign({}, this);
+    }
+    toString() {
+        return `${this.name} | ${this.message}`;
+    }
+}
+exports.BaseError = BaseError;
+// AWS S3 errors
+class BaseS3Error extends BaseError {
+    constructor({ bucket, message }) {
+        super({ bucket, message });
+    }
+}
+exports.BaseS3Error = BaseS3Error;
+class ClientNoSuchKey extends BaseS3Error {
+    constructor({ bucket, key }) {
+        super({ bucket, message: `Key does not exists [s3://${bucket}/${key}]` });
+        this.key = key;
+    }
+}
+exports.ClientNoSuchKey = ClientNoSuchKey;
+// Our errors
+class BaseS3dbError extends BaseError {
+    constructor({ bucket, message, cause }) {
+        super({ bucket, message, cause });
+    }
+}
+exports.BaseS3dbError = BaseS3dbError;
+class S3dbMissingMetadata extends BaseS3dbError {
+    constructor({ bucket, cause }) {
+        super({ bucket, cause, message: `Missing metadata for bucket [s3://${bucket}]` });
+    }
+}
+exports.S3dbMissingMetadata = S3dbMissingMetadata;
+class S3dbInvalidResource extends BaseS3dbError {
+    constructor({ bucket, resourceName, attributes, validation, }) {
+        super({
+            bucket,
+            message: `Resource is not valid. Name=${resourceName} [s3://${bucket}].\n${JSON.stringify(validation, null, 2)}`,
+        });
+        this.resourceName = resourceName;
+        this.attributes = attributes;
+        this.validation = validation;
+    }
+}
+exports.S3dbInvalidResource = S3dbInvalidResource;

package/build/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3db = void 0;
+const s3db_class_1 = __importDefault(require("./s3db.class"));
+exports.S3db = s3db_class_1.default;
+exports.default = s3db_class_1.default;

package/build/metadata.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/plugin.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });