feat: add dynamic object factories

Author: Superd22

README.md

@@ -1,4 +1,4 @@
-# Type Relay [name TBD] [![pipeline status](https://gitlab.com/wemaintain/type-relay/badges/master/pipeline.svg)](https://gitlab.com/wemaintain/type-relay/commits/master)[![coverage report](https://gitlab.com/wemaintain/type-relay/badges/master/coverage.svg)](https://gitlab.com/wemaintain/type-relay/commits/master)
+# Type Relay [name TBD] [![pipeline status](https://gitlab.com/wemaintain/type-relay/badges/master/pipeline.svg)](https://gitlab.com/wemaintain/type-relay/commits/master) [![coverage report](https://gitlab.com/wemaintain/type-relay/badges/master/coverage.svg)](https://gitlab.com/wemaintain/type-relay/commits/master)
 
 Type Relay is a librairy designed to work alongside [TypeGraphQL](https://typegraphql.ml/) and make it easy to paginated your results using the [Relay spec](https://facebook.github.io/relay/graphql/connections.htm)
 

packages/type-relay/src/decorators/relayed-connection.decorator.spec.ts

@@ -0,0 +1,3 @@
+describe('RelayedConnection', () => {
+  it.todo('Should call the DynamicObject factory')
+})

packages/type-relay/src/decorators/relayed-connection.decorator.ts

@@ -1,9 +1,10 @@
+import { Container } from 'typedi'
 import { ReturnTypeFunc, MethodAndPropDecorator } from '../types/types'
+import { DynamicObjectFactory } from '../graphql/dynamic-object.factory'
 
 export function RelayedConnection (type: ReturnTypeFunc): MethodAndPropDecorator
 export function RelayedConnection (type: ReturnTypeFunc, through: ReturnTypeFunc): MethodAndPropDecorator
 export function RelayedConnection (type: ReturnTypeFunc, through?: ReturnTypeFunc): MethodAndPropDecorator {
   return <M>(target: any, propertyKey: string | symbol, descriptor?: TypedPropertyDescriptor<M>) => {
-    
   }
 }

packages/type-relay/src/decorators/relayed-connection.spec.ts

@@ -0,0 +1,83 @@
+import { DynamicObjectFactory } from "./dynamic-object.factory";
+import { Container } from "typedi";
+import { TypeRelayConfig } from "../services/type-relay-config.service";
+import * as TGQL from 'type-graphql'
+
+describe('DynamicObject factory', () => {
+  let dynamicObjectFactory = new DynamicObjectFactory();
+
+  beforeEach(() => {
+    dynamicObjectFactory = new DynamicObjectFactory();
+  })
+
+  describe('makeEdgeConnection', () => {
+    it('Should throw if PAGINATION_OBJECT wasn\'t init\'d', () => {
+      expect(() => dynamicObjectFactory.makeEdgeConnection("", () => Object)).toThrowError(/PageInfo/)
+    })
+
+    it('Should throw if PAGINATION_OBJECT isn\'t a function', () => {
+      Container.set('PAGINATION_OBJECT', {})
+      expect(() => dynamicObjectFactory.makeEdgeConnection("", () => Object)).toThrowError(/PageInfo/)
+    })
+
+    it('Should throw if PAGINATION_OBJECT returns undefined', () => {
+      Container.set('PAGINATION_OBJECT', () => undefined)
+      expect(() => dynamicObjectFactory.makeEdgeConnection("", () => Object)).toThrowError(/PageInfo/)
+    })
+
+    it('Should return a decorated Edge Object', () => {
+      new TypeRelayConfig({ orm: 'type-orm' });
+      
+      const fieldSpy = jest.spyOn(TGQL, 'Field');
+      const objectSpy = jest.spyOn(TGQL, 'ObjectType');
+
+      const objectInnerSpy = jest.fn();
+      const fieldInnerSpy = jest.fn();
+      fieldSpy.mockImplementation((_a, _b) => {
+        return fieldInnerSpy;
+      });
+      objectSpy.mockImplementation((_a, _b) => {
+        return objectInnerSpy;
+      });
+
+      const { Edge } = dynamicObjectFactory.makeEdgeConnection("Foo", () => Object)
+
+      expect(Edge).toBeTruthy();
+      expect(fieldInnerSpy.mock.calls).toIncludeAllMembers([
+        [ Edge.prototype, 'node' ],
+        [ Edge.prototype, 'cursor' ]
+      ])
+
+      expect(objectSpy).toHaveBeenCalledWith('FooEdge');
+
+      fieldSpy.mockRestore();
+      objectSpy.mockRestore();
+    })
+
+    it('Should return a decorated Connection Object', () => {
+      new TypeRelayConfig({ orm: 'type-orm' });
+      
+      const fieldSpy = jest.spyOn(TGQL, 'Field');
+      const objectSpy = jest.spyOn(TGQL, 'ObjectType');
+
+      const objectInnerSpy = jest.fn();
+      const fieldInnerSpy = jest.fn();
+      fieldSpy.mockImplementation((_a, _b) => {
+        return fieldInnerSpy;
+      });
+      objectSpy.mockImplementation((_a, _b) => {
+        return objectInnerSpy;
+      });
+
+      const { Connection } = dynamicObjectFactory.makeEdgeConnection("Foo", () => Object)
+
+      expect(Connection).toBeTruthy();
+
+      expect(objectSpy).toHaveBeenCalledWith('FooConnection');
+
+      fieldSpy.mockRestore();
+      objectSpy.mockRestore();
+    })
+
+  })
+})

packages/type-relay/src/graphql/dynamic-object.factory.spec.ts

@@ -0,0 +1,88 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import { Service, Container } from 'typedi'
+import { TypeValue } from '../types/types'
+import { Field, ObjectType } from 'type-graphql'
+import * as Relay from 'graphql-relay'
+
+/**
+ * Factory service for generating Objects that are dynamic and might be appened multiple times
+ * to the SDL. Such as Edges and Connections
+ */
+@Service()
+export class DynamicObjectFactory {
+  /**
+   * Creates and decorates two new Objects to connect two entities via Relay
+   * Will return a relay Edge and Connection Object to be used when fetching this specific object
+   * @param connectionName name of the connection, usually `EntitAEntityB`
+   * @param nodeType type of the EntityB
+   * @param edgeAugment if the relation is N:M, "augment" the edge with the join table
+   */
+  public makeEdgeConnection<T extends TypeValue> (
+    connectionName: string,
+    nodeType: () => T,
+    edgeAugment?: () => new () => Object): { Connection: new () => Relay.Connection<T>; Edge: new () => Relay.Edge<T> } {
+    if (!edgeAugment) edgeAugment = () => Object
+    const PageInfo = this._getPageInfo()
+    const Edge = this._makeEdge(connectionName, nodeType, edgeAugment)
+    const Connection = this._makeConnection(connectionName, Edge, PageInfo)
+
+    return { Edge, Connection }
+  }
+
+  /**
+   * Create the Edge for the given node type & augment
+   * @param connectionName name of the connection to prefix the edge
+   * @param nodeType type of the node for this edge
+   * @param edgeAugment optional type to augment the edge with
+   */
+  protected _makeEdge<T extends TypeValue> (connectionName: string, nodeType: () => T, edgeAugment: () => new () => any): new () => Relay.Edge<T> {
+    const Edge = class extends edgeAugment().prototype.constructor implements Relay.Edge<T> {
+      public node!: T;
+
+      public cursor!: Relay.ConnectionCursor;
+    }
+
+    Object.assign(Edge, edgeAugment())
+
+    Field(nodeType)(Edge.prototype, 'node')
+    Field(() => String, { description: 'Used in `before` and `after` args' })(Edge.prototype, 'cursor')
+    ObjectType(`${connectionName}Edge`)(Edge)
+
+    return Edge
+  }
+
+  /**
+   * Create the Connection object for the given Edge
+   * @param connectionName name of the connection to prefix the object
+   * @param Edge type of the edges we want to have in this connection
+   * @param PageInfo type of the PageInfo we're using
+   */
+  protected _makeConnection<T extends TypeValue> (connectionName: string, Edge: new () => Relay.Edge<T>, PageInfo: new () => Relay.PageInfo): new () => Relay.Connection<T> {
+    @ObjectType(`${connectionName}Connection`)
+    class Connection implements Relay.Connection<T> {
+        @Field(() => PageInfo)
+      public pageInfo!: Relay.PageInfo;
+
+        @Field(() => [Edge])
+        public edges!: Relay.Edge<T>[];
+    }
+
+    return Connection
+  }
+
+  /**
+   * Get the local PageInfo model
+   * @throws if PageInfo cannot be accessed.
+   */
+  protected _getPageInfo (): new () => Relay.PageInfo {
+    try {
+      const PageInfoFn: () => (new () => Relay.PageInfo) = Container.get('PAGINATION_OBJECT')
+      const PageInfo = PageInfoFn()
+
+      if (!PageInfo) throw new Error()
+      return PageInfo
+    } catch (e) {
+      throw new Error(`Couldn't find PageInfo Object. Did you forget to init TypeRelay?`)
+    }
+  }
+}

packages/type-relay/src/graphql/dynamic-object.factory.ts

@@ -41,7 +41,7 @@ export class SharedObjectFactory {
    */
   public generateConnectionArgs (prefix: string): new () => Relay.ConnectionArguments {
     const argsName = `${prefix}ConnectionArgs`
-    // This is trick so the local class will be called argsName, as the ArgsType decorator doesn't take
+    // This is a trick so the local class will be called argsName, as the ArgsType decorator doesn't take
     // a name argument and instead uses the class name in the SDL.
     const darkMagic = {
       [argsName]: class implements Relay.ConnectionArguments {

packages/type-relay/tests/graphql/shared-object.factory.test.ts renamed to packages/type-relay/src/graphql/shared-object.factory.spec.ts

@@ -1,4 +1,4 @@
-import { TypeRelayConfig } from './../../src/services/type-relay-config.service'
+import { TypeRelayConfig } from './type-relay-config.service'
 import {Container} from 'typedi'
 describe('TypeRelayConfig', () => {
   let typeRelayConfig: TypeRelayConfig | null = null