@niledatabase/server 1.0.0-alpha.196 → 1.0.0-alpha.197

package/dist/Server.d.ts

@@ -12,7 +12,7 @@ declare type Api = {
 declare class Server {
     config: Config;
     api: Api;
-    private _db;
+    private manager;
     constructor(config?: ServerConfig);
     setConfig(cfg: Config): void;
     set database(val: string | void);

package/dist/db/DBManager.d.ts

@@ -0,0 +1,8 @@
+import { Config } from '../utils/Config';
+import NileDatabase, { NileDatabaseI } from './NileInstance';
+export default class DBManager {
+    connections: Map<string, NileDatabase>;
+    private makeId;
+    constructor(config: Config);
+    getConnection(config: Config): NileDatabaseI;
+}

package/dist/db/NileInstance.d.ts

@@ -0,0 +1,13 @@
+import { Knex } from 'knex';
+import { Config } from '../utils/Config';
+declare class NileDatabase {
+    knex: Knex;
+    tenantId?: undefined | null | string;
+    userId?: undefined | null | string;
+    id: string;
+    config: any;
+    constructor(config: Config, id: string);
+    startTimeout(): void;
+}
+export declare type NileDatabaseI = (table?: string) => Knex;
+export default NileDatabase;

package/dist/db/index.d.ts

@@ -1,14 +1,2 @@
-import { Knex } from 'knex';
-import { Config } from '../utils/Config';
-declare class NileDatabase {
-    knex: Knex;
-    db: Knex;
-    tenantId?: undefined | null | string;
-    userId?: undefined | null | string;
-    config: any;
-    constructor(config: Config);
-    ensureUpToDate(): void;
-    setConfig(newConfig: Config): void;
-}
-export declare type NileDatabaseI = (table?: string) => Knex;
-export default NileDatabase;
+export { default } from './DBManager';
+export { NileDatabaseI } from './NileInstance';

package/dist/server.cjs.development.js

@@ -512,6 +512,7 @@ var Events;
   Events["User"] = "userId";
   Events["Tenant"] = "tenantId";
   Events["Token"] = "token";
+  Events["EvictPool"] = "EvictPool";
 })(Events || (Events = {}));
 var Eventer = /*#__PURE__*/function () {
   function Eventer() {
@@ -560,6 +561,12 @@ var updateToken = function updateToken(val) {
 var watchToken = function watchToken(cb) {
   return eventer.subscribe(Events.Token, cb);
 };
+var watchEvictPool = function watchEvictPool(cb) {
+  return eventer.subscribe(Events.EvictPool, cb);
+};
+var evictPool = function evictPool(val) {
+  eventer.publish(Events.EvictPool, val);
+};
 
 var X_NILE_TENANT = 'x-nile-tenantId';
 var X_NILE_USER_ID = 'x-nile-userId';
@@ -1364,117 +1371,119 @@ var Tenants = /*#__PURE__*/function (_Config) {
 
 // doing this now, to provide flexibility later
 var NileDatabase = /*#__PURE__*/function () {
-  function NileDatabase(config) {
-    var _this = this;
-    this.config = _extends({}, config, {
-      client: 'pg'
-    });
-    this.knex = knex(this.config);
-    // Create a proxy to intercept method calls
-    // @ts-expect-error - proxy, but knex
-    this.db = new Proxy(this, {
-      get: function get(target, method) {
-        if (method === 'tenantId') {
-          return _this.tenantId;
-        }
-        if (method === 'userId') {
-          return _this.userId;
-        }
-        if (method === 'db') {
-          return function () {
-            var _target$knex;
-            //@ts-expect-error - its a string
-            return (_target$knex = target.knex).table.apply(_target$knex, arguments);
-          };
-        }
-        //@ts-expect-error - its a string
-        if (typeof target.knex[method] === 'function') {
-          return function () {
-            var _target$knex2;
-            //@ts-expect-error - its a string
-            return (_target$knex2 = target.knex)[method].apply(_target$knex2, arguments);
-          };
-        } else {
-          return target.knex;
-        }
-      }
-    });
-  }
-  var _proto = NileDatabase.prototype;
-  _proto.ensureUpToDate = function ensureUpToDate() {
-    // Close the existing pool connections and update the Knex instance with the latest config
-    this.knex.destroy();
-    this.knex = knex(_extends({}, this.config.db, {
-      client: 'pg'
-    }));
-  };
-  _proto.setConfig = function setConfig(newConfig) {
-    var _this2 = this;
-    var tenantId = newConfig.tenantId,
-      userId = newConfig.userId;
-    this.tenantId = tenantId;
-    this.userId = userId;
+  function NileDatabase(config, id) {
+    var _config$db$connection;
+    this.id = id;
     var poolConfig = {};
     var afterCreate = function afterCreate(conn, done) {
-      // console.log(this.tenantId, this.userId, 'in create');
-      var query = ["SET nile.tenant_id = '" + _this2.tenantId + "'"];
-      if (_this2.userId) {
-        if (!_this2.tenantId) {
+      var query = ["SET nile.tenant_id = '" + config.tenantId + "'"];
+      if (config.userId) {
+        if (!config.tenantId) {
           // eslint-disable-next-line no-console
           console.warn('A user id cannot be set in context without a tenant id');
         }
-        query.push("SET nile.user_id = '" + _this2.userId + "'");
+        query.push("SET nile.user_id = '" + config.userId + "'");
       }
       // in this example we use pg driver's connection API
       conn.query(query.join(';'), function (err) {
         done(err, conn);
       });
     };
-    if (this.tenantId) {
-      var _newConfig$db$pool;
-      if ((_newConfig$db$pool = newConfig.db.pool) != null && _newConfig$db$pool.afterCreate) {
+    if (config.tenantId) {
+      var _config$db$pool;
+      if ((_config$db$pool = config.db.pool) != null && _config$db$pool.afterCreate) {
         // eslint-disable-next-line no-console
-        console.log('Providing an  pool configuration will stop automatic tenant context setting.');
-      } else if (newConfig.db.pool) {
-        poolConfig = _extends({}, newConfig.db.pool, {
+        console.log('Providing an pool configuration will stop automatic tenant context setting.');
+      } else if (config.db.pool) {
+        poolConfig = _extends({}, config.db.pool, {
           afterCreate: afterCreate
         });
-      } else if (!newConfig.db.pool) {
+      } else if (!config.db.pool) {
         poolConfig = {
           afterCreate: afterCreate
         };
       }
     }
-    this.config = _extends({}, newConfig, {
-      db: _extends({}, newConfig.db, {
+    this.config = _extends({}, config, {
+      db: _extends({}, config.db, {
+        connection: _extends({}, config.db.connection, {
+          database: (_config$db$connection = config.db.connection.database) != null ? _config$db$connection : config.database
+        }),
         pool: poolConfig
       })
     });
-    this.ensureUpToDate();
+    var knexConfig = _extends({}, this.config.db, {
+      client: 'pg'
+    });
+    // start the timer for cleanup
+    this.startTimeout();
+    this.knex = knex(knexConfig);
+  }
+  var _proto = NileDatabase.prototype;
+  _proto.startTimeout = function startTimeout() {
+    var _this = this,
+      _this$config$db$pool$;
+    setTimeout(function () {
+      _this.knex.destroy();
+      evictPool(_this.id);
+    }, (_this$config$db$pool$ = this.config.db.pool.idleTimeoutMillis) != null ? _this$config$db$pool$ : 30000);
   };
   return NileDatabase;
 }();
 
+var DBManager = /*#__PURE__*/function () {
+  function DBManager(config) {
+    var _this = this;
+    this.connections = new Map();
+    // add the base one, so you can at least query
+    var id = this.makeId();
+    this.connections.set(id, new NileDatabase(new Config(config), id));
+    watchEvictPool(function (id) {
+      if (id && _this.connections.has(id)) {
+        _this.connections["delete"](id);
+      }
+    });
+  }
+  var _proto = DBManager.prototype;
+  _proto.makeId = function makeId(tenantId, userId) {
+    if (tenantId && userId) {
+      return tenantId + ":" + userId;
+    }
+    if (tenantId) {
+      return "" + tenantId;
+    }
+    return 'base';
+  };
+  _proto.getConnection = function getConnection(config) {
+    var id = this.makeId(config.tenantId, config.userId);
+    var existing = this.connections.get(id);
+    if (existing) {
+      return existing;
+    }
+    this.connections.set(id, new NileDatabase(new Config(config), id));
+    return this.connections.get(id);
+  };
+  return DBManager;
+}();
+
 var init = function init(config) {
   var auth = new Auth(config);
   var users = new Users(config);
   var tenants = new Tenants(config);
-  var db = new NileDatabase(config);
   return [{
     auth: auth,
     users: users,
     tenants: tenants
-  }, db];
+  }];
 };
 var Server = /*#__PURE__*/function () {
   function Server(config) {
     var _this = this;
     this.config = new Config(config);
     var _init = init(this.config),
-      api = _init[0],
-      knex = _init[1];
+      api = _init[0];
     this.api = api;
-    this._db = knex;
+    this.manager = new DBManager(this.config);
     watchTenantId(function (tenantId) {
       _this.tenantId = tenantId;
     });
@@ -1487,15 +1496,7 @@ var Server = /*#__PURE__*/function () {
   }
   var _proto = Server.prototype;
   _proto.setConfig = function setConfig(cfg) {
-    if (cfg.db.connection) {
-      this.config.db.connection = cfg.db.connection;
-    }
-    if (cfg.database && this.database !== cfg.workspace) {
-      this.database = cfg.database;
-    }
-    if (cfg.workspace && this.workspace !== cfg.workspace) {
-      this.workspace = cfg.workspace;
-    }
+    this.config = new Config(cfg);
   };
   _createClass(Server, [{
     key: "database",
@@ -1526,8 +1527,6 @@ var Server = /*#__PURE__*/function () {
     set: function set(userId) {
       this.database = this.config.database;
       this.config.userId = userId;
-      // update the db with config values
-      this._db.setConfig(this.config);
       if (this.api) {
         this.api.auth.userId = this.config.userId;
         this.api.users.userId = this.config.userId;
@@ -1542,8 +1541,6 @@ var Server = /*#__PURE__*/function () {
     set: function set(tenantId) {
       this.database = this.config.database;
       this.config.tenantId = tenantId;
-      // update the db with config values
-      this._db.setConfig(this.config);
       if (this.api) {
         this.api.auth.tenantId = tenantId;
         this.api.users.tenantId = tenantId;
@@ -1571,13 +1568,13 @@ var Server = /*#__PURE__*/function () {
     get: function get() {
       // only need to interact with the knex object
       //@ts-expect-error - because that's where it is in the proxy
-      return this._db.db.db;
+      return this.manager.getConnection(this.config).knex;
     }
   }]);
   return Server;
 }(); // export default Server;
 function Nile(config) {
-  var server = new Server();
+  var server = new Server(config);
   server.setConfig(new Config(config));
   return server;
 }