Merge pull request #76 from RobinBuschmann/issue-74

fixes #74

Author: RobinBuschmann

lib/services/association.ts

@@ -35,21 +35,16 @@ export function addAssociation(target: any,
                                otherKey?: string): void {
 
   let associations = getAssociations(target);
+  let throughClassGetter;
+  let options: Partial<ConcatAssociationOptions> = {};
 
   if (!associations) {
     associations = [];
-    setAssociations(target, associations);
   }
-
-  let throughClassGetter;
-
   if (typeof through === 'function') {
     throughClassGetter = through;
     through = undefined;
   }
-
-  let options: Partial<ConcatAssociationOptions> = {};
-
   if (typeof optionsOrForeignKey === 'string') {
     options.foreignKey = {name: optionsOrForeignKey};
   } else {
@@ -67,6 +62,7 @@ export function addAssociation(target: any,
     as,
     options
   });
+  setAssociations(target, associations);
 }
 
 /**
@@ -131,18 +127,18 @@ export function getForeignKey(model: typeof Model,
  * Returns association meta data from specified class
  */
 export function getAssociations(target: any): ISequelizeAssociation[] | undefined {
-
-  return Reflect.getMetadata(ASSOCIATIONS_KEY, target);
+  const associations = Reflect.getMetadata(ASSOCIATIONS_KEY, target);
+  if (associations) {
+    return [...associations];
+  }
 }
 
 export function setAssociations(target: any, associations: ISequelizeAssociation[]): void {
-
   Reflect.defineMetadata(ASSOCIATIONS_KEY, associations, target);
 }
 
 export function getAssociationsByRelation(target: any, relatedClass: any): ISequelizeAssociation[] {
   const associations = getAssociations(target);
-
   return (associations || []).filter(association => {
     const _relatedClass = association.relatedClassGetter();
     return (
@@ -159,18 +155,15 @@ export function getAssociationsByRelation(target: any, relatedClass: any): ISequ
 export function addForeignKey(target: any,
                               relatedClassGetter: ModelClassGetter,
                               foreignKey: string): void {
-
   let foreignKeys = getForeignKeys(target);
-
   if (!foreignKeys) {
     foreignKeys = [];
-    setForeignKeys(target, foreignKeys);
   }
-
   foreignKeys.push({
     relatedClassGetter,
     foreignKey
   });
+  setForeignKeys(target, foreignKeys);
 }
 
 /**
@@ -205,7 +198,6 @@ export function processAssociation(sequelize: BaseSequelize,
   let otherKey;
 
   if (association.relation === BELONGS_TO_MANY) {
-
     otherKey = getOtherKey(association);
     through = getThroughClass(sequelize, association);
   }
@@ -235,7 +227,6 @@ export function processAssociation(sequelize: BaseSequelize,
 export function getThroughClass(sequelize: BaseSequelize,
                                 association: ISequelizeAssociation): any {
   if (association.through) {
-
     if (!sequelize.thoughMap[association.through]) {
       const throughModel = sequelize.getThroughModel(association.through);
       sequelize.addModels([throughModel]);
@@ -249,15 +240,16 @@ export function getThroughClass(sequelize: BaseSequelize,
 /**
  * Returns foreign key meta data from specified class
  */
-function getForeignKeys(target: any): ISequelizeForeignKeyConfig[] | undefined {
-
-  return Reflect.getMetadata(FOREIGN_KEYS_KEY, target);
+export function getForeignKeys(target: any): ISequelizeForeignKeyConfig[] | undefined {
+  const foreignKeys = Reflect.getMetadata(FOREIGN_KEYS_KEY, target);
+  if (foreignKeys) {
+    return [...foreignKeys];
+  }
 }
 
 /**
  * Sets foreign key meta data
  */
 function setForeignKeys(target: any, foreignKeys: any[]): void {
-
   Reflect.defineMetadata(FOREIGN_KEYS_KEY, foreignKeys, target);
 }

test/specs/services/association.spec.ts

@@ -0,0 +1,118 @@
+/* tslint:disable:max-classes-per-file */
+import {expect} from 'chai';
+import {addAssociation, addForeignKey, getAssociations, getForeignKeys} from "../../../lib/services/association";
+import {Model} from "../../../lib/models/Model";
+
+describe('service.association', () => {
+
+  describe('addAssociation', () => {
+
+    it('should add association to target metadata', () => {
+      const target = {};
+      const RELATION = 'hasMany';
+      const AS_NAME = 'test';
+      const RELATED_CLASS_GETTER = () => class T extends Model<T> {};
+      addAssociation(target, RELATION, RELATED_CLASS_GETTER, AS_NAME);
+      const associations = getAssociations(target);
+
+      expect(associations).to.have.property('length', 1);
+      expect(associations[0]).to.eql({
+        relation: RELATION,
+        options: {},
+        through: undefined,
+        throughClassGetter: undefined,
+        as: AS_NAME,
+        relatedClassGetter: RELATED_CLASS_GETTER,
+      });
+    });
+
+    it('should add association to target metadata, but not parent', () => {
+      const parent = {};
+      const target = Object.create(parent);
+      const RELATION = 'hasMany';
+      const PARENT_RELATION = 'belongsToMany';
+      const AS_NAME = 'test';
+      const RELATED_CLASS_GETTER = () => class T extends Model<T> {};
+      addAssociation(parent, PARENT_RELATION, RELATED_CLASS_GETTER, AS_NAME);
+      addAssociation(target, RELATION, RELATED_CLASS_GETTER, AS_NAME);
+
+      const associations = getAssociations(target);
+      expect(associations).to.have.property('length', 2);
+      expect(associations[0]).to.eql({
+        relation: PARENT_RELATION,
+        options: {},
+        through: undefined,
+        throughClassGetter: undefined,
+        as: AS_NAME,
+        relatedClassGetter: RELATED_CLASS_GETTER,
+      });
+      expect(associations[1]).to.eql({
+        relation: RELATION,
+        options: {},
+        through: undefined,
+        throughClassGetter: undefined,
+        as: AS_NAME,
+        relatedClassGetter: RELATED_CLASS_GETTER,
+      });
+
+      const parentAssociations = getAssociations(parent);
+      expect(parentAssociations).to.have.property('length', 1);
+      expect(parentAssociations[0]).to.eql({
+        relation: PARENT_RELATION,
+        options: {},
+        through: undefined,
+        throughClassGetter: undefined,
+        as: AS_NAME,
+        relatedClassGetter: RELATED_CLASS_GETTER,
+      });
+    });
+
+  });
+
+  describe('addForeignKey', () => {
+
+    it('should add foreign key to target metadata', () => {
+      const target = {};
+      const FOREIGN_KEY = 'testId';
+      const RELATED_CLASS_GETTER = () => class T extends Model<T> {};
+      addForeignKey(target, RELATED_CLASS_GETTER, FOREIGN_KEY);
+      const foreignKeys = getForeignKeys(target);
+
+      expect(foreignKeys).to.have.property('length', 1);
+      expect(foreignKeys[0]).to.eql({
+        foreignKey: FOREIGN_KEY,
+        relatedClassGetter: RELATED_CLASS_GETTER,
+      });
+    });
+
+    it('should add foreign key to target metadata, but not parent', () => {
+      const parent = {};
+      const target = Object.create(parent);
+      const FOREIGN_KEY = 'testId';
+      const PARENT_FOREIGN_KEY = 'parentTestId';
+      const RELATED_CLASS_GETTER = () => class T extends Model<T> {};
+      addForeignKey(parent, RELATED_CLASS_GETTER, PARENT_FOREIGN_KEY);
+      addForeignKey(target, RELATED_CLASS_GETTER, FOREIGN_KEY);
+
+      const foreignKeys = getForeignKeys(target);
+      expect(foreignKeys).to.have.property('length', 2);
+      expect(foreignKeys[0]).to.eql({
+        foreignKey: PARENT_FOREIGN_KEY,
+        relatedClassGetter: RELATED_CLASS_GETTER,
+      });
+      expect(foreignKeys[1]).to.eql({
+        foreignKey: FOREIGN_KEY,
+        relatedClassGetter: RELATED_CLASS_GETTER,
+      });
+
+      const parentForeignKeys = getForeignKeys(parent);
+      expect(parentForeignKeys).to.have.property('length', 1);
+      expect(parentForeignKeys[0]).to.eql({
+        foreignKey: PARENT_FOREIGN_KEY,
+        relatedClassGetter: RELATED_CLASS_GETTER,
+      });
+    });
+
+  });
+
+});

test/specs/services/models.spec.ts

@@ -1,38 +1,107 @@
 import {expect} from 'chai';
-import {resolveModelGetter} from '../../../lib/services/models';
+import {
+  addAttribute, addAttributeOptions, getAttributes,
+  resolveModelGetter, setAttributes
+} from '../../../lib/services/models';
 import {Book} from "../../models/Book";
+import {DataType} from "../../../lib/enums/DataType";
 
 /* tslint:disable:max-classes-per-file */
 
-describe('services', () => {
+describe('services.models', () => {
 
-  describe('models', () => {
+  describe('resolveModelGetter', () => {
 
-    describe('resolveModelGetter', () => {
+    const options = {
+      a: () => Book,
+      b: () => null,
+      c: {
+        c1: () => Book,
+        c2: () => null
+      }
+    };
 
-      const options = {
-        a: () => Book,
-        b: () => null,
-        c: {
-          c1: () => Book,
-          c2: () => null
-        }
-      };
+    resolveModelGetter(options);
 
-      resolveModelGetter(options);
+    it('should resolve getter', () => {
 
-      it('should resolve getter', () => {
+      expect(options.a).to.be.equal(Book);
+      expect(options.c.c1).to.be.equal(Book);
+    });
+
+    it('should not resolve other functions', () => {
+
+      expect(options.b).to.be.a('function');
+      expect(options.c.c2).to.be.a('function');
+    });
+  });
+
+  describe('addAttribute', () => {
 
-        expect(options.a).to.be.equal(Book);
-        expect(options.c.c1).to.be.equal(Book);
-      });
+    it('should not throw', () => {
+      expect(() => addAttribute({}, 'test', {})).to.not.throw();
+    });
+
+  });
 
-      it('should not resolve other functions', () => {
+  describe('getAttributes', () => {
 
-        expect(options.b).to.be.a('function');
-        expect(options.c.c2).to.be.a('function');
-      });
+    const target = {};
+    const ATTRIBUTES = {name: {primaryKey: true}, age: {type: DataType.NUMBER}};
+    setAttributes(target, ATTRIBUTES);
+
+    it('should not return reference but copy of attributes', () => {
+      const attributes = getAttributes(target);
+      expect(attributes).to.not.equal(ATTRIBUTES);
     });
 
   });
+
+  describe('addAttributeOptions', () => {
+
+    const target = {};
+    const PROPERTY_NAME = 'test';
+    const OPTIONS = {allowNull: true};
+    addAttribute(target, PROPERTY_NAME, {});
+    addAttributeOptions(target, PROPERTY_NAME, OPTIONS);
+
+    it('should be able to retrieve added attribute options', () => {
+      const attributes = getAttributes(target);
+      expect(Object.keys(attributes)).to.have.property('length', 1);
+      expect(Object.keys(attributes[PROPERTY_NAME])).to.have.property('length', Object.keys(OPTIONS).length);
+      expect(attributes).to.have.property(PROPERTY_NAME).that.eqls(OPTIONS);
+    });
+
+    it('should be able to retrieve added attribute options of prototype linked object', () => {
+      const child = Object.create(target);
+      const attributes = getAttributes(child);
+      expect(Object.keys(attributes)).to.have.property('length', 1);
+      expect(Object.keys(attributes[PROPERTY_NAME])).to.have.property('length', Object.keys(OPTIONS).length);
+      expect(attributes).to.have.property(PROPERTY_NAME).that.eqls(OPTIONS);
+    });
+
+    it('should add new options to child prototype but not parent one', () => {
+      const child = Object.create(target);
+      const NEW_OPTIONS = {primaryKey: true};
+      addAttributeOptions(child, PROPERTY_NAME, NEW_OPTIONS);
+
+      // for child
+      const attributes = getAttributes(child);
+      expect(Object.keys(attributes)).to.have.property('length', 1);
+      expect(Object.keys(attributes[PROPERTY_NAME]))
+        .to.have.property(
+        'length',
+        Object.keys(OPTIONS).length + Object.keys(NEW_OPTIONS).length
+      );
+      expect(attributes).to.have.property(PROPERTY_NAME).that.eqls({...OPTIONS, ...NEW_OPTIONS});
+
+      // for parent
+      const parentAttributes = getAttributes(target);
+      expect(Object.keys(parentAttributes)).to.have.property('length', 1);
+      expect(Object.keys(parentAttributes[PROPERTY_NAME])).to.have.property('length', Object.keys(OPTIONS).length);
+      expect(parentAttributes).to.have.property(PROPERTY_NAME).that.eqls(OPTIONS);
+    });
+
+  });
+
 });