@boxyhq/saml-jackson 0.2.3-beta.231 → 0.2.3-beta.235

package/src/db/mongo.ts

@@ -1,110 +0,0 @@
-import { MongoClient } from 'mongodb';
-import { DatabaseDriver, DatabaseOption, Encrypted, Index } from 'saml-jackson';
-import * as dbutils from './utils';
-
-type Document = {
-  value: Encrypted;
-  expiresAt: Date;
-  indexes: string[];
-};
-
-class Mongo implements DatabaseDriver {
-  private options: DatabaseOption;
-  private client!: MongoClient;
-  private collection: any;
-  private db: any;
-
-  constructor(options: DatabaseOption) {
-    this.options = options;
-  }
-
-  async init(): Promise<Mongo> {
-    this.client = new MongoClient(this.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: string, key: string): Promise<any> {
-    const res = await this.collection.findOne({
-      _id: dbutils.key(namespace, key),
-    });
-    if (res && res.value) {
-      return res.value;
-    }
-
-    return null;
-  }
-
-  async getByIndex(namespace: string, idx: Index): Promise<any> {
-    const docs = await this.collection
-      .find({
-        indexes: dbutils.keyForIndex(namespace, idx),
-      })
-      .toArray();
-
-    const ret: string[] = [];
-    for (const doc of docs || []) {
-      ret.push(doc.value);
-    }
-
-    return ret;
-  }
-
-  async put(
-    namespace: string,
-    key: string,
-    val: Encrypted,
-    ttl = 0,
-    ...indexes: any[]
-  ): Promise<void> {
-    const doc = <Document>{
-      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: string, key: string): Promise<any> {
-    return await this.collection.deleteOne({
-      _id: dbutils.key(namespace, key),
-    });
-  }
-}
-
-export default {
-  new: async (options: DatabaseOption): Promise<Mongo> => {
-    return await new Mongo(options).init();
-  },
-};

package/src/db/redis.ts

@@ -1,103 +0,0 @@
-import * as redis from 'redis';
-import { DatabaseDriver, DatabaseOption, Encrypted, Index } from 'saml-jackson';
-import * as dbutils from './utils';
-
-class Redis implements DatabaseDriver {
-  private options: DatabaseOption;
-  private client!: any;
-
-  constructor(options: DatabaseOption) {
-    this.options = options;
-  }
-
-  async init(): Promise<Redis> {
-    const opts = {};
-
-    if (this.options && this.options.url) {
-      opts['socket'] = {
-        url: this.options.url,
-      };
-    }
-
-    this.client = redis.createClient(opts);
-    this.client.on('error', (err: any) =>
-      console.log('Redis Client Error', err)
-    );
-
-    await this.client.connect();
-
-    return this;
-  }
-
-  async get(namespace: string, key: string): Promise<any> {
-    const res = await this.client.get(dbutils.key(namespace, key));
-    if (res) {
-      return JSON.parse(res);
-    }
-
-    return null;
-  }
-
-  async getByIndex(namespace: string, idx: Index): Promise<any> {
-    const dbKeys = await this.client.sMembers(
-      dbutils.keyForIndex(namespace, idx)
-    );
-
-    const ret: string[] = [];
-    for (const dbKey of dbKeys || []) {
-      ret.push(await this.get(namespace, dbKey));
-    }
-
-    return ret;
-  }
-
-  async put(
-    namespace: string,
-    key: string,
-    val: Encrypted,
-    ttl = 0,
-    ...indexes: any[]
-  ): Promise<void> {
-    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: string, key: string): Promise<any> {
-    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();
-  }
-}
-
-export default {
-  new: async (options: DatabaseOption): Promise<Redis> => {
-    return await new Redis(options).init();
-  },
-};

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

@@ -1,43 +0,0 @@
-import { EntitySchema } from 'typeorm';
-import { JacksonIndex } from '../model/JacksonIndex';
-import { JacksonStore } from '../model/JacksonStore';
-
-export default 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: {
-    // @ts-ignore
-    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.ts

@@ -1,43 +0,0 @@
-import { DatabaseType } from 'saml-jackson';
-import { ColumnType, EntitySchema } from 'typeorm';
-import { JacksonStore } from '../model/JacksonStore';
-
-const valueType = (type: DatabaseType): ColumnType => {
-  switch (type) {
-    case 'postgres':
-    case 'cockroachdb':
-      return 'text';
-    case 'mysql':
-    case 'mariadb':
-      return 'mediumtext';
-    default:
-      return 'varchar';
-  }
-};
-
-export default (type: DatabaseType) => {
-  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.ts

@@ -1,17 +0,0 @@
-import { Entity, Column, Index } from 'typeorm';
-
-@Entity()
-export class JacksonTTL {
-  @Column({
-    primary: true,
-    type: 'varchar',
-    length: 1500,
-  })
-  key!: string;
-
-  @Index('_jackson_ttl_expires_at')
-  @Column({
-    type: 'bigint',
-  })
-  expiresAt!: number;
-}

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

@@ -1,3 +0,0 @@
-export class JacksonIndex {
-  constructor(public id: number, public key: string, public store: any) {}
-}

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

@@ -1,8 +0,0 @@
-export class JacksonStore {
-  constructor(
-    public key: string,
-    public value: string,
-    public iv?: string,
-    public tag?: string
-  ) {}
-}

package/src/db/sql/sql.ts

@@ -1,181 +0,0 @@
-/*eslint no-constant-condition: ["error", { "checkLoops": false }]*/
-
-require('reflect-metadata');
-
-import { DatabaseDriver, DatabaseOption, Index, Encrypted } from 'saml-jackson';
-import { Connection, createConnection } from 'typeorm';
-import * as dbutils from '../utils';
-import JacksonIndexEntity from './entity/JacksonIndex';
-import JacksonStoreEntity from './entity/JacksonStore';
-import {
-  JacksonTTL,
-  JacksonTTL as JacksonTTLEntity,
-} from './entity/JacksonTTL';
-import { JacksonIndex } from './model/JacksonIndex';
-import { JacksonStore } from './model/JacksonStore';
-
-class Sql implements DatabaseDriver {
-  private options: DatabaseOption;
-  private connection!: Connection;
-  private storeRepository;
-  private indexRepository;
-  private ttlRepository;
-  private ttlCleanup;
-  private timerId;
-
-  constructor(options: DatabaseOption) {
-    this.options = options;
-  }
-
-  async init(): Promise<Sql> {
-    while (true) {
-      try {
-        this.connection = await createConnection({
-          name: this.options.type + Math.floor(Math.random() * 100000),
-          type: this.options.type,
-          url: this.options.url,
-          synchronize: true,
-          migrationsTableName: '_jackson_migrations',
-          logging: false,
-          entities: [
-            JacksonStoreEntity(this.options.type),
-            JacksonIndexEntity,
-            JacksonTTLEntity,
-          ],
-        });
-
-        break;
-      } catch (err) {
-        console.error(`error connecting to ${this.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 (this.options.ttl && this.options.cleanupLimit) {
-      this.ttlCleanup = async () => {
-        const now = Date.now();
-
-        while (true) {
-          const ids = await 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;
-          });
-
-          await this.storeRepository.remove(ids);
-          await 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;
-  }
-
-  async get(namespace: string, key: string): Promise<any> {
-    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: string, idx: Index): Promise<any> {
-    const res = await this.indexRepository.find({
-      key: dbutils.keyForIndex(namespace, idx),
-    });
-
-    const ret: Encrypted[] = [];
-
-    if (res) {
-      res.forEach((r) => {
-        ret.push({
-          value: r.store.value,
-          iv: r.store.iv,
-          tag: r.store.tag,
-        });
-      });
-    }
-
-    return ret;
-  }
-
-  async put(
-    namespace: string,
-    key: string,
-    val: Encrypted,
-    ttl: number = 0,
-    ...indexes: any[]
-  ): Promise<void> {
-    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();
-        ttlRec.key = dbKey;
-        ttlRec.expiresAt = 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: string, key: string): Promise<any> {
-    return await this.storeRepository.remove({
-      key: dbutils.key(namespace, key),
-    });
-  }
-}
-
-export default {
-  new: async (options: DatabaseOption): Promise<Sql> => {
-    return await new Sql(options).init();
-  },
-};

package/src/db/store.ts

@@ -1,49 +0,0 @@
-import { Index, Storable } from 'saml-jackson';
-import * as dbutils from './utils';
-
-class Store implements Storable {
-  private namespace: string;
-  private db: any;
-  private ttl: number;
-
-  constructor(namespace: string, db: any, ttl = 0) {
-    this.namespace = namespace;
-    this.db = db;
-    this.ttl = ttl;
-  }
-
-  async get(key: string): Promise<any> {
-    return await this.db.get(this.namespace, dbutils.keyDigest(key));
-  }
-
-  async getByIndex(idx: Index): Promise<any> {
-    idx.value = dbutils.keyDigest(idx.value);
-
-    return await this.db.getByIndex(this.namespace, idx);
-  }
-
-  async put(key: string, val: any, ...indexes: Index[]): Promise<any> {
-    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: string): Promise<any> {
-    return await this.db.delete(this.namespace, dbutils.keyDigest(key));
-  }
-}
-
-export default {
-  new: (namespace: string, db: any, ttl = 0): Storable => {
-    return new Store(namespace, db, ttl);
-  },
-};

package/src/db/utils.ts

@@ -1,26 +0,0 @@
-import Ripemd160 from 'ripemd160';
-import { Index } from 'saml-jackson';
-
-export const key = (namespace: string, k: string): string => {
-  return namespace + ':' + k;
-};
-
-export const keyForIndex = (namespace: string, idx: Index): string => {
-  return key(key(namespace, idx.name), idx.value);
-};
-
-export const keyDigest = (k: string): string => {
-  return new Ripemd160().update(k).digest('hex');
-};
-
-export const keyFromParts = (...parts: string[]): string => {
-  // TODO: pick a better strategy, keys can collide now
-
-  return parts.join(':');
-};
-
-export const sleep = (ms: number): Promise<void> => {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-};
-
-export const indexPrefix = '_index';

package/src/env.ts

@@ -1,42 +0,0 @@
-const hostUrl = process.env.HOST_URL || 'localhost';
-const hostPort = +(process.env.HOST_PORT || '5000');
-const externalUrl =
-  process.env.EXTERNAL_URL || 'http://' + hostUrl + ':' + hostPort;
-const samlPath = process.env.SAML_PATH || '/oauth/saml';
-
-const internalHostUrl = process.env.INTERNAL_HOST_URL || 'localhost';
-const internalHostPort = +(process.env.INTERNAL_HOST_PORT || '6000');
-
-const apiKeys = (process.env.JACKSON_API_KEYS || '').split(',');
-
-const samlAudience = process.env.SAML_AUDIENCE || 'https://saml.boxyhq.com';
-const preLoadedConfig = process.env.PRE_LOADED_CONFIG;
-
-const idpEnabled = process.env.IDP_ENABLED;
-
-const db = {
-  engine: process.env.DB_ENGINE,
-  url: process.env.DB_URL,
-  type: process.env.DB_TYPE,
-  ttl: process.env.DB_TTL,
-  encryptionKey: process.env.DB_ENCRYPTION_KEY,
-};
-
-const env = {
-  hostUrl,
-  hostPort,
-  externalUrl,
-  samlPath,
-  samlAudience,
-  preLoadedConfig,
-  internalHostUrl,
-  internalHostPort,
-  apiKeys,
-  idpEnabled,
-  db,
-  useInternalServer: !(
-    hostUrl === internalHostUrl && hostPort === internalHostPort
-  ),
-};
-
-export default env;