Change KnexProvider interfaces, supports multiple configuration

dist/lib/contracts/KnexProvider.d.ts

@@ -1,5 +1,16 @@
 declare namespace Najs.Contracts.Eloquent {
     interface KnexProvider<Knex, QueryBuilder, Config extends object> extends Najs.Contracts.Autoload {
+        /**
+         * Set config by name
+         * @param {string} name
+         * @param {object} config
+         */
+        setConfig(name: string, config: Config): this;
+        /**
+         * Set config by name
+         * @param {string} name
+         */
+        getConfig(name: string): Config;
         /**
          * Set default config for knex instance
          */
@@ -11,10 +22,34 @@ declare namespace Najs.Contracts.Eloquent {
         /**
          * Create an knex instance
          */
-        create(config?: Config): Knex;
+        create(): Knex;
         /**
-         * Create an knex instance
+         * Create an knex cached instance
+         */
+        create(name: string): Knex;
+        /**
+         * Create an knex instance with config
+         */
+        create(config: Config): Knex;
+        /**
+         * Set config to name and create knex cached instance
+         */
+        create(name: string, config: Config): Knex;
+        /**
+         * Create query builder from default knex instance
+         */
+        createQueryBuilder(table: string): QueryBuilder;
+        /**
+         * Create query builder from knex cached instance by name
+         */
+        createQueryBuilder(table: string, name: string): QueryBuilder;
+        /**
+         * Create query builder from not cached knex instance with config
+         */
+        createQueryBuilder(table: string, config: Config): QueryBuilder;
+        /**
+         * Set config to name and create query builder from knex cached instance
          */
-        createQueryBuilder(table: string, config?: Config): QueryBuilder;
+        createQueryBuilder(table: string, name: string, config: Config): QueryBuilder;
     }
 }

dist/lib/providers/KnexProvider.d.ts

@@ -3,11 +3,18 @@ import * as Knex from 'knex';
 import { Facade } from 'najs-facade';
 import { QueryBuilder, Config } from 'knex';
 export declare class KnexProvider extends Facade implements Najs.Contracts.Eloquent.KnexProvider<Knex, QueryBuilder, Config> {
-    protected defaultConfig: Config;
-    protected defaultKnex?: Knex;
+    protected configurations: {
+        [name: string]: Config;
+    };
+    protected instances: {
+        [name: string]: Knex | undefined;
+    };
+    constructor();
     getClassName(): string;
+    setConfig(name: string, config: Config): this;
+    getConfig(name: string): Config;
     setDefaultConfig(config: Config): this;
     getDefaultConfig(): Config;
-    create(config?: Config): Knex;
-    createQueryBuilder(table: string, config?: Config): QueryBuilder;
+    create(arg1?: string | Config, arg2?: Config): Knex;
+    createQueryBuilder(table: string, arg1?: Config | string, arg2?: Config): QueryBuilder;
 }

dist/lib/providers/KnexProvider.js

@@ -6,28 +6,45 @@ const constants_1 = require("../constants");
 const najs_facade_1 = require("najs-facade");
 const najs_binding_1 = require("najs-binding");
 class KnexProvider extends najs_facade_1.Facade {
+    constructor() {
+        super();
+        this.configurations = {};
+        this.instances = {};
+    }
     getClassName() {
         return constants_1.NajsEloquent.Provider.KnexProvider;
     }
-    setDefaultConfig(config) {
-        this.defaultConfig = config;
-        this.defaultKnex = undefined;
+    setConfig(name, config) {
+        this.configurations[name] = config;
+        this.instances[name] = undefined;
         return this;
     }
+    getConfig(name) {
+        return this.configurations[name];
+    }
+    setDefaultConfig(config) {
+        return this.setConfig('default', config);
+    }
     getDefaultConfig() {
-        return this.defaultConfig;
-    }
-    create(config) {
-        if (!config) {
-            if (!this.defaultKnex) {
-                this.defaultKnex = Knex(this.defaultConfig);
-            }
-            return this.defaultKnex;
+        return this.getConfig('default');
+    }
+    create(arg1, arg2) {
+        if (typeof arg1 === 'object') {
+            return Knex(arg1);
+        }
+        if (typeof arg1 === 'undefined') {
+            arg1 = 'default';
+        }
+        if (typeof arg2 !== 'undefined') {
+            this.setConfig(arg1, arg2);
+        }
+        if (!this.instances[arg1]) {
+            this.instances[arg1] = Knex(this.configurations[arg1]);
         }
-        return Knex(config);
+        return this.instances[arg1];
     }
-    createQueryBuilder(table, config) {
-        return this.create(config).table(table);
+    createQueryBuilder(table, arg1, arg2) {
+        return this.create(arg1, arg2).table(table);
     }
 }
 exports.KnexProvider = KnexProvider;

dist/test/providers/KnexProvider.test.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("jest");
+const Sinon = require("sinon");
 const najs_facade_1 = require("najs-facade");
 const KnexProvider_1 = require("../../lib/providers/KnexProvider");
 describe('KnexProvider', function () {
@@ -9,22 +10,40 @@ describe('KnexProvider', function () {
         expect(knexProvider).toBeInstanceOf(najs_facade_1.Facade);
         expect(knexProvider.getClassName()).toEqual('NajsEloquent.Provider.KnexProvider');
     });
-    describe('.setDefaultConfig()', function () {
-        it('simply assigns to this.defaultConfig', function () {
+    describe('.setConfig()', function () {
+        it('simply assigns to this.configurations[name]', function () {
             const knexProvider = new KnexProvider_1.KnexProvider();
-            expect(knexProvider.getDefaultConfig()).toBeUndefined();
+            expect(knexProvider.getConfig('test')).toBeUndefined();
             const config = {};
-            knexProvider.setDefaultConfig(config);
-            expect(knexProvider.getDefaultConfig() === config).toBe(true);
+            expect(knexProvider.setConfig('test', config) === knexProvider).toBe(true);
+            expect(knexProvider.getConfig('test') === config).toBe(true);
         });
-        it('clears this.defaultKnex instance', function () {
+        it('clears instance in this.instances[name] instance', function () {
+            const knexProvider = new KnexProvider_1.KnexProvider();
+            knexProvider['instances']['test'] = {};
+            knexProvider.setConfig('test', {});
+            expect(knexProvider['instances']['test']).toBeUndefined();
+        });
+    });
+    describe('.getConfig()', function () {
+        it('simply returns config from this.configurations', function () {
             const knexProvider = new KnexProvider_1.KnexProvider();
             const config = {};
+            knexProvider['configurations']['test'] = config;
+            expect(knexProvider.getConfig('test') === config).toBe(true);
+        });
+    });
+    describe('.setDefaultConfig()', function () {
+        it('calls .setConfig() with name = default', function () {
+            const knexProvider = new KnexProvider_1.KnexProvider();
+            const setConfigStub = Sinon.stub(knexProvider, 'setConfig');
+            const config = {};
             knexProvider.setDefaultConfig(config);
+            expect(setConfigStub.calledWith('default', config)).toBe(true);
         });
     });
     describe('.getDefaultConfig()', function () {
-        it('simply returns to this.defaultConfig', function () {
+        it('calls and returns this.getConfig() with name = default', function () {
             const knexProvider = new KnexProvider_1.KnexProvider();
             expect(knexProvider.getDefaultConfig()).toBeUndefined();
             const config = {};
@@ -33,24 +52,43 @@ describe('KnexProvider', function () {
         });
     });
     describe('.create()', function () {
-        it('calls knex() with this.defaultConfig if the config param is not passed', function () {
+        it('calls knex() with default config and cached the result in this.instances if the config param is not passed', function () {
             const knexProvider = new KnexProvider_1.KnexProvider();
             const config = { client: 'mysql' };
             knexProvider.setDefaultConfig(config);
             const result = knexProvider.create();
+            expect(result === knexProvider['instances']['default']).toBe(true);
             expect(result['client']['config'] === config).toBe(true);
+            expect(knexProvider.create() === result).toBe(true);
         });
-        it('calls knex() with passed config, this case always create new knex instance', function () {
+        it('calls Knex() and creates instance if the first argument is object, this instance is not cached', function () {
+            const knexProvider = new KnexProvider_1.KnexProvider();
+            const config = { client: 'mysql' };
+            const a = knexProvider.create(config);
+            const b = knexProvider.create(config);
+            expect(a !== b).toBe(true);
+        });
+        it('creates cached instance by config with name', function () {
+            const knexProvider = new KnexProvider_1.KnexProvider();
+            const config = { client: 'mysql' };
+            knexProvider.setConfig('test', config);
+            const result = knexProvider.create('test');
+            expect(result === knexProvider['instances']['test']).toBe(true);
+            expect(knexProvider.create('test') === result).toBe(true);
+            expect(result['client']['config'] === config).toBe(true);
+        });
+        it('sets config by name then creates a cached instance at the same time', function () {
             const knexProvider = new KnexProvider_1.KnexProvider();
-            const defaultConfig = { client: 'mysql' };
-            knexProvider.setDefaultConfig(defaultConfig);
             const config = { client: 'mysql' };
-            const result = knexProvider.create(config);
+            const result = knexProvider.create('test', config);
+            expect(config === knexProvider['configurations']['test']).toBe(true);
+            expect(result === knexProvider['instances']['test']).toBe(true);
+            expect(knexProvider.create('test') === result).toBe(true);
             expect(result['client']['config'] === config).toBe(true);
         });
     });
     describe('.createQueryBuilder()', function () {
-        it('calls .create() with default config, then passes table to the result function', function () {
+        it('calls .create() and passes arg1, arg2, then passes table to the result function', function () {
             const knexProvider = new KnexProvider_1.KnexProvider();
             const config = { client: 'mysql' };
             knexProvider.setDefaultConfig(config);

lib/contracts/KnexProvider.ts

@@ -1,5 +1,18 @@
 namespace Najs.Contracts.Eloquent {
   export interface KnexProvider<Knex, QueryBuilder, Config extends object> extends Najs.Contracts.Autoload {
+    /**
+     * Set config by name
+     * @param {string} name
+     * @param {object} config
+     */
+    setConfig(name: string, config: Config): this
+
+    /**
+     * Set config by name
+     * @param {string} name
+     */
+    getConfig(name: string): Config
+
     /**
      * Set default config for knex instance
      */
@@ -13,11 +26,35 @@ namespace Najs.Contracts.Eloquent {
     /**
      * Create an knex instance
      */
-    create(config?: Config): Knex
+    create(): Knex
+    /**
+     * Create an knex cached instance
+     */
+    create(name: string): Knex
+    /**
+     * Create an knex instance with config
+     */
+    create(config: Config): Knex
+    /**
+     * Set config to name and create knex cached instance
+     */
+    create(name: string, config: Config): Knex
 
     /**
-     * Create an knex instance
+     * Create query builder from default knex instance
+     */
+    createQueryBuilder(table: string): QueryBuilder
+    /**
+     * Create query builder from knex cached instance by name
+     */
+    createQueryBuilder(table: string, name: string): QueryBuilder
+    /**
+     * Create query builder from not cached knex instance with config
+     */
+    createQueryBuilder(table: string, config: Config): QueryBuilder
+    /**
+     * Set config to name and create query builder from knex cached instance
      */
-    createQueryBuilder(table: string, config?: Config): QueryBuilder
+    createQueryBuilder(table: string, name: string, config: Config): QueryBuilder
   }
 }

lib/providers/KnexProvider.ts

@@ -7,36 +7,63 @@ import { QueryBuilder, Config } from 'knex'
 import { register } from 'najs-binding'
 
 export class KnexProvider extends Facade implements Najs.Contracts.Eloquent.KnexProvider<Knex, QueryBuilder, Config> {
-  protected defaultConfig: Config
-  protected defaultKnex?: Knex
+  protected configurations: {
+    [name: string]: Config
+  }
+  protected instances: {
+    [name: string]: Knex | undefined
+  }
+
+  constructor() {
+    super()
+    this.configurations = {}
+    this.instances = {}
+  }
 
   getClassName() {
     return NajsEloquent.Provider.KnexProvider
   }
 
-  setDefaultConfig(config: Config): this {
-    this.defaultConfig = config
-    this.defaultKnex = undefined
+  setConfig(name: string, config: Config): this {
+    this.configurations[name] = config
+    this.instances[name] = undefined
 
     return this
   }
 
+  getConfig(name: string): Config {
+    return this.configurations[name]
+  }
+
+  setDefaultConfig(config: Config): this {
+    return this.setConfig('default', config)
+  }
+
   getDefaultConfig(): Config {
-    return this.defaultConfig
+    return this.getConfig('default')
   }
 
-  create(config?: Config): Knex {
-    if (!config) {
-      if (!this.defaultKnex) {
-        this.defaultKnex = Knex(this.defaultConfig)
-      }
-      return this.defaultKnex
+  create(arg1?: string | Config, arg2?: Config): Knex {
+    if (typeof arg1 === 'object') {
+      return Knex(<object>arg1)
+    }
+
+    if (typeof arg1 === 'undefined') {
+      arg1 = 'default'
+    }
+
+    if (typeof arg2 !== 'undefined') {
+      this.setConfig(arg1, arg2)
+    }
+
+    if (!this.instances[arg1]) {
+      this.instances[arg1] = Knex(this.configurations[arg1])
     }
-    return Knex(config!)
+    return this.instances[arg1]!
   }
 
-  createQueryBuilder(table: string, config?: Config): QueryBuilder {
-    return this.create(config).table(table)
+  createQueryBuilder(table: string, arg1?: Config | string, arg2?: Config): QueryBuilder {
+    return this.create(<any>arg1, <any>arg2).table(table)
   }
 }
 register(KnexProvider, NajsEloquent.Provider.KnexProvider)