now throws error when static fn of uninitialized model is called

Author: Robin Buschmann

example/app.ts

@@ -70,13 +70,17 @@ sequelize
   )
   .then(() => {
     const post = new Post({
-      text: 'hey2',
+      text: 'hey',
       author: {
         name: 'jörn'
       }
     }, {include: [Author]});
 
-    return post.save();
+    return post
+      .save({validate: true})
+      .catch(err => {
+        'stop';
+      });
   })
   .then(() => Post.build<Post>({text: 'hey3'}).save())
   .then(() => Post

example/models/Post.ts

@@ -6,6 +6,7 @@ import {Comment} from "./Comment";
 import {PostTopic} from "./PostTopic";
 import {Topic} from "./Topic";
 import {Author} from "./Author";
+import {Length} from "../../lib/annotations/validation/Length";
 
 @Scopes({
   full: {
@@ -28,7 +29,9 @@ export class Post extends Model<Post> {
   @Column
   id: number;
 
-  @Column
+  @Column({
+    field: '_text_'
+  })
   text: string;
 
   @HasMany(() => Comment)
@@ -45,3 +48,5 @@ export class Post extends Model<Post> {
   author?: Author;
 
 }
+
+Post.beforeCreate(post => {});

lib/models/BaseModel.ts

@@ -4,11 +4,14 @@ import {majorVersion} from "../utils/versioning";
 import {capitalize} from "../utils/string";
 import {IAssociationActionOptions} from "../interfaces/IAssociationActionOptions";
 import {preConformIncludes} from "../services/models";
+import {getAllPropertyNames} from "../utils/object";
 
 const parentPrototype = majorVersion === 3 ? (Instance as any).prototype : (Model as any).prototype;
 
 export abstract class BaseModel {
 
+  static isInitialized: boolean = false;
+
   /**
    * Indicates which static methods of Model has to be proxied,
    * to prepare include option to automatically resolve alias;
@@ -47,26 +50,50 @@ export abstract class BaseModel {
       .forEach(name => target[name] = this[name])
     ;
 
-
-    // Creates proxies for pre conforming include options; see "preConformIncludes"
-    Object
-      .keys(this.toPreConformIncludeMap)
+    // Creates proxies for all static methods but forbidden ones
+    getAllPropertyNames(target)
+      .filter(key => !isForbiddenKey(key))
       .forEach(key => {
 
+        if (typeof target[key] !== 'function') return;
+
         const superFn = target[key];
 
         target[key] = function(...args: any[]): any {
 
-          const options = args[BaseModel.toPreConformIncludeMap[key]];
+          if (!this.isInitialized) {
+            throw new Error(`Model not initialized: "${this.name}" needs to be added to a Sequelize instance ` +
+              `before "${key}" can be called.`);
+          }
+
+          const optionIndex = BaseModel.toPreConformIncludeMap[key];
+
+          if (optionIndex !== void 0) {
 
-          if (options) {
+            const options = args[optionIndex];
 
-            args[BaseModel.toPreConformIncludeMap[key]] = preConformIncludes(options, this);
+            if (options) {
+
+              args[optionIndex] = preConformIncludes(options, this);
+            }
           }
 
           return superFn.call(this, ...args);
         };
       });
+
+    function isForbiddenKey(key: string): boolean {
+
+      // is private member?
+      if (key.charAt(0) === '_') {
+        return true;
+      }
+
+      const forbiddenKeys = ['name', 'constructor', 'length', 'prototype', 'caller', 'arguments', 'apply',
+        'QueryInterface', 'QueryGenerator', 'init', 'replaceHookAliases', 'refreshAttributes'];
+
+      return forbiddenKeys.indexOf(key) !== -1;
+    }
   }
 
   static prepareInstantiationOptions(options: BuildOptions, source: any): BuildOptions {

lib/models/BaseSequelize.ts

@@ -64,6 +64,7 @@ export abstract class BaseSequelize {
     const models = getModels(arg);
 
     this.defineModels(models);
+    models.forEach(model => model.isInitialized = true);
     this.associateModels(models);
     resolveScopes(models);
   }

lib/models/Model.d.ts

@@ -28,6 +28,8 @@ export declare class Model<T> extends Hooks {
 
   constructor(values?: any, options?: IBuildOptions);
 
+  static isInitialized: boolean;
+
   /**
    * Remove attribute from model definition
    *

lib/utils/object.ts

@@ -3,9 +3,9 @@
  * The last source overrides all properties of the previous
  * ones, if they have the same names
  */
-export function deepAssign<T, S1, S2, S3>(target: T, source1: S1, source2: S2, source3: S3): T&S1&S2&S3;
-export function deepAssign<T, S1, S2>(target: T, source1: S1, source2: S2): T&S1&S2;
-export function deepAssign<T, S>(target: T, source: S): T&S;
+export function deepAssign<T, S1, S2, S3>(target: T, source1: S1, source2: S2, source3: S3): T & S1 & S2 & S3;
+export function deepAssign<T, S1, S2>(target: T, source1: S1, source2: S2): T & S1 & S2;
+export function deepAssign<T, S>(target: T, source: S): T & S;
 export function deepAssign<S>(target: {}, source: S): S;
 export function deepAssign(target: any, ...sources: any[]): any {
 
@@ -19,7 +19,7 @@ export function deepAssign(target: any, ...sources: any[]): any {
 
   return target;
 
-  function assign(key: string|number, _target: any, _source: any): void {
+  function assign(key: string | number, _target: any, _source: any): void {
 
     const sourceValue = _source[key];
     if (sourceValue !== void 0) {
@@ -91,3 +91,21 @@ export function cloneRegExp(input: RegExp, injectFlags?: string): RegExp {
   return ( new RegExp(pattern, flags) );
 }
 
+export function getAllPropertyNames(obj: any): string[] {
+  const names: string[] = [];
+  do {
+    names.push.apply(names, Object.getOwnPropertyNames(obj));
+    obj = Object.getPrototypeOf(obj);
+  } while (obj !== Object.prototype);
+
+  const exists: {[name: string]: boolean|undefined} = {};
+
+  return names.filter(name => {
+
+    const isValid = !exists[name] && name !== 'constructor';
+
+    exists[name] = true;
+
+    return isValid;
+  });
+}

test/specs/model.spec.ts

@@ -66,6 +66,17 @@ describe('model', () => {
     return MainUser.sync({force: true});
   });
 
+  describe('static functions when not initialized', () => {
+
+    it('should throw an error', () => {
+      @Table
+      class Test extends Model<Test> {}
+
+      expect(() => Test.beforeCreate(test => test)).to.throw(/^Model not initialized/);
+    });
+
+  });
+
   describe('constructor', () => {
     it('uses the passed dao name as tablename if freezeTableName', () => {