associations: handling circular, multiple same, undefined class, and …

…not json class;

adding tests

src/decorators/JSONObject.ts

@@ -1,13 +1,11 @@
-import { JSONEntityNumber, JSONEntityObject } from '../types/JSONTypes';
+import { JSONEntityObject } from '../types/JSONTypes';
 import { Omit } from 'lodash';
 import { ClassLike, DecoratorClassProps } from '../types/ClassTypes';
 import { DecoratorEngine } from '../engine/DecoratorEngine';
-import PropertyEngine from '../engine/PropertyEngine';
-import SchemaEngine from '../engine/SchemaEngine';
-import { NotAJsonSchemaError } from '../exception/NotAJsonSchemaError';
 import AssociationEngine from '../engine/AssociationEngine';
+import { ClassFn } from '../types/AssociationTypes';
 
-type JSONObjectValue = Omit<Partial<JSONEntityObject>, 'type'> | (() => ClassLike);
+type JSONObjectValue = Omit<Partial<JSONEntityObject>, 'type'> | ClassFn;
 
 /**
  * Decorator for JSON object attribute.
@@ -22,9 +20,9 @@ export function JSONObject(...args: [JSONObjectValue] | DecoratorClassProps): Fu
       key: keyof ClassLike['prototype'] & string,
       descriptor?: PropertyDescriptor
     ): void => {
-      const Class = (args as [Function])[0]();
+      const [classFn] = args as [ClassFn];
 
-      AssociationEngine.addAssociation(prototype, key, null, Class);
+      AssociationEngine.addAssociation(prototype, key, null, classFn);
     };
   }
 

src/engine/AssociationEngine.ts

@@ -1,23 +1,39 @@
 import { ClassLike } from '../types/ClassTypes';
 import { JSONSchema7 } from 'json-schema';
 import { REFLECT_KEY } from '../decorators/ReflectKeys';
-import { Association, AssociationMap } from '../types/AssociationTypes';
+import { Association, AssociationMap, ClassFn } from '../types/AssociationTypes';
 import PropertyEngine from './PropertyEngine';
 import SchemaEngine from './SchemaEngine';
 import { NotAJsonSchemaError } from '../exception/NotAJsonSchemaError';
+import { CircularDependencyError } from '../exception/CircularDependencyError';
+import { Util } from './Util';
 
 export default class AssociationEngine {
-  static computeJSONAssociations(target: ClassLike): void {
+  static computeJSONAssociations(target: ClassLike, sourceStack: ClassLike[] = []): void {
+    if (!Util.isClass(target)) {
+      throw new NotAJsonSchemaError(target);
+    }
+
+    if (sourceStack.some(s => s.name === target.name)) {
+      throw new CircularDependencyError(...sourceStack, target);
+    }
+
+    sourceStack.push(target);
+
     const assocMapClass = AssociationEngine.getAssociations(target.name, target.prototype);
 
     assocMapClass.forEach(a => {
-      const valueSchema = SchemaEngine.getReflectSchema(a.target);
+      const assocTarget: ClassLike = a.targetFn();
+
+      AssociationEngine.computeJSONAssociations(assocTarget, sourceStack);
+
+      const valueSchema = SchemaEngine.getReflectSchema(assocTarget);
 
       if (!valueSchema) {
-        throw new NotAJsonSchemaError(a.target);
+        throw new NotAJsonSchemaError(assocTarget);
       }
 
-      valueSchema.properties = PropertyEngine.getReflectProperties(a.target.prototype);
+      valueSchema.properties = PropertyEngine.getReflectProperties(assocTarget.prototype);
 
       const value = a.jsonPropertyKey
         ? {
@@ -33,15 +49,15 @@ export default class AssociationEngine {
     prototypeSource: C['prototype'],
     propertyKey: keyof C['prototype'] & string,
     jsonProperty: keyof JSONSchema7 | null,
-    classTarget: ClassLike
+    classTargetFn: ClassFn
   ): void {
     const className = prototypeSource.constructor.name;
 
     const association: Association = {
       className,
       key: propertyKey,
       jsonPropertyKey: jsonProperty,
-      target: classTarget
+      targetFn: classTargetFn
     };
 
     const associationMap = AssociationEngine.getReflectAssociation(prototypeSource) || {};

src/engine/Util.ts

@@ -0,0 +1,7 @@
+import { ClassLike } from '../types/ClassTypes';
+
+export const Util = {
+  isClass(o: any): o is ClassLike {
+    return o && o['name'] && o['prototype'];
+  }
+};

src/exception/CircularDependencyError.ts

@@ -0,0 +1,20 @@
+import { ClassLike } from '../types/ClassTypes';
+
+const msg = (classStack: ClassLike[]) =>
+  `Circular dependency detected in the JSON Schema associations, it is not yet supported by Tabbouleh. 
+  This is the path followed: ${classStack.map(c => c.name).join(' => ')}`;
+
+/**
+ * To throw when a circular dependency is detected.
+ */
+export class CircularDependencyError extends Error {
+  /**
+   * @param classStack the stack of classes followed
+   */
+  constructor(...classStack: ClassLike[]) {
+    super(msg(classStack));
+    Error.call(this);
+    Error.captureStackTrace(this, this.constructor);
+    Object.setPrototypeOf(this, CircularDependencyError.prototype);
+  }
+}

src/exception/NotAJsonSchemaError.ts

@@ -1,11 +1,17 @@
 import { ClassLike } from '../types/ClassTypes';
 
 const msg = (name: string) =>
-  `Class called by Tabbouleh but not decorate with @JSONSchema: ${name}`;
+  `Class called by Tabbouleh but not decorated with @JSONSchema: ${name}`;
 
+/**
+ * To throw when an expected JSON Schema class is not (or undefined).
+ */
 export class NotAJsonSchemaError extends Error {
-  constructor(target: ClassLike) {
-    super(msg(target.name));
+  /**
+   * @param target the failing target
+   */
+  constructor(target: ClassLike | unknown) {
+    super(msg(target && (target as any).name ? (target as any).name : target));
     Error.call(this);
     Error.captureStackTrace(this, this.constructor);
     Object.setPrototypeOf(this, NotAJsonSchemaError.prototype);

src/types/AssociationTypes.ts

@@ -1,19 +1,27 @@
 import { ClassLike } from './ClassTypes';
 import { JSONSchema7 } from 'json-schema';
 
+export type ClassFn<C extends ClassLike = ClassLike> = () => C;
+
 export type Association<C extends ClassLike = ClassLike> = {
   className: C['name'];
 
-  // class property key
+  /**
+   * class property key
+   */
   key: keyof C['prototype'] & string;
 
   jsonPropertyKey: keyof JSONSchema7 | null;
 
-  // class targeted
-  target: ClassLike;
+  /**
+   * class targeted
+   */
+  targetFn: ClassFn;
 };
 
 export type AssociationMap = {
-  // class name
+  /**
+   * [className]: list Association
+   */
   [key: string]: Association[];
 };

test/JSONObject.test.ts

@@ -0,0 +1,20 @@
+import Tabbouleh from '../src/engine/Tabbouleh';
+import { OBJECT_SAMPLE_USER, JSONObjectSample } from './samples/JSONObject.sample';
+import { JSONSchema7 } from 'json-schema';
+
+const schemaObjectSample: JSONSchema7 = {
+  type: 'object',
+
+  properties: {
+    user: {
+      type: 'object',
+      ...(OBJECT_SAMPLE_USER as any)
+    }
+  }
+};
+
+describe('check JSONObject', () => {
+  it('should handle JSONObject with JSONEntity given', () => {
+    expect(Tabbouleh.generateJSONSchema(JSONObjectSample)).toEqual(schemaObjectSample);
+  });
+});

test/association.test.ts

@@ -0,0 +1,85 @@
+import { JSONSchema7 } from 'json-schema';
+import { CSample5, CS5_SCHEMA_PROPS } from './samples/CSample5';
+import Tabbouleh from '../src/engine/Tabbouleh';
+import { FOOD_SCHEMA_PROPS } from './genericSample/Food.sample';
+import { CircularAssociationSample } from './associationSamples/CircularAssociation.sample';
+import { CircularDependencyError } from '../src/exception/CircularDependencyError';
+import { UndefinedAssociationSample } from './associationSamples/UndefinedAssociation.sample';
+import { NotAJsonSchemaError } from '../src/exception/NotAJsonSchemaError';
+import { NotJsonSchemaAssociationSample } from './associationSamples/NotJsonSchemaAssociation.sample';
+import { MultipleSameAssociationSample } from './associationSamples/MultipleSameAssociation.sample';
+
+const schemaCSample5: JSONSchema7 = {
+  type: 'object',
+
+  ...CS5_SCHEMA_PROPS,
+
+  properties: {
+    type: {
+      type: 'string'
+    },
+
+    price: {
+      type: 'number'
+    },
+
+    food: {
+      type: 'object',
+
+      ...FOOD_SCHEMA_PROPS,
+
+      properties: {
+        parsley: {
+          type: 'string'
+        }
+      }
+    }
+  }
+};
+
+const schemaMultipleSameAssociation: JSONSchema7 = {
+  type: 'object',
+  properties: {
+    prop: {
+      type: 'object',
+
+      ...FOOD_SCHEMA_PROPS,
+
+      properties: {
+        parsley: {
+          type: 'string'
+        }
+      }
+    }
+  }
+};
+
+describe('Check if related schemas work', () => {
+  it('should handle nested object', () => {
+    expect(Tabbouleh.generateJSONSchema(CSample5)).toEqual(schemaCSample5);
+  });
+
+  it('should throw a CircularDependencyError on circular association', () => {
+    expect(() => Tabbouleh.generateJSONSchema(CircularAssociationSample)).toThrow(
+      CircularDependencyError
+    );
+  });
+
+  it('should throw a NotAJsonSchemaError on undefined association', () => {
+    expect(() => Tabbouleh.generateJSONSchema(UndefinedAssociationSample)).toThrow(
+      NotAJsonSchemaError
+    );
+  });
+
+  it('should throw a NotAJsonSchemaError on no-json-schema association', () => {
+    expect(() => Tabbouleh.generateJSONSchema(NotJsonSchemaAssociationSample)).toThrow(
+      NotAJsonSchemaError
+    );
+  });
+
+  it('should handle multiple same association', () => {
+    expect(Tabbouleh.generateJSONSchema(MultipleSameAssociationSample)).toEqual(
+      schemaMultipleSameAssociation
+    );
+  });
+});

test/associationSamples/CircularAssociation.sample.ts

@@ -0,0 +1,8 @@
+import { JSONSchema } from '../../src/decorators/JSONSchema';
+import { JSONObject } from '../../src/decorators/JSONObject';
+
+@JSONSchema
+export class CircularAssociationSample {
+  @JSONObject(() => CircularAssociationSample)
+  inception: CircularAssociationSample;
+}

test/associationSamples/MultipleSameAssociation.sample.ts

@@ -0,0 +1,10 @@
+import { JSONSchema } from '../../src/decorators/JSONSchema';
+import { FoodSample } from '../genericSample/Food.sample';
+import { JSONObject } from '../../src/decorators/JSONObject';
+
+@JSONSchema
+export class MultipleSameAssociationSample {
+  @JSONObject(() => FoodSample)
+  @JSONObject(() => FoodSample)
+  prop: FoodSample;
+}

test/associationSamples/NotJsonSchemaAssociation.sample.ts

@@ -0,0 +1,9 @@
+import { JSONSchema } from '../../src/decorators/JSONSchema';
+import { JSONObject } from '../../src/decorators/JSONObject';
+import { NotJsonSchemaSample } from '../genericSample/NotJsonSchema.sample';
+
+@JSONSchema
+export class NotJsonSchemaAssociationSample {
+  @JSONObject(() => NotJsonSchemaSample)
+  fake: unknown;
+}

test/associationSamples/UndefinedAssociation.sample.ts

@@ -0,0 +1,8 @@
+import { JSONSchema } from '../../src/decorators/JSONSchema';
+import { JSONObject } from '../../src/decorators/JSONObject';
+
+@JSONSchema
+export class UndefinedAssociationSample {
+  @JSONObject(() => undefined as any)
+  fake: unknown;
+}

test/genericSample/Food.sample.ts

@@ -0,0 +1,12 @@
+import { JSONSchema } from '../../src/decorators/JSONSchema';
+import { JSONString } from '../../src/decorators/JSONString';
+
+export const FOOD_SCHEMA_PROPS = {
+  title: 'Tabbouleh'
+};
+
+@JSONSchema<FoodSample>(FOOD_SCHEMA_PROPS)
+export class FoodSample {
+  @JSONString
+  parsley: string;
+}

test/genericSample/NotJsonSchema.sample.ts

@@ -0,0 +1,5 @@
+export class NotJsonSchemaSample {
+  toto: number;
+
+  tata: string;
+}