add new sequelize definition

Author: kukoo

lib/interfaces/ISequelizeConfig.ts

@@ -5,7 +5,7 @@ export interface ISequelizeConfig extends Options {
   /**
    * Name of database
    */
-  name: string;
+  database: string;
 
   /**
    * Username of database

lib/interfaces/ISequelizeDbNameConfig.ts

@@ -2,7 +2,7 @@ import {Options} from 'sequelize';
 
 /**
  * This class is for deprecated "name" property.
- * For cPlease
+ * For congruence to Sequelize config, use "database" instead.
  */
 export interface ISequelizeDbNameConfig extends Options {
 

lib/interfaces/ISequelizeUriConfig.ts

@@ -1,21 +1,11 @@
 import {Options} from 'sequelize';
 
-export interface ISequelizeConfig extends Options {
+export interface ISequelizeUriConfig extends Options {
 
   /**
-   * Name of database
+   * Uri connection string to database
    */
-  name: string;
-
-  /**
-   * Username of database
-   */
-  username: string;
-
-  /**
-   * Password for database user
-   */
-  password: string;
+  uri: string;
 
   /**
    * Path to models, which should be loaded

lib/models/BaseSequelize.ts

@@ -2,6 +2,9 @@ import {Model} from "./Model";
 import {DEFAULT_DEFINE_OPTIONS, getModels} from "../services/models";
 import {getAssociations, processAssociation} from "../services/association";
 import {ISequelizeConfig} from "../interfaces/ISequelizeConfig";
+import {ISequelizeUriConfig} from "../interfaces/ISequelizeUriConfig";
+import {ISequelizeDbNameConfig} from "../interfaces/ISequelizeDbNameConfig";
+import {SequelizeConfig} from "../types/SequelizeConfig";
 import {resolveScopes} from "../services/scopes";
 import {ISequelizeValidationOnlyConfig} from "../interfaces/ISequelizeValidationOnlyConfig";
 import {extend} from "../utils/object";
@@ -19,6 +22,18 @@ export abstract class BaseSequelize {
   thoughMap: { [through: string]: any } = {};
   _: { [modelName: string]: (typeof Model) } = {};
 
+  static isISequelizeConfig(obj: any): obj is ISequelizeConfig {
+    return obj.hasOwnProperty("database") && obj.hasOwnProperty("username");
+  }
+
+  static isISequelizeDbNameConfig(obj: any): obj is ISequelizeDbNameConfig {
+    return obj.hasOwnProperty("name") && obj.hasOwnProperty("username");
+  }
+
+  static isISequelizeUriConfig(obj: any): obj is ISequelizeUriConfig {
+    return obj.hasOwnProperty("uri");
+  }
+
   static extend(target: any): void {
 
     extend(target, this);
@@ -27,7 +42,7 @@ export abstract class BaseSequelize {
   /**
    * Prepares sequelize config passed to original sequelize constructor
    */
-  static prepareConfig(config: ISequelizeConfig | ISequelizeValidationOnlyConfig): ISequelizeConfig {
+  static prepareConfig(config: SequelizeConfig | ISequelizeValidationOnlyConfig): SequelizeConfig {
     if (!config.define) {
       config.define = {};
     }
@@ -37,13 +52,21 @@ export abstract class BaseSequelize {
 
       return this.getValidationOnlyConfig(config);
     }
-    return {...config as ISequelizeConfig};
+
+    if (BaseSequelize.isISequelizeDbNameConfig(config)) {
+      // Sequelize uses "database" property as a database name.
+      // @TODO: "name" property is deprecated, use "database" instead
+      const database = config.name;
+      return {...config, database} as ISequelizeConfig;
+    }
+
+    return {...config as SequelizeConfig};
   }
 
-  static getValidationOnlyConfig(config: ISequelizeConfig | ISequelizeValidationOnlyConfig): ISequelizeConfig {
+  static getValidationOnlyConfig(config: SequelizeConfig | ISequelizeValidationOnlyConfig): ISequelizeConfig {
     return {
       ...config,
-      name: '_name_',
+      database: '_name_',
       username: '_username_',
       password: '_password_',
       dialect: 'sqlite',
@@ -64,7 +87,7 @@ export abstract class BaseSequelize {
     models.forEach(model => this._[model.name] = model);
   }
 
-  init(config: ISequelizeConfig): void {
+  init(config: SequelizeConfig): void {
 
     if (config.modelPaths) this.addModels(config.modelPaths);
   }

lib/models/Sequelize.d.ts

@@ -1,15 +1,15 @@
-/// <reference types="sequelize" />
 import 'reflect-metadata';
 import * as SequelizeOrigin from 'sequelize';
 import {Model} from "./Model";
-import {ISequelizeConfig} from "../interfaces/ISequelizeConfig";
+import {SequelizeConfig} from "../../types/SequelizeConfig";
 import {ISequelizeValidationOnlyConfig} from "../interfaces/ISequelizeValidationOnlyConfig";
 
 export declare class Sequelize extends SequelizeOrigin {
 
   _: {[modelName: string]: (typeof Model)};
 
-  constructor(config: ISequelizeConfig | ISequelizeValidationOnlyConfig);
+  constructor(config: SequelizeConfig | ISequelizeValidationOnlyConfig);
+  constructor(uri: string);
 
   addModels(models: Array<typeof Model>): void;
   addModels(modelPaths: string[]): void;

lib/models/v4/Sequelize.ts

@@ -1,36 +1,37 @@
 import 'reflect-metadata';
 import * as OriginSequelize from 'sequelize';
 import {Model} from "../Model";
-import {ISequelizeConfig} from "../../interfaces/ISequelizeConfig";
+import {SequelizeConfig} from "../../types/SequelizeConfig";
 import {getModelName, getAttributes, getOptions} from "../../services/models";
 import {BaseSequelize} from "../BaseSequelize";
 import {Table} from "../../annotations/Table";
 import {ISequelizeAssociation} from "../../interfaces/ISequelizeAssociation";
 
-let preparedConfig;
-
 export class Sequelize extends OriginSequelize implements BaseSequelize {
 
-  thoughMap: {[through: string]: any} = {};
-  _: {[modelName: string]: typeof Model} = {};
-  init: (config: ISequelizeConfig) => void;
-  addModels: (models: Array<typeof Model>|string[]) => void;
+  thoughMap: { [through: string]: any } = {};
+  _: { [modelName: string]: typeof Model } = {};
+  init: (config: SequelizeConfig) => void;
+  addModels: (models: Array<typeof Model> | string[]) => void;
   associateModels: (models: Array<typeof Model>) => void;
 
-  constructor(config: ISequelizeConfig) {
-    // a spread operator would be the more reasonable approach here,
-    // but this is currently not possible due to a bug by ts
-    // https://github.com/Microsoft/TypeScript/issues/4130
-    // TODO@robin probably make the constructor private and
-    // TODO       use a static factory function instead
+  constructor(config: SequelizeConfig | string) {
+
     super(
-      (preparedConfig = BaseSequelize.prepareConfig(config), preparedConfig.name),
-      preparedConfig.username,
-      preparedConfig.password,
-      preparedConfig
+      (typeof config === "string") ?
+        config : // URI string
+        BaseSequelize.isISequelizeUriConfig(config) ?
+          config.uri : // URI string from ISequelizeUriConfig
+          BaseSequelize.prepareConfig(config) // Config object (ISequelizeConfig)
     );
 
-    this.init(config);
+    if (BaseSequelize.isISequelizeUriConfig(config)) {
+      this.options = {...this.options, ...config};
+    }
+
+    if (typeof config !== "string") {
+      this.init(config);
+    }
   }
 
   getThroughModel(through: string): typeof Model {
@@ -43,7 +44,8 @@ export class Sequelize extends OriginSequelize implements BaseSequelize {
     return Through;
   }
 
-  adjustAssociation(model: any, association: ISequelizeAssociation): void {}
+  adjustAssociation(model: any, association: ISequelizeAssociation): void {
+  }
 
   /**
    * Creates sequelize models and registers these models

lib/types/SequelizeConfig.ts

@@ -0,0 +1,5 @@
+import {ISequelizeConfig} from "../interfaces/ISequelizeConfig";
+import {ISequelizeUriConfig} from "../interfaces/ISequelizeUriConfig";
+import {ISequelizeDbNameConfig} from "../interfaces/ISequelizeDbNameConfig";
+
+export type SequelizeConfig = ISequelizeConfig | ISequelizeUriConfig | ISequelizeDbNameConfig;

test/specs/models/sequelize.spec.ts

@@ -1,7 +1,7 @@
 /* tslint:disable:max-classes-per-file */
 
 import {expect} from 'chai';
-import {createSequelize} from "../../utils/sequelize";
+import {createSequelize, createSequelizeUriObject, createSequelizeUriString} from "../../utils/sequelize";
 import {Game} from "../../models/exports/Game";
 import Gamer from "../../models/exports/gamer.model";
 import {Sequelize} from "../../../lib/models/Sequelize";
@@ -20,6 +20,24 @@ describe('sequelize', () => {
 
   });
 
+  describe('constructor using uri in options object', () => {
+
+    const sequelizeUri = createSequelizeUriString(false);
+    it('should equal Sequelize class', () => {
+      expect(sequelizeUri.constructor).to.equal(Sequelize);
+    });
+
+  });
+
+  describe('constructor using uri string', () => {
+
+    const sequelizeUri = createSequelizeUriObject(false);
+    it('should equal Sequelize class', () => {
+      expect(sequelizeUri.constructor).to.equal(Sequelize);
+    });
+
+  });
+
   describe('global define options', () => {
 
     const DEFINE_OPTIONS = {timestamps: true, underscoredAll: true};

test/utils/sequelize.ts

@@ -2,10 +2,11 @@ import {Sequelize} from "../../lib/models/Sequelize";
 import * as OriginSequelize from "sequelize";
 import {DefineOptions, Sequelize as SequelizeType} from "sequelize";
 
+
 export function createSequelize(useModelsInPath: boolean = true, define: DefineOptions<any> = {}): Sequelize {
 
   return new Sequelize({
-    name: '__',
+    database: '__',
     dialect: 'sqlite',
     username: 'root',
     password: '',
@@ -16,6 +17,22 @@ export function createSequelize(useModelsInPath: boolean = true, define: DefineO
   });
 }
 
+export function createSequelizeUriObject(useModelsInPath: boolean = true, define: DefineOptions<any> = {}): Sequelize {
+
+  return new Sequelize({
+    uri: 'sqlite://root@localhost/__',
+    dialect: 'sqlite',
+    define,
+    storage: ':memory:',
+    logging: !('SEQ_SILENT' in process.env),
+    modelPaths: useModelsInPath ? [__dirname + '/../models'] : []
+  });
+}
+export function createSequelizeUriString(useModelsInPath: boolean = true, define: DefineOptions<any> = {}): Sequelize {
+
+  return new Sequelize("sqlite://root@localhost/__");
+}
+
 export function createSequelizeValidationOnly(useModelsInPath: boolean = true): Sequelize {
 
   return new Sequelize({