@boxyhq/saml-jackson 0.2.4 → 0.3.0-beta.246

package/src/db/encrypter.js

@@ -1,36 +0,0 @@
-const crypto = require('crypto');
-
-const ALGO = 'aes-256-gcm';
-const BLOCK_SIZE = 16; // 128 bit
-
-const encrypt = (text, key) => {
-  const iv = crypto.randomBytes(BLOCK_SIZE);
-  const cipher = crypto.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,
-  };
-};
-
-const decrypt = (ciphertext, iv, tag, key) => {
-  const decipher = crypto.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;
-};
-
-module.exports = {
-  encrypt,
-  decrypt,
-};

package/src/db/mem.js

@@ -1,111 +0,0 @@
-// This is an in-memory implementation to be used with testing and prototyping only
-const dbutils = require('./utils.js');
-
-class Mem {
-  constructor(options) {
-    return (async () => {
-      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 (options.ttl) {
-        this.ttlCleanup = async () => {
-          const now = Date.now();
-          for (const k in this.ttlStore) {
-            if (this.ttlStore[k].expiresAt < now) {
-              await this.delete(
-                this.ttlStore[k].namespace,
-                this.ttlStore[k].key
-              );
-            }
-          }
-
-          this.timerId = setTimeout(this.ttlCleanup, options.ttl * 1000);
-        };
-
-        this.timerId = setTimeout(this.ttlCleanup, options.ttl * 1000);
-      }
-
-      return this;
-    })();
-  }
-
-  async get(namespace, key) {
-    let res = this.store[dbutils.key(namespace, key)];
-    if (res) {
-      return res;
-    }
-
-    return null;
-  }
-
-  async getByIndex(namespace, idx) {
-    const dbKeys = await this.indexes[dbutils.keyForIndex(namespace, idx)];
-
-    const ret = [];
-    for (const dbKey of dbKeys || []) {
-      ret.push(await this.get(namespace, dbKey));
-    }
-
-    return ret;
-  }
-
-  async put(namespace, key, val, ttl = 0, ...indexes) {
-    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);
-    }
-  }
-
-  async delete(namespace, key) {
-    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];
-  }
-}
-
-module.exports = {
-  new: async (options) => {
-    return new Mem(options);
-  },
-};

package/src/db/mongo.js

@@ -1,89 +0,0 @@
-const { MongoClient } = require('mongodb');
-const dbutils = require('./utils.js');
-
-class Mongo {
-  constructor(options) {
-    return (async () => {
-      this.client = new MongoClient(options.url);
-
-      await this.client.connect();
-      this.db = this.client.db();
-      this.collection = this.db.collection('jacksonStore');
-
-      await this.collection.createIndex({ indexes: 1 });
-      await this.collection.createIndex(
-        { expiresAt: 1 },
-        { expireAfterSeconds: 1 }
-      );
-
-      return this;
-    })();
-  }
-
-  async get(namespace, key) {
-    let res = await this.collection.findOne({
-      _id: dbutils.key(namespace, key),
-    });
-    if (res && res.value) {
-      return res.value;
-    }
-
-    return null;
-  }
-
-  async getByIndex(namespace, idx) {
-    const docs = await this.collection
-      .find({
-        indexes: dbutils.keyForIndex(namespace, idx),
-      })
-      .toArray();
-
-    const ret = [];
-    for (const doc of docs || []) {
-      ret.push(doc.value);
-    }
-
-    return ret;
-  }
-
-  async put(namespace, key, val, ttl = 0, ...indexes) {
-    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);
-    }
-
-    await this.collection.updateOne(
-      { _id: dbutils.key(namespace, key) },
-      {
-        $set: doc,
-      },
-      { upsert: true }
-    );
-  }
-
-  async delete(namespace, key) {
-    return await this.collection.deleteOne({
-      _id: dbutils.key(namespace, key),
-    });
-  }
-}
-
-module.exports = {
-  new: async (options) => {
-    return new Mongo(options);
-  },
-};

package/src/db/redis.js

@@ -1,88 +0,0 @@
-const redis = require('redis');
-const dbutils = require('./utils.js');
-
-class Redis {
-  constructor(options) {
-    return (async () => {
-      let opts = {};
-      if (options && options.url) {
-        opts.socket = {
-          url: options.url,
-        };
-      }
-      this.client = redis.createClient(opts);
-
-      this.client.on('error', (err) => console.log('Redis Client Error', err));
-
-      await this.client.connect();
-
-      return this;
-    })();
-  }
-
-  async get(namespace, key) {
-    let res = await this.client.get(dbutils.key(namespace, key));
-    if (res) {
-      return JSON.parse(res);
-    }
-
-    return null;
-  }
-
-  async getByIndex(namespace, idx) {
-    const dbKeys = await this.client.sMembers(
-      dbutils.keyForIndex(namespace, idx)
-    );
-
-    const ret = [];
-    for (const dbKey of dbKeys || []) {
-      ret.push(await this.get(namespace, dbKey));
-    }
-
-    return ret;
-  }
-
-  async put(namespace, key, val, ttl = 0, ...indexes) {
-    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);
-    }
-
-    await tx.exec();
-  }
-
-  async delete(namespace, key) {
-    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 = await this.client.sMembers(idxKey);
-
-    for (const dbKey of dbKeys || []) {
-      tx.sRem(dbKey, key);
-    }
-
-    tx.del(idxKey);
-
-    return await tx.exec();
-  }
-}
-
-module.exports = {
-  new: async (options) => {
-    return new Redis(options);
-  },
-};

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

@@ -1,42 +0,0 @@
-const EntitySchema = require('typeorm').EntitySchema;
-const JacksonIndex = require('../model/JacksonIndex.js');
-const JacksonStore = require('../model/JacksonStore.js');
-
-module.exports = new EntitySchema({
-  name: 'JacksonIndex',
-  target: JacksonIndex,
-  columns: {
-    id: {
-      primary: true,
-      generated: true,
-      type: 'int',
-    },
-    key: {
-      type: 'varchar',
-      length: 1500,
-    },
-    storeKey: {
-      type: 'varchar',
-      length: 1500,
-    }
-  },
-  relations: {
-    store: {
-      target: () => JacksonStore,
-      type: 'many-to-one',
-      inverseSide: 'indexes',
-      eager: true,
-      onDelete: 'CASCADE',
-    },
-  },
-  indices: [
-    {
-      name: '_jackson_index_key',
-      columns: ['key'],
-    },
-    {
-      name: '_jackson_index_key_store',
-      columns: ['key', 'storeKey'],
-    },
-  ],
-});

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

@@ -1,42 +0,0 @@
-const EntitySchema = require('typeorm').EntitySchema;
-const JacksonStore = require('../model/JacksonStore.js');
-
-const valueType = (type) => {
-  switch (type) {
-    case 'postgres':
-    case 'cockroachdb':
-      return 'text';
-    case 'mysql':
-    case 'mariadb':
-      return 'mediumtext';
-    default:
-      return 'varchar';
-  }
-};
-
-module.exports = (type) => {
-  return new EntitySchema({
-    name: 'JacksonStore',
-    target: JacksonStore,
-    columns: {
-      key: {
-        primary: true,
-        type: 'varchar',
-        length: 1500,
-      },
-      value: {
-        type: valueType(type),
-      },
-      iv: {
-        type: 'varchar',
-        length: 64,
-        nullable: true,
-      },
-      tag: {
-        type: 'varchar',
-        length: 64,
-        nullable: true,
-      },
-    },
-  });
-};

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

@@ -1,23 +0,0 @@
-const EntitySchema = require('typeorm').EntitySchema;
-const JacksonTTL = require('../model/JacksonTTL.js');
-
-module.exports = new EntitySchema({
-  name: 'JacksonTTL',
-  target: JacksonTTL,
-  columns: {
-    key: {
-      primary: true,
-      type: 'varchar',
-      length: 1500,
-    },
-    expiresAt: {
-      type: 'bigint',
-    },
-  },
-  indices: [
-    {
-      name: '_jackson_ttl_expires_at',
-      columns: ['expiresAt'],
-    },
-  ],
-});

package/src/db/sql/model/JacksonIndex.js

@@ -1,9 +0,0 @@
-/*export */ class JacksonIndex {
-  constructor(id, key, store) {
-    this.id = id;
-    this.key = key;
-    this.store = store;
-  }
-}
-
-module.exports = JacksonIndex;

package/src/db/sql/model/JacksonStore.js

@@ -1,10 +0,0 @@
-/*export */ class JacksonStore {
-  constructor(key, value, iv, tag) {
-    this.key = key;
-    this.value = value;
-    this.iv = iv;
-    this.tag = tag;
-  }
-}
-
-module.exports = JacksonStore;

package/src/db/sql/model/JacksonTTL.js

@@ -1,8 +0,0 @@
-/*export */ class JacksonTTL {
-  constructor(key, expiresAt) {
-    this.key = key;
-    this.expiresAt = expiresAt;
-  }
-}
-
-module.exports = JacksonTTL;

package/src/db/sql/sql.js

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

package/src/db/store.js

@@ -1,42 +0,0 @@
-const dbutils = require('./utils.js');
-
-class Store {
-  constructor(namespace, db, ttl = 0) {
-    this.namespace = namespace;
-    this.db = db;
-    this.ttl = ttl;
-  }
-
-  async get(key) {
-    return await this.db.get(this.namespace, dbutils.keyDigest(key));
-  }
-
-  async getByIndex(idx) {
-    idx.value = dbutils.keyDigest(idx.value);
-    return await this.db.getByIndex(this.namespace, idx);
-  }
-
-  async put(key, val, ...indexes) {
-    indexes = (indexes || []).map((idx) => {
-      idx.value = dbutils.keyDigest(idx.value);
-      return idx;
-    });
-    return await this.db.put(
-      this.namespace,
-      dbutils.keyDigest(key),
-      val,
-      this.ttl,
-      ...indexes
-    );
-  }
-
-  async delete(key) {
-    return await this.db.delete(this.namespace, dbutils.keyDigest(key));
-  }
-}
-
-module.exports = {
-  new: (namespace, db, ttl = 0) => {
-    return new Store(namespace, db, ttl);
-  },
-};

package/src/db/utils.js

@@ -1,30 +0,0 @@
-const Ripemd160 = require('ripemd160');
-
-const key = (namespace, k) => {
-  return namespace + ':' + k;
-};
-
-const keyForIndex = (namespace, idx) => {
-  return key(key(namespace, idx.name), idx.value);
-};
-
-const keyDigest = (k) => {
-  return new Ripemd160().update(k).digest('hex');
-};
-
-const keyFromParts = (...parts) => {
-  return parts.join(':'); // TODO: pick a better strategy, keys can collide now
-};
-
-const sleep = (ms) => {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-};
-
-module.exports = {
-  key,
-  keyForIndex,
-  keyDigest,
-  keyFromParts,
-  sleep,
-  indexPrefix: '_index',
-};