@rxdi/neo4j 0.7.152 → 0.7.153

package/README.md

@@ -3,6 +3,7 @@
 [![Build Status](https://travis-ci.org/rxdi/neo4j.svg?branch=master)](https://travis-ci.org/rxdi/neo4j)
 
 ##### For questions/issues you can write ticket [here](http://gitlab.youvolio.com/rxdi/neo4j/issues)
+
 ##### This module is intended to be used with [rxdi](https://github.com/rxdi/core)
 
 > With this module by just defining your types and adding them inside `types` property you will have `CRUD` operations generated automatically
@@ -12,6 +13,7 @@
 > Why is this so cool ? :)) Because while you are writing your schema you can have also `queries` and `mutations` prepared for you to execute inside `Neo4J Graph`
 
 ## Installation and basic examples:
+
 ##### To install this module, run:
 
 ```bash
@@ -21,86 +23,56 @@ $ npm install @rxdi/neo4j --save
 ## Consuming @rxdi/neo4j
 
 ##### Simple approach
+
 ```typescript
 import { Module, CoreModule } from '@gapi/core';
 import { Neo4JModule } from '@rxdi/neo4j';
 import { UserType } from './user.type';
 
 @Module({
-  imports: [
-    CoreModule.forRoot(),
-    Neo4JModule.forRoot({
-      types: [UserType],
-      password: '12345678',
-      username: 'neo4j',
-      address: 'bolt://localhost:7687',
-      excludedTypes: {
-        mutation: {
-          exclude: [UserType]
-        }
-      }
-    })
-  ]
+ imports: [
+  CoreModule.forRoot(),
+  Neo4JModule.forRoot({
+   password: '12345678',
+   username: 'neo4j',
+   address: 'bolt://localhost:7687',
+  }),
+ ],
 })
 export class AppModule {}
 ```
 
-#####  Simple GraphqlObject `UserType`
-```typescript
-import { GraphQLObjectType, GraphQLString } from 'graphql';
-
-export const UserType = new GraphQLObjectType({
-  name: 'User',
-  fields: () => ({
-    userName: {
-      type: GraphQLString
-    },
-  })
-});
-
-```
-
-
 ##### More complex Approach
 
 ```typescript
 import { Module, CoreModule } from '@gapi/core';
-import { Neo4JModule } from '@rxdi/neo4j';
-import { UserType } from './user.type';
+import { Neo4JModule, UtilService } from '@rxdi/neo4j';
 import { GraphQLSchema } from 'graphql';
 
 @Module({
-  imports: [
-    Neo4JModule.forRoot({
-      types: [
-        UserType
-      ],
-      schemaOverride(schema: GraphQLSchema) {
-        return neo4jgql.makeAugmentedSchema({
-          typeDefs: printSchema(schema),
-          config: {
-            mutation: {
-                exclude: [UserType.name]
-            }
-          }
-        });
-      },
-      async onRequest(graphqlRequest, request, h, err) {
-        const context = {
-          driver: neo4j.driver(
-            'bolt://localhost:7687',
-            neo4j.auth.basic('neo4j', '12345678')
-          )
-        }
-        return graphqlRequest(context);
-      }
-    }),
-  ]
+ imports: [
+  Neo4JModule.forRoot({
+   schemaOverride(schema: GraphQLSchema) {
+    const neo4JUtils = Container.get(UtilService);
+    neo4JUtils.validateSchema(schema);
+
+    const typeDefs = neo4JUtils.generateTypeDefs(schema);
+
+    const neoSchema = new Neo4jGraphQL({
+     typeDefs,
+     driver,
+     assumeValidSDL: true,
+    });
+    return neoSchema;
+   },
+  }),
+ ],
 })
 export class AppModule {}
 ```
 
 ##### Import inside AppModule or CoreModule
+
 ```typescript
 import { Module, CoreModule } from '@gapi/core';
 import { VoyagerModule } from '@gapi/voyager';
@@ -112,38 +84,26 @@ import { Channel } from './types/channel/channel.type';
 import { AttachmentType } from './types/attachment/attachment.type';
 import { ToUpperCaseDirective } from './core/directives/toUppercase.directive';
 
-// import { AppQueriesController } from './app.controller';
-// Uncomment to override some methods which are provided from neo4js
-
 @Module({
-  // controllers: [AppQueriesController],
-  imports: [
-    CoreModule.forRoot({
-      graphql: { directives: [ToUpperCaseDirective] }
-    }),
-    Neo4JModule.forRoot({
-      types: [UserContext, User, Message, Channel, AttachmentType],
-      username: 'neo4j',
-      password: '12345678',
-      address: 'bolt://localhost:7687',
-      context: {},
-      excludedTypes: {
-        mutation: {
-          exclude: [UserContext]
-        }
-      }
-    }),
-    // Optional voyager but you will not regret to have mind mapping for all your graph api :) npm i @gapi/voyager
-    VoyagerModule.forRoot({
-      endpointUrl: '/graphql',
-      path: '/voyager'
-    })
-  ]
+ imports: [
+  CoreModule.forRoot({
+   graphql: { directives: [ToUpperCaseDirective] },
+  }),
+  Neo4JModule.forRoot({
+   username: 'neo4j',
+   password: '12345678',
+   address: 'bolt://localhost:7687',
+  }),
+  // Optional voyager but you will not regret to have mind mapping for all your graph api :) npm i @gapi/voyager
+  VoyagerModule.forRoot({
+   endpointUrl: '/graphql',
+   path: '/voyager',
+  }),
+ ],
 })
 export class AppModule {}
 ```
 
-
 ##### Graphql Directive
 
 ```typescript
@@ -151,141 +111,13 @@ import { GraphQLCustomDirective } from '@gapi/core';
 import { DirectiveLocation } from 'graphql';
 
 export const ToUpperCaseDirective = new GraphQLCustomDirective<string>({
-  name: 'toUpperCase',
-  description: 'change the case of a string to uppercase',
-  locations: [DirectiveLocation.FIELD],
-  resolve: async resolve => (await resolve()).toUpperCase()
+ name: 'toUpperCase',
+ description: 'change the case of a string to uppercase',
+ locations: [DirectiveLocation.FIELD],
+ resolve: async (resolve) => (await resolve()).toUpperCase(),
 });
 ```
 
-
-##### Interceptor
-```typescript
-import { Observable } from 'rxjs';
-import { tap } from 'rxjs/operators';
-import { Service } from '@rxdi/core';
-import { InterceptResolver, GenericGapiResolversType } from '@gapi/core';
-import { GraphQLContext } from '../../app.context';
-
-@Service()
-export class LoggerInterceptor implements InterceptResolver {
-  intercept(
-    chainable$: Observable<any>,
-    context: GraphQLContext,
-    payload,
-    descriptor: GenericGapiResolversType
-  ) {
-    console.log('Before...');
-    const now = Date.now();
-    return chainable$.pipe(
-      tap(() => console.log(`After... ${Date.now() - now}ms`))
-    );
-  }
-}
-```
-
-
-##### Guard
-```typescript
-import { Service } from '@rxdi/core';
-import { CanActivateResolver, GenericGapiResolversType } from '@gapi/core';
-import { GraphQLContext } from '../../app.context';
-
-@Service()
-export class AdminOnly implements CanActivateResolver {
-  canActivate(
-    context: GraphQLContext,
-    payload,
-    descriptor: GenericGapiResolversType
-  ) {
-    return false;
-  }
-}
-```
-
-
-##### Controller
-> The name of our class methods is important since we want to override default `neo4j-graphql` autogenerated types
-```typescript
-
-import { Controller, Type, Mutation, GraphQLString, Query, Interceptor, Guard } from '@gapi/core';
-import { Message } from './types/message/message.type';
-import { GraphQLContext } from './app.context';
-import { GraphQLList } from 'graphql';
-import { graphRequest } from '@rxdi/neo4j';
-import { IMessage } from './core/api-introspection';
-import { LoggerInterceptor } from './core/interceptors/logger.interceptor';
-import { AdminOnly } from './core/guards/admin-only.guard';
-
-@Controller()
-export class AppQueriesController {
-
-  @Interceptor(LoggerInterceptor)
-  @Type(Message)
-  @Guard(AdminOnly)
-  @Mutation({
-    messageId: {
-      type: GraphQLString
-    },
-    channelId: {
-      type: GraphQLString
-    }
-  })
-  CreateMessage(root, params, ctx: GraphQLContext, resolveInfo): Promise<IMessage> {
-    return graphRequest<IMessage>(root, params, ctx, resolveInfo);
-  }
-
-  @Type(new GraphQLList(Message))
-  @Query({
-    messageId: {
-      type: GraphQLString
-    },
-    channelId: {
-      type: GraphQLString
-    }
-  })
-  Messages(root, params, ctx: GraphQLContext, resolveInfo): Promise<IMessage[]> {
-    return graphRequest<IMessage[]>(root, params, ctx, resolveInfo);
-  }
-
-  @Type(Message)
-  @Query({
-    messageId: {
-      type: GraphQLString
-    },
-    channelId: {
-      type: GraphQLString
-    }
-  })
-  Message(root, params, ctx: GraphQLContext, resolveInfo): Promise<IMessage> {
-    return graphRequest<IMessage>(root, params, ctx, resolveInfo);
-  }
-}
-
-```
-
-##### Context interface
-
-```typescript
-import { Driver } from '@rxdi/neo4j';
-
-export interface GraphQLContext {
-  driver: Driver;
-}
-```
-
-##### Example query
-> Note: `offset`, `first`, `orderBy` are autogenerated for convenience
-
-```graphql
-query {
-  User(userName: "your-name", first: 10, offset: 10, orderBy: userName_asc) {
-    userName
-  }
-}
-```
-
-
 TODO: Better documentation...
 
 Enjoy ! :)

package/dist/index.d.ts

@@ -2,7 +2,6 @@ import { ModuleWithServices } from '@rxdi/core';
 import { NEO4J_MODULE_CONFIG } from './injection.tokens';
 export declare class Neo4JModule {
     static forRoot(config?: NEO4J_MODULE_CONFIG): ModuleWithServices;
-    static forChild(types: string[] | Function[]): void;
 }
 export * from './injection.tokens';
-export * from './services/index';
+export * from './services';

package/dist/index.js

@@ -15,16 +15,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var Neo4JModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Neo4JModule = void 0;
 const core_1 = require("@rxdi/core");
-const type_service_1 = require("./services/type.service");
 const injection_tokens_1 = require("./injection.tokens");
 const graphql_1 = require("@rxdi/graphql");
 const util_service_1 = require("./services/util.service");
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
 let Neo4JModule = Neo4JModule_1 = class Neo4JModule {
     static forRoot(config = {}) {
         return {
@@ -34,17 +40,6 @@ let Neo4JModule = Neo4JModule_1 = class Neo4JModule {
                     provide: injection_tokens_1.NEO4J_MODULE_CONFIG,
                     useValue: config
                 },
-                {
-                    provide: injection_tokens_1.NEO4J_MODULE_CONFIG,
-                    deps: [injection_tokens_1.NEO4J_MODULE_CONFIG, type_service_1.TypeService],
-                    lazy: true,
-                    useFactory: (config, typeService) => (0, rxjs_1.of)(config).pipe((0, operators_1.map)(c => typeService.extendExcludedTypes(c)))
-                },
-                {
-                    provide: injection_tokens_1.Neo4JTypes,
-                    deps: [type_service_1.TypeService, injection_tokens_1.NEO4J_MODULE_CONFIG],
-                    useFactory: (typeService, config) => typeService.addTypes(config.types)
-                },
                 ...(config.onRequest
                     ? [
                         {
@@ -70,20 +65,19 @@ let Neo4JModule = Neo4JModule_1 = class Neo4JModule {
                     : [
                         {
                             provide: graphql_1.SCHEMA_OVERRIDE,
-                            deps: [util_service_1.UtilService],
-                            useFactory: (util) => (schema) => util.augmentSchema(schema)
+                            deps: [util_service_1.UtilService, injection_tokens_1.NEO4J_DRIVER],
+                            useFactory: (util, driver) => (schema) => __awaiter(this, void 0, void 0, function* () { return util.augmentSchema(schema)(driver); })
                         }
                     ])
             ]
         };
     }
-    static forChild(types) { }
 };
 Neo4JModule = Neo4JModule_1 = __decorate([
     (0, core_1.Module)({
-        providers: [type_service_1.TypeService]
+        providers: []
     })
 ], Neo4JModule);
 exports.Neo4JModule = Neo4JModule;
 __exportStar(require("./injection.tokens"), exports);
-__exportStar(require("./services/index"), exports);
+__exportStar(require("./services"), exports);

package/dist/injection.tokens.d.ts

@@ -1,13 +1,7 @@
 import { InjectionToken } from '@rxdi/core';
 import { GraphQLObjectType, GraphQLSchema } from 'graphql';
 import { ResponseToolkit } from 'hapi';
-import { AugmentSchemaConfig } from 'neo4j-graphql-js';
-export declare const Neo4JTypes: InjectionToken<GraphQLObjectType<any, any, {
-    [key: string]: any;
-}>[]>;
-interface Neo4JTypesPrivate extends GraphQLObjectType {
-}
-export declare type Neo4JTypes = Neo4JTypesPrivate[];
+import { Driver } from 'neo4j-driver';
 export declare const NEO4J_MODULE_CONFIG: InjectionToken<NEO4J_MODULE_CONFIG>;
 export declare type IExcludeType = string | Function | GraphQLObjectType;
 export interface ExcludedTypes {
@@ -31,18 +25,18 @@ export interface RelationshipMap {
     [key: string]: RelationshipType;
 }
 export interface NEO4J_MODULE_CONFIG {
-    types?: GraphQLObjectType[];
     username?: string;
     password?: string;
     address?: string | 'bolt://localhost:7687';
-    excludedTypes?: AugmentSchemaConfig;
     debug?: boolean;
     auth?: boolean;
     context?: any;
     onRequest?(next: any, request: Request, h: ResponseToolkit, err: Error): Promise<any>;
     schemaOverride?(schema: GraphQLSchema): GraphQLSchema;
 }
+/**
+ * Neo4j driver @rxdi injection token
+ */
 export declare const NEO4J_DRIVER: InjectionToken<unknown>;
-declare const graphRequest: <T>(root: any, params: any, ctx: any, resolveInfo: any) => Promise<T>;
-export { graphRequest };
+export declare type NEO4J_DRIVER = Driver;
 export { Driver } from 'neo4j-driver';

package/dist/injection.tokens.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.graphRequest = exports.NEO4J_DRIVER = exports.NEO4J_MODULE_CONFIG = exports.Neo4JTypes = void 0;
+exports.NEO4J_DRIVER = exports.NEO4J_MODULE_CONFIG = void 0;
 const core_1 = require("@rxdi/core");
-const neo4j_graphql_js_1 = require("neo4j-graphql-js");
-exports.Neo4JTypes = new core_1.InjectionToken('GAPI_NEO4J_TYPES');
 exports.NEO4J_MODULE_CONFIG = new core_1.InjectionToken('GAPI_NEO4J_MODULE_CONFIG');
+/**
+ * Neo4j driver @rxdi injection token
+ */
 exports.NEO4J_DRIVER = new core_1.InjectionToken('GAPI_NEO4J_MODULE_CONFIG');
-const graphRequest = (root, params, ctx, resolveInfo) => (0, neo4j_graphql_js_1.neo4jgraphql)(root, params, ctx, resolveInfo);
-exports.graphRequest = graphRequest;

package/dist/services/index.d.ts

@@ -1,2 +1 @@
-export * from './type.service';
 export * from './util.service';

package/dist/services/index.js

@@ -10,5 +10,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./type.service"), exports);
 __exportStar(require("./util.service"), exports);

package/dist/services/util.service.d.ts

@@ -1,14 +1,14 @@
-import { NEO4J_MODULE_CONFIG } from '../injection.tokens';
-import { GRAPHQL_PLUGIN_CONFIG } from '@rxdi/graphql';
+import { NEO4J_DRIVER, NEO4J_MODULE_CONFIG } from '../injection.tokens';
 import * as neo4j from 'neo4j-driver';
 import { GraphQLSchema } from 'graphql';
 export declare class UtilService {
     private config;
-    private gqlConfig;
-    constructor(config: NEO4J_MODULE_CONFIG, gqlConfig: GRAPHQL_PLUGIN_CONFIG);
+    constructor(config: NEO4J_MODULE_CONFIG);
     private extendSchemaDirectives;
     private validateSchema;
-    augmentSchema(schema: GraphQLSchema): GraphQLSchema;
+    augmentSchema(schema: GraphQLSchema): (driver: NEO4J_DRIVER) => Promise<GraphQLSchema>;
     mergeSchemas(...schemas: GraphQLSchema[]): GraphQLSchema;
     assignDriverToContext(): neo4j.Driver;
+    generateTypeDefs(schema: GraphQLSchema): string;
+    private findRelations;
 }

package/dist/services/util.service.js

@@ -11,20 +11,26 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilService = void 0;
 const core_1 = require("@rxdi/core");
-const neo4jgql = require("neo4j-graphql-js");
 const injection_tokens_1 = require("../injection.tokens");
-const graphql_1 = require("@rxdi/graphql");
 const graphql_tools_1 = require("graphql-tools");
 const neo4j = require("neo4j-driver");
-const generate_type_defs_1 = require("../helpers/generate-type-defs");
+const graphql_1 = require("@neo4j/graphql");
 const graphql_2 = require("graphql");
 let UtilService = class UtilService {
-    constructor(config, gqlConfig) {
+    constructor(config) {
         this.config = config;
-        this.gqlConfig = gqlConfig;
     }
     extendSchemaDirectives(augmentedSchema, schema) {
         augmentedSchema['_directives'] = schema['_directives'];
@@ -37,11 +43,16 @@ let UtilService = class UtilService {
         }
     }
     augmentSchema(schema) {
-        this.validateSchema(schema);
-        return this.extendSchemaDirectives(neo4jgql.makeAugmentedSchema({
-            typeDefs: (0, generate_type_defs_1.generateTypeDefs)(schema),
-            config: this.config.excludedTypes
-        }), schema);
+        return (driver) => __awaiter(this, void 0, void 0, function* () {
+            this.validateSchema(schema);
+            const typeDefs = this.generateTypeDefs(schema);
+            const neoSchema = new graphql_1.Neo4jGraphQL({
+                typeDefs,
+                driver,
+                assumeValidSDL: true,
+            });
+            return this.extendSchemaDirectives(yield neoSchema.getSchema(), schema);
+        });
     }
     mergeSchemas(...schemas) {
         return this.extendSchemaDirectives((0, graphql_tools_1.mergeSchemas)({
@@ -49,16 +60,44 @@ let UtilService = class UtilService {
         }), schemas.filter(s => !!s)[0]);
     }
     assignDriverToContext() {
-        const driver = neo4j.driver(this.config.address || 'bolt://localhost:7687', neo4j.auth.basic(this.config.username, this.config.password));
-        this.gqlConfig.graphqlOptions.context = this.gqlConfig.graphqlOptions.context || {};
-        Object.assign(this.gqlConfig.graphqlOptions.context, { driver });
-        return driver;
+        return neo4j.driver(this.config.address || 'bolt://localhost:7687', neo4j.auth.basic(this.config.username, this.config.password));
+    }
+    generateTypeDefs(schema) {
+        return Object.values(this.findRelations(schema)).reduce((curr, prev) => curr.replace(prev.searchIndex, prev.replaceWith), (0, graphql_2.printSchema)(schema));
+    }
+    findRelations(schema) {
+        const relations = {};
+        Object.values(schema.getQueryType()).forEach(field => {
+            if (!field) {
+                return;
+            }
+            if (typeof field === 'string') {
+                return;
+            }
+            Object.keys(field).reduce((prev, currentType) => {
+                const type = field[currentType].type;
+                if (type && typeof type.getFields === 'function') {
+                    Object.entries(type.getFields()).map(([key, value]) => {
+                        relations[currentType] =
+                            relations[currentType] || {};
+                        const relation = value['relation'];
+                        if (typeof relation === 'object') {
+                            relations[currentType].searchIndex = `${key}: ${value.type}`;
+                            const cyper = relation.cyper ||
+                                `@relationship(type: "${relation.name}", direction: ${relation.direction})`;
+                            relations[currentType].replaceWith = `${relations[currentType].searchIndex} ${cyper}`;
+                        }
+                    });
+                }
+                return prev;
+            }, {});
+        });
+        return relations;
     }
 };
 UtilService = __decorate([
     (0, core_1.Injectable)(),
     __param(0, (0, core_1.Inject)(injection_tokens_1.NEO4J_MODULE_CONFIG)),
-    __param(1, (0, core_1.Inject)(graphql_1.GRAPHQL_PLUGIN_CONFIG)),
-    __metadata("design:paramtypes", [Object, Object])
+    __metadata("design:paramtypes", [Object])
 ], UtilService);
 exports.UtilService = UtilService;

package/package.json

@@ -1,72 +1,72 @@
 {
-  "name": "@rxdi/neo4j",
-  "version": "0.7.152",
-  "description": "",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "module": "./dist/index.js",
-  "typings": "./dist/index.d.ts",
-  "files": [
-    "dist"
+ "name": "@rxdi/neo4j",
+ "version": "0.7.153",
+ "description": "",
+ "main": "./dist/index.js",
+ "types": "./dist/index.d.ts",
+ "module": "./dist/index.js",
+ "typings": "./dist/index.d.ts",
+ "files": [
+  "dist"
+ ],
+ "scripts": {
+  "lint": "tslint -c tslint.json 'src/**/*.{ts,tsx}'",
+  "pretest": "npm run lint",
+  "test": "echo Test Neo4J",
+  "build": "tsc || true"
+ },
+ "repository": {
+  "type": "git",
+  "url": "https://github.com/rxdi/neo4j"
+ },
+ "author": "Kristiyan Tachev (@Stradivario)",
+ "license": "MIT",
+ "bugs": {
+  "url": "https://github.com/rxdi/neo4j/issues"
+ },
+ "homepage": "https://github.com/rxdi/neo4j/blob/master/README.md",
+ "dependencies": {
+  "@neo4j/graphql": "^3.8.0",
+  "neo4j-driver": "^5.0.1"
+ },
+ "devDependencies": {
+  "graphql": "^14.5.8",
+  "@types/graphql": "^14.5.0",
+  "graphql-tools": "^5.0.0",
+  "@rxdi/core": "^0.7.152",
+  "@rxdi/graphql": "^0.7.152",
+  "@types/hapi": "^18.0.4",
+  "@types/jest": "^24.0.22",
+  "@types/node": "^12.0.10",
+  "jest": "^24.8.0",
+  "jest-cli": "^24.8.1",
+  "ts-jest": "^24.0.2",
+  "tslint": "^5.20.1",
+  "tslint-language-service": "^0.9.9",
+  "typescript": "^4.3.5"
+ },
+ "jest": {
+  "testEnvironment": "node",
+  "testPathIgnorePatterns": [
+   "/node_modules/"
   ],
-  "scripts": {
-    "lint": "tslint -c tslint.json 'src/**/*.{ts,tsx}'",
-    "pretest": "npm run lint",
-    "test": "echo Test Neo4J",
-    "build": "tsc || true"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/rxdi/neo4j"
-  },
-  "author": "Kristiyan Tachev (@Stradivario)",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/rxdi/neo4j/issues"
-  },
-  "homepage": "https://github.com/rxdi/neo4j/blob/master/README.md",
-  "dependencies": {
-    "neo4j-driver": "^5.0.1",
-    "neo4j-graphql-js": "^2.19.4"
-  },
-  "devDependencies": {
-    "graphql": "^14.5.8",
-    "@types/graphql": "^14.5.0",
-    "graphql-tools": "^5.0.0",
-    "@rxdi/core": "^0.7.151",
-    "@rxdi/graphql": "^0.7.151",
-    "@types/hapi": "^18.0.4",
-    "@types/jest": "^24.0.22",
-    "@types/node": "^12.0.10",
-    "jest": "^24.8.0",
-    "jest-cli": "^24.8.1",
-    "ts-jest": "^24.0.2",
-    "tslint": "^5.20.1",
-    "tslint-language-service": "^0.9.9",
-    "typescript": "^4.3.5"
+  "coverageReporters": [
+   "lcov",
+   "html"
+  ],
+  "rootDir": "./",
+  "moduleFileExtensions": [
+   "ts",
+   "tsx",
+   "js",
+   "json",
+   "node"
+  ],
+  "transform": {
+   "\\.(ts|tsx)$": "ts-jest"
   },
-  "jest": {
-    "testEnvironment": "node",
-    "testPathIgnorePatterns": [
-      "/node_modules/"
-    ],
-    "coverageReporters": [
-      "lcov",
-      "html"
-    ],
-    "rootDir": "./",
-    "moduleFileExtensions": [
-      "ts",
-      "tsx",
-      "js",
-      "json",
-      "node"
-    ],
-    "transform": {
-      "\\.(ts|tsx)$": "ts-jest"
-    },
-    "testRegex": "/src/.*\\.spec.(ts|tsx|js)$",
-    "verbose": true,
-    "collectCoverage": true
-  }
+  "testRegex": "/src/.*\\.spec.(ts|tsx|js)$",
+  "verbose": true,
+  "collectCoverage": true
+ }
 }

package/dist/helpers/generate-type-defs.d.ts

@@ -1,4 +0,0 @@
-import { GraphQLSchema } from 'graphql';
-import { RelationshipMap } from '../injection.tokens';
-export declare function findRelations(schema: GraphQLSchema): RelationshipMap;
-export declare function generateTypeDefs(schema: GraphQLSchema): string;

package/dist/helpers/generate-type-defs.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateTypeDefs = exports.findRelations = void 0;
-const graphql_1 = require("graphql");
-function findRelations(schema) {
-    const relations = {};
-    Object.values(schema.getQueryType()).forEach(field => {
-        if (!field) {
-            return;
-        }
-        if (typeof field === 'string') {
-            return;
-        }
-        Object.keys(field).reduce((prev, currentType) => {
-            const type = schema.getType(`${currentType}`);
-            console.log(type, currentType);
-            if (type) {
-                Object.entries(type.getFields()).map(([key, value]) => {
-                    relations[currentType] =
-                        relations[currentType] || {};
-                    const relation = value['relation'];
-                    if (typeof relation === 'object') {
-                        relations[currentType].searchIndex = `${key}: ${value.type}`;
-                        const cyper = relation.cyper ||
-                            `@relation(name: "${relation.name}", direction: "${relation.direction}")`;
-                        relations[currentType].replaceWith = `${relations[currentType].searchIndex} ${cyper}`;
-                    }
-                });
-            }
-            return prev;
-        }, {});
-    });
-    return relations;
-}
-exports.findRelations = findRelations;
-function generateTypeDefs(schema) {
-    return Object.values(findRelations(schema)).reduce((curr, prev) => curr.replace(prev.searchIndex, prev.replaceWith), (0, graphql_1.printSchema)(schema));
-}
-exports.generateTypeDefs = generateTypeDefs;

package/dist/helpers/index.d.ts

@@ -1,8 +0,0 @@
-import { IExcludeType, NEO4J_MODULE_CONFIG } from '../injection.tokens';
-export declare const mapToString: (a: IExcludeType[]) => string[];
-export declare const exclude: (c: NEO4J_MODULE_CONFIG, type: 'query' | 'mutation', defaultExcludedTypes: IExcludeType[]) => {
-    [x: string]: {
-        exclude: IExcludeType[];
-    };
-};
-export * from './generate-type-defs';

package/dist/helpers/index.js

@@ -1,22 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exclude = exports.mapToString = void 0;
-const mapToString = (a) => a.map(t => t.toString());
-exports.mapToString = mapToString;
-const exclude = (c, type, defaultExcludedTypes) => ({
-    [type]: {
-        exclude: defaultExcludedTypes.concat(...c.excludedTypes[type]['exclude'])
-    }
-});
-exports.exclude = exclude;
-__exportStar(require("./generate-type-defs"), exports);

package/dist/services/type.service.d.ts

@@ -1,18 +0,0 @@
-import { GraphQLObjectType } from 'graphql';
-import { NEO4J_MODULE_CONFIG } from '../injection.tokens';
-export declare class TypeService {
-    private defaultExcludedTypes;
-    private _registeredTypesMap;
-    private _registeredTypes;
-    get types(): GraphQLObjectType<any, any, {
-        [key: string]: any;
-    }>[];
-    getType(type: GraphQLObjectType): GraphQLObjectType<any, any, {
-        [key: string]: any;
-    }>;
-    private addType;
-    addTypes(types?: GraphQLObjectType[]): GraphQLObjectType<any, any, {
-        [key: string]: any;
-    }>[];
-    extendExcludedTypes(c: NEO4J_MODULE_CONFIG): NEO4J_MODULE_CONFIG;
-}

package/dist/services/type.service.js

@@ -1,45 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeService = void 0;
-const core_1 = require("@rxdi/core");
-const helpers_1 = require("../helpers");
-let TypeService = class TypeService {
-    constructor() {
-        this.defaultExcludedTypes = ['Subscription', 'StatusQueryType'];
-        this._registeredTypesMap = new Map();
-        this._registeredTypes = [];
-    }
-    get types() {
-        return this._registeredTypes;
-    }
-    getType(type) {
-        return this._registeredTypesMap.get(type.name);
-    }
-    addType(type) {
-        this._registeredTypesMap.set(type.name, type);
-        this._registeredTypes.push(type);
-    }
-    addTypes(types = []) {
-        types.forEach(type => this.addType(type));
-        return this._registeredTypes;
-    }
-    extendExcludedTypes(c) {
-        c.excludedTypes = c.excludedTypes || {};
-        c.excludedTypes.query = c.excludedTypes.query || { exclude: [] };
-        c.excludedTypes.mutation = c.excludedTypes.mutation || { exclude: [] };
-        c.excludedTypes = Object.assign(Object.assign({}, (0, helpers_1.exclude)(c, 'mutation', this.defaultExcludedTypes)), (0, helpers_1.exclude)(c, 'query', this.defaultExcludedTypes));
-        c.excludedTypes.mutation['exclude'] = (0, helpers_1.mapToString)(c.excludedTypes.mutation['exclude']);
-        c.excludedTypes.mutation['exclude'] = (0, helpers_1.mapToString)(c.excludedTypes.mutation['exclude']);
-        return c;
-    }
-};
-TypeService = __decorate([
-    (0, core_1.Injectable)()
-], TypeService);
-exports.TypeService = TypeService;