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

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

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