Merge branch 'master' into issue-204-scope-typings

Author: RobinBuschmann

README.md

@@ -11,6 +11,7 @@ Decorators and some other extras for sequelize (v3 + v4).
    - [`@Column` API](#column-api)
  - [Usage](#usage)
    - [Configuration](#configuration)
+   - [globs](#globs)
    - [Model-path resolving](#model-path-resolving)
  - [Model association](#model-association)
    - [One-to-many](#one-to-many)
@@ -63,6 +64,8 @@ class Person extends Model<Person> {
 ```
 The model needs to extend the `Model` class and has to be annotated with the `@Table` decorator. All properties that
 should appear as a column in the database require the `@Column` annotation.
+
+See more advanced example [here](https://github.com/RobinBuschmann/sequelize-typescript-example).
 
 ### `@Table`
 The `@Table` annotation can be used without passing any parameters. To specify some more define options, use
@@ -209,6 +212,18 @@ sequelize config or add the required models later on by calling `sequelize.addMo
 sequelize.addModels([Person]);
 sequelize.addModels(['path/to/models']);
 ```
+### globs
+```typescript
+import {Sequelize} from 'sequelize-typescript';
+
+const sequelize =  new Sequelize({
+        ...
+        modelPaths: [__dirname + '/**/*.model.ts']
+});
+// or
+sequelize.addModels([__dirname + '/**/*.model.ts']);
+```
+
 #### Model-path resolving
 When using a path to resolve the required models, either the class has to be exported as default or if not exported
 as default, the file should have the same name as the corresponding class:

lib/utils/object.ts

@@ -15,11 +15,17 @@ export function deepAssign(target: any, ...sources: any[]): any {
       .getOwnPropertyNames(source)
       .forEach(key => assign(key, target, source))
     ;
+    /* istanbul ignore next */
+    if (Object.getOwnPropertySymbols) {
+      Object
+        .getOwnPropertySymbols(source)
+        .forEach(key => assign(key, target, source))
+      ;
+    }
   });
-
   return target;
 
-  function assign(key: string | number, _target: any, _source: any): void {
+  function assign(key: string | number | symbol, _target: any, _source: any): void {
     const sourceValue = _source[key];
 
     if (sourceValue !== void 0) {

test/specs/scopes.spec.ts

@@ -1,12 +1,22 @@
 import {expect, use} from 'chai';
 import * as chaiAsPromised from 'chai-as-promised';
+import {useFakeTimers} from 'sinon';
+import {Op} from 'sequelize';
 import {createSequelize} from "../utils/sequelize";
 import {getScopeOptions} from "../../lib/services/scopes";
 import {ShoeWithScopes, SHOE_DEFAULT_SCOPE, SHOE_SCOPES} from "../models/ShoeWithScopes";
 import {Manufacturer} from "../models/Manufacturer";
 import {Person} from "../models/Person";
+import {Model} from '../../lib/models/Model';
+import {Table} from '../../lib/annotations/Table';
+import {Scopes} from '../../lib/annotations/Scopes';
+import {majorVersion} from '../../lib/utils/versioning';
+import {Column} from '../../lib/annotations/Column';
+import {UpdatedAt} from '../../lib/annotations/UpdatedAt';
+import chaiDatetime = require('chai-datetime');
 
 use(chaiAsPromised);
+use(chaiDatetime);
 
 describe('scopes', () => {
 
@@ -219,6 +229,55 @@ describe('scopes', () => {
 
     });
 
+    if (majorVersion > 3) {
+
+      describe('with symbols', () => {
+        const _sequelize = createSequelize(false);
+
+        @Scopes({
+          bob: {where: {name: {[Op.like]: '%bob%'}}},
+          updated: {where: {updated: {[Op.gt]: new Date(2000, 1)}}},
+        })
+        @Table
+        class Person extends Model<Person> {
+
+          @Column
+          name: string;
+
+          @UpdatedAt
+          updated: Date;
+        }
+
+        _sequelize.addModels([Person]);
+
+        beforeEach(() => _sequelize.sync({force: true}));
+
+        it('should consider symbols while finding elements', () => {
+          return Person
+            .create({name: '1bob2'})
+            .then(() => Person.create({name: 'bob'}))
+            .then(() => Person.create({name: 'bobby'}))
+            .then(() => Person.create({name: 'robert'}))
+            .then(() => (Person.scope('bob') as typeof Person).findAll())
+            .then(persons => expect(persons).to.have.property('length', 3))
+            ;
+        });
+
+        it('should consider symbols on timestamp column while finding elements', () => {
+          const clock = useFakeTimers(+new Date());
+          return Person
+            .create({name: 'test'})
+            .then(() => (Person.scope('updated') as typeof Person).findAll())
+            .then(() => Person.findAll())
+            .then(persons => expect(persons).to.have.property('length', 1))
+            .then(() => clock.restore())
+            ;
+        });
+
+      });
+    }
+
+
   });
 
 });

test/specs/utils/object.spec.ts

@@ -13,7 +13,14 @@ describe('utils', () => {
       const childSourceA = {f: childSourceF};
       const childSourceB = {};
       const source1 = {a: childSourceA, b: childSourceB, c: 1, d: 'd', over: 'ride', regex: /reg/gim, notNull: null};
-      const source2 = {e: 'für elisa', g: () => null, arr: [{h: 1}, {}, 'e'], over: 'ridden', nullable: null, notNull: 'notNull'};
+      const source2 = {
+        e: 'für elisa',
+        g: () => null,
+        arr: [{h: 1}, {}, 'e'],
+        over: 'ridden',
+        nullable: null,
+        notNull: 'notNull'
+      };
       const sourceKeys = [].concat(Object.keys(source1), Object.keys(source2));
 
       it('should not be undefined', () => {
@@ -110,15 +117,27 @@ describe('utils', () => {
 
       it('should keep prototype chain', () => {
         class Test {
-          protoFn(): any {}
+          protoFn(): any {
+          }
         }
+
         const copy = deepAssign({}, {test: new Test()});
 
         expect(copy.test)
           .to.have.property('protoFn')
           .that.is.a('function');
       });
 
+      if (Object.getOwnPropertySymbols) {
+        it('should copy symbol based objects', () => {
+          const symbol = Symbol('test');
+          const value = 'test';
+          const copy = deepAssign({}, {[symbol]: value});
+
+          expect(copy[symbol]).to.equal(value);
+        });
+      }
+
     });
 
   });