@boxyhq/saml-jackson 0.2.3-beta.177 → 0.2.3-beta.210

package/src/controller/utils.js

@@ -1,19 +0,0 @@
-const indexNames = {
-  entityID: 'entityID',
-  tenantProduct: 'tenantProduct',
-};
-
-const extractAuthToken = (req) => {
-  const authHeader = req.get('authorization');
-  const parts = (authHeader || '').split(' ');
-  if (parts.length > 1) {
-    return parts[1];
-  }
-
-  return null;
-};
-
-module.exports = {
-  indexNames,
-  extractAuthToken,
-};

package/src/db/db.js

@@ -1,81 +0,0 @@
-const mem = require('./mem.js');
-const mongo = require('./mongo.js');
-const redis = require('./redis.js');
-const sql = require('./sql/sql.js');
-const store = require('./store.js');
-const encrypter = require('./encrypter.js');
-
-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;
-  }
-
-  async get(namespace, key) {
-    const res = await this.db.get(namespace, key);
-    if (!res) {
-      return null;
-    }
-
-    return decrypt(res, this.encryptionKey);
-  }
-
-  async getByIndex(namespace, idx) {
-    const res = await this.db.getByIndex(namespace, idx);
-    const encryptionKey = this.encryptionKey;
-    return res.map((r) => {
-      return decrypt(r, encryptionKey);
-    });
-  }
-
-  // ttl is in seconds
-  async put(namespace, key, val, ttl = 0, ...indexes) {
-    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 await this.db.put(namespace, key, dbVal, ttl, ...indexes);
-  }
-
-  async delete(namespace, key) {
-    return await this.db.delete(namespace, key);
-  }
-
-  store(namespace, ttl = 0) {
-    return store.new(namespace, this, ttl);
-  }
-}
-
-module.exports = {
-  new: async (options) => {
-    const encryptionKey = options.encryptionKey
-      ? Buffer.from(options.encryptionKey, 'latin1')
-      : null;
-    switch (options.engine) {
-      case 'redis':
-        return new DB(await redis.new(options), encryptionKey);
-      case 'sql':
-        return new DB(await sql.new(options), encryptionKey);
-      case 'mongo':
-        return new DB(await mongo.new(options), encryptionKey);
-      case 'mem':
-        return new DB(await mem.new(options), encryptionKey);
-      default:
-        throw new Error('unsupported db engine: ' + options.engine);
-    }
-  },
-};

package/src/db/db.test.js

@@ -1,302 +0,0 @@
-const t = require('tap');
-
-const DB = require('./db.js');
-
-const encryptionKey = '3yGrTcnKPBqqHoH3zZMAU6nt4bmIYb2q';
-
-let configStores = [];
-let ttlStores = [];
-const ttl = 3;
-
-const record1 = {
-  id: '1',
-  name: 'Deepak',
-  city: 'London',
-};
-const record2 = {
-  id: '2',
-  name: 'Sama',
-  city: 'London',
-};
-
-const memDbConfig = {
-  engine: 'mem',
-  ttl: 1,
-};
-
-const redisDbConfig = {
-  engine: 'redis',
-  url: 'redis://localhost:6379',
-};
-
-const postgresDbConfig = {
-  engine: 'sql',
-  url: 'postgresql://postgres:postgres@localhost:5432/postgres',
-  type: 'postgres',
-  ttl: 1,
-  cleanupLimit: 1,
-};
-
-const mongoDbConfig = {
-  engine: 'mongo',
-  url: 'mongodb://localhost:27017/jackson',
-};
-
-const mysqlDbConfig = {
-  engine: 'sql',
-  url: 'mysql://root:mysql@localhost:3307/mysql',
-  type: 'mysql',
-  ttl: 1,
-  cleanupLimit: 1,
-};
-
-const mariadbDbConfig = {
-  engine: 'sql',
-  url: 'mariadb://root@localhost:3306/mysql',
-  type: 'mariadb',
-  ttl: 1,
-  cleanupLimit: 1,
-};
-
-const dbs = [
-  {
-    ...memDbConfig,
-  },
-  {
-    ...memDbConfig,
-    encryptionKey,
-  },
-  {
-    ...redisDbConfig,
-  },
-  {
-    ...redisDbConfig,
-    encryptionKey,
-  },
-  {
-    ...postgresDbConfig,
-  },
-  {
-    ...postgresDbConfig,
-    encryptionKey,
-  },
-  {
-    ...mongoDbConfig,
-  },
-  {
-    ...mongoDbConfig,
-    encryptionKey,
-  },
-  {
-    ...mysqlDbConfig,
-  },
-  {
-    ...mysqlDbConfig,
-    encryptionKey,
-  },
-  {
-    ...mariadbDbConfig,
-  },
-  {
-    ...mariadbDbConfig,
-    encryptionKey,
-  },
-];
-
-t.before(async () => {
-  for (const idx in dbs) {
-    const opts = dbs[idx];
-    const db = await DB.new(opts);
-
-    configStores.push(db.store('saml:config'));
-    ttlStores.push(db.store('oauth:session', ttl));
-  }
-});
-
-t.teardown(async () => {
-  process.exit(0);
-});
-
-t.test('dbs', ({ end }) => {
-  for (const idx in configStores) {
-    const configStore = configStores[idx];
-    const ttlStore = ttlStores[idx];
-    let dbEngine = dbs[idx].engine;
-    if (dbs[idx].type) {
-      dbEngine += ': ' + dbs[idx].type;
-    }
-    t.test('put(): ' + dbEngine, async (t) => {
-      await configStore.put(
-        record1.id,
-        record1,
-        {
-          // secondary index on city
-          name: 'city',
-          value: record1.city,
-        },
-        {
-          // secondary index on name
-          name: 'name',
-          value: record1.name,
-        }
-      );
-
-      await configStore.put(
-        record2.id,
-        record2,
-        {
-          // secondary index on city
-          name: 'city',
-          value: record2.city,
-        },
-        {
-          // secondary index on name
-          name: 'name',
-          value: record2.name,
-        }
-      );
-
-      t.end();
-    });
-
-    t.test('get(): ' + dbEngine, async (t) => {
-      const ret1 = await configStore.get(record1.id);
-      const ret2 = await configStore.get(record2.id);
-
-      t.same(ret1, record1, 'unable to get record1');
-      t.same(ret2, record2, 'unable to get record2');
-
-      t.end();
-    });
-
-    t.test('getByIndex(): ' + dbEngine, async (t) => {
-      const ret1 = await configStore.getByIndex({
-        name: 'name',
-        value: record1.name,
-      });
-
-      const ret2 = await configStore.getByIndex({
-        name: 'city',
-        value: record1.city,
-      });
-
-      t.same(ret1, [record1], 'unable to get index "name"');
-      t.same(
-        ret2.sort((a, b) => a.id.localeCompare(b.id)),
-        [record1, record2].sort((a, b) => a.id.localeCompare(b.id)),
-        'unable to get index "city"'
-      );
-
-      t.end();
-    });
-
-    t.test('delete(): ' + dbEngine, async (t) => {
-      await configStore.delete(record1.id);
-
-      const ret0 = await configStore.getByIndex({
-        name: 'city',
-        value: record1.city,
-      });
-
-      t.same(ret0, [record2], 'unable to get index "city" after delete');
-
-      await configStore.delete(record2.id);
-
-      const ret1 = await configStore.get(record1.id);
-      const ret2 = await configStore.get(record2.id);
-
-      const ret3 = await configStore.getByIndex({
-        name: 'name',
-        value: record1.name,
-      });
-      const ret4 = await configStore.getByIndex({
-        name: 'city',
-        value: record1.city,
-      });
-
-      t.same(ret1, null, 'delete for record1 failed');
-      t.same(ret2, null, 'delete for record2 failed');
-
-      t.same(ret3, [], 'delete for record1 failed');
-      t.same(ret4, [], 'delete for record2 failed');
-
-      t.end();
-    });
-
-    t.test('ttl indexes: ' + dbEngine, async (t) => {
-      try {
-        await ttlStore.put(
-          record1.id,
-          record1,
-          {
-            // secondary index on city
-            name: 'city',
-            value: record1.city,
-          },
-          {
-            // secondary index on name
-            name: 'name',
-            value: record1.name,
-          }
-        );
-
-        t.fail('expecting a secondary indexes not allow on a store with ttl');
-      } catch (err) {
-        t.ok(err, 'got expected error');
-      }
-
-      t.end();
-    });
-
-    t.test('ttl put(): ' + dbEngine, async (t) => {
-      await ttlStore.put(record1.id, record1);
-
-      await ttlStore.put(record2.id, record2);
-
-      t.end();
-    });
-
-    t.test('ttl get(): ' + dbEngine, async (t) => {
-      const ret1 = await ttlStore.get(record1.id);
-      const ret2 = await ttlStore.get(record2.id);
-
-      t.same(ret1, record1, 'unable to get record1');
-      t.same(ret2, record2, 'unable to get record2');
-
-      t.end();
-    });
-
-    t.test('ttl expiry: ' + dbEngine, async (t) => {
-      // mongo runs ttl task every 60 seconds
-      if (dbEngine.startsWith('mongo')) {
-        t.end();
-        return;
-      }
-
-      await new Promise((resolve) =>
-        setTimeout(resolve, (2 * ttl + 0.5) * 1000)
-      );
-
-      const ret1 = await ttlStore.get(record1.id);
-      const ret2 = await ttlStore.get(record2.id);
-
-      t.same(ret1, null, 'ttl for record1 failed');
-      t.same(ret2, null, 'ttl for record2 failed');
-
-      t.end();
-    });
-  }
-
-  t.test('db.new() error', async (t) => {
-    try {
-      await DB.new('somedb');
-      t.fail('expecting an unsupported db error');
-    } catch (err) {
-      t.ok(err, 'got expected error');
-    }
-
-    t.end();
-  });
-
-  end();
-});

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);
-  },
-};