@boxyhq/saml-jackson 0.2.4-beta.198 → 0.3.0-beta.248

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;

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

@@ -0,0 +1,20 @@
+import { DatabaseDriver, DatabaseOption, Index, Encrypted } from '../../typings';
+declare class Sql implements DatabaseDriver {
+    private options;
+    private connection;
+    private storeRepository;
+    private indexRepository;
+    private ttlRepository;
+    private ttlCleanup;
+    private timerId;
+    constructor(options: DatabaseOption);
+    init(): Promise<Sql>;
+    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<Sql>;
+};
+export default _default;

package/dist/db/sql/sql.js

@@ -0,0 +1,174 @@
+"use strict";
+/*eslint no-constant-condition: ["error", { "checkLoops": false }]*/
+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 });
+require('reflect-metadata');
+const typeorm_1 = require("typeorm");
+const dbutils = __importStar(require("../utils"));
+const JacksonStore_1 = require("./entity/JacksonStore");
+const JacksonIndex_1 = require("./entity/JacksonIndex");
+const JacksonTTL_1 = require("./entity/JacksonTTL");
+class Sql {
+    constructor(options) {
+        this.options = options;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (true) {
+                try {
+                    this.connection = yield (0, typeorm_1.createConnection)({
+                        name: this.options.type + Math.floor(Math.random() * 100000),
+                        type: this.options.type,
+                        url: this.options.url,
+                        synchronize: true,
+                        migrationsTableName: '_jackson_migrations',
+                        logging: ['error'],
+                        entities: [JacksonStore_1.JacksonStore, JacksonIndex_1.JacksonIndex, JacksonTTL_1.JacksonTTL],
+                    });
+                    break;
+                }
+                catch (err) {
+                    console.error(`error connecting to ${this.options.type} db: ${err}`);
+                    yield dbutils.sleep(1000);
+                    continue;
+                }
+            }
+            this.storeRepository = this.connection.getRepository(JacksonStore_1.JacksonStore);
+            this.indexRepository = this.connection.getRepository(JacksonIndex_1.JacksonIndex);
+            this.ttlRepository = this.connection.getRepository(JacksonTTL_1.JacksonTTL);
+            if (this.options.ttl && this.options.cleanupLimit) {
+                this.ttlCleanup = () => __awaiter(this, void 0, void 0, function* () {
+                    const now = Date.now();
+                    while (true) {
+                        const ids = yield this.ttlRepository
+                            .createQueryBuilder('jackson_ttl')
+                            .limit(this.options.cleanupLimit)
+                            .where('jackson_ttl.expiresAt <= :expiresAt', {
+                            expiresAt: now,
+                        })
+                            .getMany();
+                        if (ids.length <= 0) {
+                            break;
+                        }
+                        const delIds = ids.map((id) => {
+                            return id.key;
+                        });
+                        yield this.storeRepository.remove(ids);
+                        yield this.ttlRepository.delete(delIds);
+                    }
+                    this.timerId = setTimeout(this.ttlCleanup, this.options.ttl * 1000);
+                });
+                this.timerId = setTimeout(this.ttlCleanup, this.options.ttl * 1000);
+            }
+            else {
+                console.log('Warning: ttl cleanup not enabled, set both "ttl" and "cleanupLimit" options to enable it!');
+            }
+            return this;
+        });
+    }
+    get(namespace, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let res = yield this.storeRepository.findOne({
+                key: dbutils.key(namespace, key),
+            });
+            if (res && res.value) {
+                return {
+                    value: res.value,
+                    iv: res.iv,
+                    tag: res.tag,
+                };
+            }
+            return null;
+        });
+    }
+    getByIndex(namespace, idx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.indexRepository.find({
+                key: dbutils.keyForIndex(namespace, idx),
+            });
+            const ret = [];
+            if (res) {
+                res.forEach((r) => {
+                    ret.push({
+                        value: r.store.value,
+                        iv: r.store.iv,
+                        tag: r.store.tag,
+                    });
+                });
+            }
+            return ret;
+        });
+    }
+    put(namespace, key, val, ttl = 0, ...indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.connection.transaction((transactionalEntityManager) => __awaiter(this, void 0, void 0, function* () {
+                const dbKey = dbutils.key(namespace, key);
+                const store = new JacksonStore_1.JacksonStore();
+                store.key = dbKey;
+                store.value = val.value;
+                store.iv = val.iv;
+                store.tag = val.tag;
+                yield transactionalEntityManager.save(store);
+                if (ttl) {
+                    const ttlRec = new JacksonTTL_1.JacksonTTL();
+                    ttlRec.key = dbKey;
+                    ttlRec.expiresAt = Date.now() + ttl * 1000;
+                    yield transactionalEntityManager.save(ttlRec);
+                }
+                // no ttl support for secondary indexes
+                for (const idx of indexes || []) {
+                    const key = dbutils.keyForIndex(namespace, idx);
+                    const rec = yield this.indexRepository.findOne({
+                        key,
+                        storeKey: store.key,
+                    });
+                    if (!rec) {
+                        const ji = new JacksonIndex_1.JacksonIndex();
+                        ji.key = key;
+                        ji.store = store;
+                        yield transactionalEntityManager.save(ji);
+                    }
+                }
+            }));
+        });
+    }
+    delete(namespace, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.storeRepository.remove({
+                key: dbutils.key(namespace, key),
+            });
+        });
+    }
+}
+exports.default = {
+    new: (options) => __awaiter(void 0, void 0, void 0, function* () {
+        return yield new Sql(options).init();
+    }),
+};

package/dist/db/store.d.ts

@@ -0,0 +1,5 @@
+import { Storable } from '../typings';
+declare const _default: {
+    new: (namespace: string, db: any, ttl?: number) => Storable;
+};
+export default _default;

package/dist/db/store.js

@@ -0,0 +1,68 @@
+"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 dbutils = __importStar(require("./utils"));
+class Store {
+    constructor(namespace, db, ttl = 0) {
+        this.namespace = namespace;
+        this.db = db;
+        this.ttl = ttl;
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.db.get(this.namespace, dbutils.keyDigest(key));
+        });
+    }
+    getByIndex(idx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            idx.value = dbutils.keyDigest(idx.value);
+            return yield this.db.getByIndex(this.namespace, idx);
+        });
+    }
+    put(key, val, ...indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            indexes = (indexes || []).map((idx) => {
+                idx.value = dbutils.keyDigest(idx.value);
+                return idx;
+            });
+            return yield this.db.put(this.namespace, dbutils.keyDigest(key), val, this.ttl, ...indexes);
+        });
+    }
+    delete(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.db.delete(this.namespace, dbutils.keyDigest(key));
+        });
+    }
+}
+exports.default = {
+    new: (namespace, db, ttl = 0) => {
+        return new Store(namespace, db, ttl);
+    },
+};

package/dist/db/utils.d.ts

@@ -0,0 +1,7 @@
+import { Index } from '../typings';
+export declare const key: (namespace: string, k: string) => string;
+export declare const keyForIndex: (namespace: string, idx: Index) => string;
+export declare const keyDigest: (k: string) => string;
+export declare const keyFromParts: (...parts: string[]) => string;
+export declare const sleep: (ms: number) => Promise<void>;
+export declare const indexPrefix = "_index";

package/dist/db/utils.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.indexPrefix = exports.sleep = exports.keyFromParts = exports.keyDigest = exports.keyForIndex = exports.key = void 0;
+const ripemd160_1 = __importDefault(require("ripemd160"));
+const key = (namespace, k) => {
+    return namespace + ':' + k;
+};
+exports.key = key;
+const keyForIndex = (namespace, idx) => {
+    return (0, exports.key)((0, exports.key)(namespace, idx.name), idx.value);
+};
+exports.keyForIndex = keyForIndex;
+const keyDigest = (k) => {
+    return new ripemd160_1.default().update(k).digest('hex');
+};
+exports.keyDigest = keyDigest;
+const keyFromParts = (...parts) => {
+    // TODO: pick a better strategy, keys can collide now
+    return parts.join(':');
+};
+exports.keyFromParts = keyFromParts;
+const sleep = (ms) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+};
+exports.sleep = sleep;
+exports.indexPrefix = '_index';