@boxyhq/saml-jackson 0.2.3-beta.238 → 0.2.3-beta.243

package/dist/db/db.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 };
+};
+const encrypter = __importStar(require("./encrypter"));
+const mem_1 = __importDefault(require("./mem"));
+const mongo_1 = __importDefault(require("./mongo"));
+const redis_1 = __importDefault(require("./redis"));
+const sql_1 = __importDefault(require("./sql/sql"));
+const store_1 = __importDefault(require("./store"));
+const decrypt = (res, encryptionKey) => {
+    if (res.iv && res.tag) {
+        return JSON.parse(encrypter.decrypt(res.value, res.iv, res.tag, encryptionKey));
+    }
+    return JSON.parse(res.value);
+};
+class DB {
+    constructor(db, encryptionKey) {
+        this.db = db;
+        this.encryptionKey = encryptionKey;
+    }
+    get(namespace, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.db.get(namespace, key);
+            if (!res) {
+                return null;
+            }
+            return decrypt(res, this.encryptionKey);
+        });
+    }
+    getByIndex(namespace, idx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.db.getByIndex(namespace, idx);
+            const encryptionKey = this.encryptionKey;
+            return res.map((r) => {
+                return decrypt(r, encryptionKey);
+            });
+        });
+    }
+    // ttl is in seconds
+    put(namespace, key, val, ttl = 0, ...indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ttl > 0 && indexes && indexes.length > 0) {
+                throw new Error('secondary indexes not allow on a store with ttl');
+            }
+            const dbVal = this.encryptionKey
+                ? encrypter.encrypt(JSON.stringify(val), this.encryptionKey)
+                : { value: JSON.stringify(val) };
+            return yield this.db.put(namespace, key, dbVal, ttl, ...indexes);
+        });
+    }
+    delete(namespace, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.db.delete(namespace, key);
+        });
+    }
+    store(namespace, ttl = 0) {
+        return store_1.default.new(namespace, this, ttl);
+    }
+}
+module.exports = {
+    new: (options) => __awaiter(void 0, void 0, void 0, function* () {
+        const encryptionKey = options.encryptionKey
+            ? Buffer.from(options.encryptionKey, 'latin1')
+            : null;
+        switch (options.engine) {
+            case 'redis':
+                return new DB(yield redis_1.default.new(options), encryptionKey);
+            case 'sql':
+                return new DB(yield sql_1.default.new(options), encryptionKey);
+            case 'mongo':
+                return new DB(yield mongo_1.default.new(options), encryptionKey);
+            case 'mem':
+                return new DB(yield mem_1.default.new(options), encryptionKey);
+            default:
+                throw new Error('unsupported db engine: ' + options.engine);
+        }
+    }),
+};

package/dist/db/encrypter.d.ts

@@ -0,0 +1,3 @@
+import { Encrypted, EncryptionKey } from '../typings';
+export declare const encrypt: (text: string, key: EncryptionKey) => Encrypted;
+export declare const decrypt: (ciphertext: string, iv: string, tag: string, key: EncryptionKey) => string;

package/dist/db/encrypter.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decrypt = exports.encrypt = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const ALGO = 'aes-256-gcm';
+const BLOCK_SIZE = 16; // 128 bit
+const encrypt = (text, key) => {
+    const iv = crypto_1.default.randomBytes(BLOCK_SIZE);
+    const cipher = crypto_1.default.createCipheriv(ALGO, key, iv);
+    let ciphertext = cipher.update(text, 'utf8', 'base64');
+    ciphertext += cipher.final('base64');
+    return {
+        iv: iv.toString('base64'),
+        tag: cipher.getAuthTag().toString('base64'),
+        value: ciphertext,
+    };
+};
+exports.encrypt = encrypt;
+const decrypt = (ciphertext, iv, tag, key) => {
+    const decipher = crypto_1.default.createDecipheriv(ALGO, key, Buffer.from(iv, 'base64'));
+    decipher.setAuthTag(Buffer.from(tag, 'base64'));
+    let cleartext = decipher.update(ciphertext, 'base64', 'utf8');
+    cleartext += decipher.final('utf8');
+    return cleartext;
+};
+exports.decrypt = decrypt;

package/dist/db/mem.d.ts

@@ -0,0 +1,20 @@
+import { DatabaseDriver, DatabaseOption, Index, Encrypted } from '../typings';
+declare class Mem implements DatabaseDriver {
+    private options;
+    private store;
+    private indexes;
+    private cleanup;
+    private ttlStore;
+    private ttlCleanup;
+    private timerId;
+    constructor(options: DatabaseOption);
+    init(): Promise<Mem>;
+    get(namespace: string, key: string): Promise<any>;
+    getByIndex(namespace: string, idx: Index): Promise<any>;
+    put(namespace: string, key: string, val: Encrypted, ttl?: number, ...indexes: any[]): Promise<any>;
+    delete(namespace: string, key: string): Promise<any>;
+}
+declare const _default: {
+    new: (options: DatabaseOption) => Promise<Mem>;
+};
+export default _default;

package/dist/db/mem.js

@@ -0,0 +1,128 @@
+"use strict";
+// This is an in-memory implementation to be used with testing and prototyping only
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dbutils = __importStar(require("./utils"));
+class Mem {
+    constructor(options) {
+        this.options = options;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.store = {}; // map of key, value
+            this.indexes = {}; // map of key, Set
+            this.cleanup = {}; // map of indexes for cleanup when store key is deleted
+            this.ttlStore = {}; // map of key to ttl
+            if (this.options.ttl) {
+                this.ttlCleanup = () => __awaiter(this, void 0, void 0, function* () {
+                    const now = Date.now();
+                    for (const k in this.ttlStore) {
+                        if (this.ttlStore[k].expiresAt < now) {
+                            yield this.delete(this.ttlStore[k].namespace, this.ttlStore[k].key);
+                        }
+                    }
+                    if (this.options.ttl) {
+                        this.timerId = setTimeout(this.ttlCleanup, this.options.ttl * 1000);
+                    }
+                });
+                this.timerId = setTimeout(this.ttlCleanup, this.options.ttl * 1000);
+            }
+            return this;
+        });
+    }
+    get(namespace, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = this.store[dbutils.key(namespace, key)];
+            if (res) {
+                return res;
+            }
+            return null;
+        });
+    }
+    getByIndex(namespace, idx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dbKeys = yield this.indexes[dbutils.keyForIndex(namespace, idx)];
+            const ret = [];
+            for (const dbKey of dbKeys || []) {
+                ret.push(yield this.get(namespace, dbKey));
+            }
+            return ret;
+        });
+    }
+    put(namespace, key, val, ttl = 0, ...indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const k = dbutils.key(namespace, key);
+            this.store[k] = val;
+            if (ttl) {
+                this.ttlStore[k] = {
+                    namespace,
+                    key,
+                    expiresAt: Date.now() + ttl * 1000,
+                };
+            }
+            // no ttl support for secondary indexes
+            for (const idx of indexes || []) {
+                const idxKey = dbutils.keyForIndex(namespace, idx);
+                let set = this.indexes[idxKey];
+                if (!set) {
+                    set = new Set();
+                    this.indexes[idxKey] = set;
+                }
+                set.add(key);
+                const cleanupKey = dbutils.keyFromParts(dbutils.indexPrefix, k);
+                let cleanup = this.cleanup[cleanupKey];
+                if (!cleanup) {
+                    cleanup = new Set();
+                    this.cleanup[cleanupKey] = cleanup;
+                }
+                cleanup.add(idxKey);
+            }
+        });
+    }
+    delete(namespace, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const k = dbutils.key(namespace, key);
+            delete this.store[k];
+            const idxKey = dbutils.keyFromParts(dbutils.indexPrefix, k);
+            // delete secondary indexes and then the mapping of the seconary indexes
+            const dbKeys = this.cleanup[idxKey];
+            for (const dbKey of dbKeys || []) {
+                this.indexes[dbKey] && this.indexes[dbKey].delete(key);
+            }
+            delete this.cleanup[idxKey];
+            delete this.ttlStore[k];
+        });
+    }
+}
+exports.default = {
+    new: (options) => __awaiter(void 0, void 0, void 0, function* () {
+        return yield new Mem(options).init();
+    }),
+};

package/dist/db/mongo.d.ts

@@ -0,0 +1,17 @@
+import { DatabaseDriver, DatabaseOption, Encrypted, Index } from '../typings';
+declare class Mongo implements DatabaseDriver {
+    private options;
+    private client;
+    private collection;
+    private db;
+    constructor(options: DatabaseOption);
+    init(): Promise<Mongo>;
+    get(namespace: string, key: string): Promise<any>;
+    getByIndex(namespace: string, idx: Index): Promise<any>;
+    put(namespace: string, key: string, val: Encrypted, ttl?: number, ...indexes: any[]): Promise<void>;
+    delete(namespace: string, key: string): Promise<any>;
+}
+declare const _default: {
+    new: (options: DatabaseOption) => Promise<Mongo>;
+};
+export default _default;

package/dist/db/mongo.js

@@ -0,0 +1,106 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongodb_1 = require("mongodb");
+const dbutils = __importStar(require("./utils"));
+class Mongo {
+    constructor(options) {
+        this.options = options;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.client = new mongodb_1.MongoClient(this.options.url);
+            yield this.client.connect();
+            this.db = this.client.db();
+            this.collection = this.db.collection('jacksonStore');
+            yield this.collection.createIndex({ indexes: 1 });
+            yield this.collection.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 1 });
+            return this;
+        });
+    }
+    get(namespace, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.collection.findOne({
+                _id: dbutils.key(namespace, key),
+            });
+            if (res && res.value) {
+                return res.value;
+            }
+            return null;
+        });
+    }
+    getByIndex(namespace, idx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const docs = yield this.collection
+                .find({
+                indexes: dbutils.keyForIndex(namespace, idx),
+            })
+                .toArray();
+            const ret = [];
+            for (const doc of docs || []) {
+                ret.push(doc.value);
+            }
+            return ret;
+        });
+    }
+    put(namespace, key, val, ttl = 0, ...indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const doc = {
+                value: val,
+            };
+            if (ttl) {
+                doc.expiresAt = new Date(Date.now() + ttl * 1000);
+            }
+            // no ttl support for secondary indexes
+            for (const idx of indexes || []) {
+                const idxKey = dbutils.keyForIndex(namespace, idx);
+                if (!doc.indexes) {
+                    doc.indexes = [];
+                }
+                doc.indexes.push(idxKey);
+            }
+            yield this.collection.updateOne({ _id: dbutils.key(namespace, key) }, {
+                $set: doc,
+            }, { upsert: true });
+        });
+    }
+    delete(namespace, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.collection.deleteOne({
+                _id: dbutils.key(namespace, key),
+            });
+        });
+    }
+}
+exports.default = {
+    new: (options) => __awaiter(void 0, void 0, void 0, function* () {
+        return yield new Mongo(options).init();
+    }),
+};

package/dist/db/redis.d.ts

@@ -0,0 +1,15 @@
+import { DatabaseDriver, DatabaseOption, Encrypted, Index } from '../typings';
+declare class Redis implements DatabaseDriver {
+    private options;
+    private client;
+    constructor(options: DatabaseOption);
+    init(): Promise<Redis>;
+    get(namespace: string, key: string): Promise<any>;
+    getByIndex(namespace: string, idx: Index): Promise<any>;
+    put(namespace: string, key: string, val: Encrypted, ttl?: number, ...indexes: any[]): Promise<void>;
+    delete(namespace: string, key: string): Promise<any>;
+}
+declare const _default: {
+    new: (options: DatabaseOption) => Promise<Redis>;
+};
+export default _default;

package/dist/db/redis.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const redis = __importStar(require("redis"));
+const dbutils = __importStar(require("./utils"));
+class Redis {
+    constructor(options) {
+        this.options = options;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const opts = {};
+            if (this.options && this.options.url) {
+                opts['socket'] = {
+                    url: this.options.url,
+                };
+            }
+            this.client = redis.createClient(opts);
+            this.client.on('error', (err) => console.log('Redis Client Error', err));
+            yield this.client.connect();
+            return this;
+        });
+    }
+    get(namespace, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.client.get(dbutils.key(namespace, key));
+            if (res) {
+                return JSON.parse(res);
+            }
+            return null;
+        });
+    }
+    getByIndex(namespace, idx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dbKeys = yield this.client.sMembers(dbutils.keyForIndex(namespace, idx));
+            const ret = [];
+            for (const dbKey of dbKeys || []) {
+                ret.push(yield this.get(namespace, dbKey));
+            }
+            return ret;
+        });
+    }
+    put(namespace, key, val, ttl = 0, ...indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let tx = this.client.multi();
+            const k = dbutils.key(namespace, key);
+            tx = tx.set(k, JSON.stringify(val));
+            if (ttl) {
+                tx = tx.expire(k, ttl);
+            }
+            // no ttl support for secondary indexes
+            for (const idx of indexes || []) {
+                const idxKey = dbutils.keyForIndex(namespace, idx);
+                tx = tx.sAdd(idxKey, key);
+                tx = tx.sAdd(dbutils.keyFromParts(dbutils.indexPrefix, k), idxKey);
+            }
+            yield tx.exec();
+        });
+    }
+    delete(namespace, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let tx = this.client.multi();
+            const k = dbutils.key(namespace, key);
+            tx = tx.del(k);
+            const idxKey = dbutils.keyFromParts(dbutils.indexPrefix, k);
+            // delete secondary indexes and then the mapping of the seconary indexes
+            const dbKeys = yield this.client.sMembers(idxKey);
+            for (const dbKey of dbKeys || []) {
+                tx.sRem(dbKey, key);
+            }
+            tx.del(idxKey);
+            return yield tx.exec();
+        });
+    }
+}
+exports.default = {
+    new: (options) => __awaiter(void 0, void 0, void 0, function* () {
+        return yield new Redis(options).init();
+    }),
+};

package/dist/db/sql/entity/JacksonIndex.d.ts

@@ -0,0 +1,7 @@
+import { JacksonStore } from './JacksonStore';
+export declare class JacksonIndex {
+    id: number;
+    key: string;
+    storeKey: string;
+    store?: JacksonStore;
+}

package/dist/db/sql/entity/JacksonIndex.js

@@ -0,0 +1,41 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JacksonIndex = void 0;
+const JacksonStore_1 = require("./JacksonStore");
+const typeorm_1 = require("typeorm");
+let JacksonIndex = class JacksonIndex {
+};
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)()
+], JacksonIndex.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Index)('_jackson_index_key'),
+    (0, typeorm_1.Column)({
+        type: 'varchar',
+        length: 1500,
+    })
+], JacksonIndex.prototype, "key", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'varchar',
+        length: 1500,
+    })
+], JacksonIndex.prototype, "storeKey", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => JacksonStore_1.JacksonStore, undefined, {
+        //inverseSide: 'in',
+        eager: true,
+        onDelete: 'CASCADE',
+    })
+], JacksonIndex.prototype, "store", void 0);
+JacksonIndex = __decorate([
+    (0, typeorm_1.Index)('_jackson_index_key_store', ['key', 'storeKey']),
+    (0, typeorm_1.Entity)()
+], JacksonIndex);
+exports.JacksonIndex = JacksonIndex;

package/dist/db/sql/entity/JacksonStore.d.ts

@@ -0,0 +1,6 @@
+export declare class JacksonStore {
+    key: string;
+    value: string;
+    iv?: string;
+    tag?: string;
+}

package/dist/db/sql/entity/JacksonStore.js

@@ -0,0 +1,42 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JacksonStore = void 0;
+const typeorm_1 = require("typeorm");
+let JacksonStore = class JacksonStore {
+};
+__decorate([
+    (0, typeorm_1.Column)({
+        primary: true,
+        type: 'varchar',
+        length: 1500,
+    })
+], JacksonStore.prototype, "key", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'text',
+    })
+], JacksonStore.prototype, "value", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'varchar',
+        length: 64,
+        nullable: true,
+    })
+], JacksonStore.prototype, "iv", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'varchar',
+        length: 64,
+        nullable: true,
+    })
+], JacksonStore.prototype, "tag", void 0);
+JacksonStore = __decorate([
+    (0, typeorm_1.Entity)()
+], JacksonStore);
+exports.JacksonStore = JacksonStore;

package/dist/db/sql/entity/JacksonTTL.d.ts

@@ -0,0 +1,4 @@
+export declare class JacksonTTL {
+    key: string;
+    expiresAt: number;
+}

package/dist/db/sql/entity/JacksonTTL.js

@@ -0,0 +1,29 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JacksonTTL = void 0;
+const typeorm_1 = require("typeorm");
+let JacksonTTL = class JacksonTTL {
+};
+__decorate([
+    (0, typeorm_1.Column)({
+        primary: true,
+        type: 'varchar',
+        length: 1500,
+    })
+], JacksonTTL.prototype, "key", void 0);
+__decorate([
+    (0, typeorm_1.Index)('_jackson_ttl_expires_at'),
+    (0, typeorm_1.Column)({
+        type: 'bigint',
+    })
+], JacksonTTL.prototype, "expiresAt", void 0);
+JacksonTTL = __decorate([
+    (0, typeorm_1.Entity)()
+], JacksonTTL);
+exports.JacksonTTL = JacksonTTL;