@boxyhq/saml-jackson 0.1.3 → 0.1.4-beta.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boxyhq/saml-jackson",
-  "version": "0.1.3",
+  "version": "0.1.4-beta.88",
   "license": "Apache 2.0",
   "description": "SAML 2.0 service",
   "main": "src/index.js",
@@ -20,7 +20,7 @@
     "calendso": "cross-env DB_URL=postgresql://postgres:postgres@localhost:5450/calendso nodemon src/jackson.js",
     "mongo": "cross-env DB_ENGINE=mongo DB_URL=mongodb://localhost:27017/jackson nodemon src/jackson.js",
     "pre-loaded": "cross-env DB_ENGINE=mem PRE_LOADED_CONFIG='./_config' nodemon src/jackson.js",
-    "test": "tap src/**/*.test.js",
+    "test": "tap --timeout=100 src/**/*.test.js",
     "dev-dbs": "docker-compose -f ./_dev/docker-compose.yml up -d"
   },
   "tap": {

package/src/controller/oauth.js

@@ -28,10 +28,16 @@ const extractBearerToken = (req) => {
 function getEncodedClientId(client_id) {
   try {
     const sp = new URLSearchParams(client_id);
-    return {
-      tenant: sp.get('tenant'),
-      product: sp.get('product'),
-    };
+    const tenant = sp.get('tenant');
+    const product = sp.get('product');
+    if (tenant && product) {
+      return {
+        tenant: sp.get('tenant'),
+        product: sp.get('product'),
+      };
+    }
+
+    return null;
   } catch (err) {
     return null;
   }
@@ -287,7 +293,7 @@ const token = async (req, res) => {
   res.json({
     access_token: token,
     token_type: 'bearer',
-    expires_in: 300,
+    expires_in: options.db.ttl,
   });
 };
 

package/src/db/db.js

@@ -19,7 +19,7 @@ class DB {
 
   // ttl is in seconds
   async put(namespace, key, val, ttl = 0, ...indexes) {
-    if (this.ttl > 0 && indexes && indexes.length > 0) {
+    if (ttl > 0 && indexes && indexes.length > 0) {
       throw new Error('secondary indexes not allow on a store with ttl');
     }
 

package/src/db/db.test.js

@@ -3,6 +3,8 @@ const t = require('tap');
 const DB = require('./db.js');
 
 let configStores = [];
+let ttlStores = [];
+const ttl = 3;
 
 const record1 = {
   id: '1',
@@ -18,48 +20,46 @@ const record2 = {
 const dbs = [
   {
     engine: 'mem',
-    options: {},
+    ttl: 1,
   },
   {
     engine: 'redis',
-    options: { url: 'redis://localhost:6379' },
+    url: 'redis://localhost:6379',
   },
   {
     engine: 'sql',
-    options: {
-      url: 'postgresql://postgres:postgres@localhost:5432/postgres',
-      type: 'postgres',
-    },
+    url: 'postgresql://postgres:postgres@localhost:5432/postgres',
+    type: 'postgres',
+    ttl: 1,
+    limit: 1,
   },
   {
     engine: 'mongo',
-    options: { url: 'mongodb://localhost:27017/jackson' },
+    url: 'mongodb://localhost:27017/jackson',
   },
   {
     engine: 'sql',
-    options: {
-      url: 'mysql://root:mysql@localhost:3307/mysql',
-      type: 'mysql',
-    },
+    url: 'mysql://root:mysql@localhost:3307/mysql',
+    type: 'mysql',
+    ttl: 1,
+    limit: 1,
   },
   {
     engine: 'sql',
-    options: {
-      url: 'mariadb://root@localhost:3306/mysql',
-      type: 'mariadb',
-    },
+    url: 'mariadb://root@localhost:3306/mysql',
+    type: 'mariadb',
+    ttl: 1,
+    limit: 1,
   },
 ];
 
 t.before(async () => {
   for (const idx in dbs) {
-    const config = dbs[idx];
-    const engine = config.engine;
-    const opts = config.options;
-    opts.engine = engine;
+    const opts = dbs[idx];
     const db = await DB.new(opts);
 
     configStores.push(db.store('saml:config'));
+    ttlStores.push(db.store('oauth:session', ttl));
   }
 });
 
@@ -70,9 +70,10 @@ t.teardown(async () => {
 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].options.type) {
-      dbEngine += ': ' + dbs[idx].options.type;
+    if (dbs[idx].type) {
+      dbEngine += ': ' + dbs[idx].type;
     }
     t.test('put(): ' + dbEngine, async (t) => {
       await configStore.put(
@@ -109,8 +110,8 @@ t.test('dbs', ({ end }) => {
     });
 
     t.test('get(): ' + dbEngine, async (t) => {
-      const ret1 = await configStore.get('1');
-      const ret2 = await configStore.get('2');
+      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');
@@ -151,8 +152,8 @@ t.test('dbs', ({ end }) => {
 
       await configStore.delete(record2.id);
 
-      const ret1 = await configStore.get('1');
-      const ret2 = await configStore.get('2');
+      const ret1 = await configStore.get(record1.id);
+      const ret2 = await configStore.get(record2.id);
 
       const ret3 = await configStore.getByIndex({
         name: 'name',
@@ -171,6 +172,69 @@ t.test('dbs', ({ end }) => {
 
       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, ((dbEngine === 'mem' ? 5 : 0) + 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) => {

package/src/db/mem.js

@@ -2,14 +2,32 @@
 const dbutils = require('./utils.js');
 
 class Mem {
-  constructor(/*options*/) {
+  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
 
-      return this; // Return the newly-created instance
+      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;
     })();
   }
 
@@ -39,8 +57,11 @@ class Mem {
     this.store[k] = JSON.stringify(val);
 
     if (ttl) {
-      // TODO: implement cleanup of TTL
-      this.ttlStore[k] = Date.now() + ttl * 1000;
+      this.ttlStore[k] = {
+        namespace,
+        key,
+        expiresAt: Date.now() + ttl * 1000,
+      };
     }
 
     // no ttl support for secondary indexes
@@ -79,6 +100,7 @@ class Mem {
     }
 
     delete this.cleanup[idxKey];
+    delete this.ttlStore[k];
   }
 }
 

package/src/db/sql/sql.js

@@ -23,7 +23,32 @@ class Sql {
       this.storeRepository = this.connection.getRepository(JacksonStore);
       this.indexRepository = this.connection.getRepository(JacksonIndex);
 
-      return this; // Return the newly-created instance
+      if (options.ttl && options.limit) {
+        this.ttlCleanup = async () => {
+          const now = Date.now();
+
+          while (true) {
+            const ids = await this.storeRepository.find({
+              expiresAt: typeorm.MoreThan(now),
+              take: options.limit,
+            });
+
+            if (ids.length <= 0) {
+              break;
+            }
+
+            await this.storeRepository.remove(ids);
+          }
+
+          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 "limit" options to enable it!')
+      }
+
+      return this;
     })();
   }
 

package/src/env.js

@@ -15,6 +15,7 @@ const db = {
   engine: process.env.DB_ENGINE,
   url: process.env.DB_URL,
   type: process.env.DB_TYPE,
+  ttl: process.env.DB_TTL,
 };
 
 module.exports = {

package/src/index.js

@@ -21,6 +21,8 @@ const defaultOpts = (opts) => {
   newOpts.db.url =
     newOpts.db.url || 'postgres://postgres:postgres@localhost:5432/jackson';
   newOpts.db.type = newOpts.db.type || 'postgres'; // Only needed if DB_ENGINE is sql. Supported values: postgres, cockroachdb, mysql, mariadb
+  newOpts.db.ttl = (newOpts.db.ttl || 300) * 1; // TTL for the code, session and token stores (in seconds)
+  newOpts.db.limit = (newOpts.db.limit || 1000) * 1; // Limit ttl cleanup to this many items at a time
 
   return newOpts;
 };
@@ -30,9 +32,9 @@ module.exports = async function (opts) {
 
   const db = await DB.new(opts.db);
   const configStore = db.store('saml:config');
-  const sessionStore = db.store('oauth:session', 300);
-  const codeStore = db.store('oauth:code', 300);
-  const tokenStore = db.store('oauth:token', 300);
+  const sessionStore = db.store('oauth:session', opts.db.ttl);
+  const codeStore = db.store('oauth:code', opts.db.ttl);
+  const tokenStore = db.store('oauth:token', opts.db.ttl);
 
   const apiController = require('./controller/api.js')({ configStore });
   const oauthController = require('./controller/oauth.js')({