@rxdi/neo4j 0.7.152 → 0.7.154

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 './neo4j.service';

package/dist/index.js

@@ -15,51 +15,37 @@ 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");
+const neo4j_service_1 = require("./neo4j.service");
 let Neo4JModule = Neo4JModule_1 = class Neo4JModule {
     static forRoot(config = {}) {
         return {
             module: Neo4JModule_1,
             providers: [
+                neo4j_service_1.UtilService,
                 {
                     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)
+                    provide: injection_tokens_1.NEO4J_DRIVER,
+                    deps: [neo4j_service_1.UtilService],
+                    useFactory: (util) => util.createDriver()
                 },
-                ...(config.onRequest
-                    ? [
-                        {
-                            provide: graphql_1.ON_REQUEST_HANDLER,
-                            deps: [injection_tokens_1.NEO4J_MODULE_CONFIG],
-                            useFactory: (config) => config.onRequest
-                        }
-                    ]
-                    : [
-                        {
-                            provide: injection_tokens_1.NEO4J_DRIVER,
-                            deps: [util_service_1.UtilService],
-                            useFactory: (util) => util.assignDriverToContext()
-                        }
-                    ]),
                 ...(config.schemaOverride
                     ? [
                         {
@@ -70,20 +56,19 @@ let Neo4JModule = Neo4JModule_1 = class Neo4JModule {
                     : [
                         {
                             provide: graphql_1.SCHEMA_OVERRIDE,
-                            deps: [util_service_1.UtilService],
-                            useFactory: (util) => (schema) => util.augmentSchema(schema)
+                            deps: [neo4j_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: [neo4j_service_1.UtilService]
     })
 ], Neo4JModule);
 exports.Neo4JModule = Neo4JModule;
 __exportStar(require("./injection.tokens"), exports);
-__exportStar(require("./services/index"), exports);
+__exportStar(require("./neo4j.service"), exports);

package/dist/injection.tokens.d.ts

@@ -1,26 +1,17 @@
 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 { GraphQLSchema } from 'graphql';
+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 {
-    mutation?: {
-        exclude: IExcludeType[];
-    };
-    query?: {
-        exclude: IExcludeType[];
-    };
+export interface NEO4J_MODULE_CONFIG {
+    username?: string;
+    password?: string;
+    address?: string | 'bolt://localhost:7687';
+    schemaOverride?(schema: GraphQLSchema): GraphQLSchema;
 }
 export interface RelationshipType {
-    searchIndex: string;
-    replaceWith: string;
+    searchIndex?: string;
+    replaceWith?: string;
+    extends?: string;
 }
 export interface Relationship {
     direction: 'IN' | 'OUT';
@@ -30,19 +21,10 @@ export interface Relationship {
 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';
+export declare function gql(...args: any[]): any;

package/dist/injection.tokens.js

@@ -1,10 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.graphRequest = exports.NEO4J_DRIVER = exports.NEO4J_MODULE_CONFIG = exports.Neo4JTypes = void 0;
+exports.gql = 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');
-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;
+/**
+ * Neo4j driver @rxdi injection token
+ */
+exports.NEO4J_DRIVER = new core_1.InjectionToken('GAPI_NEO4J_MODULE_DRIVER');
+function gql(...args) {
+    const literals = args[0];
+    let result = typeof literals === 'string' ? literals : literals[0];
+    for (let i = 1; i < args.length; i++) {
+        if (args[i] && args[i].kind && args[i].kind === 'Document') {
+            result += args[i].loc.source.body;
+        }
+        else {
+            result += args[i];
+        }
+        result += literals[i];
+    }
+    return result;
+}
+exports.gql = gql;

package/dist/neo4j.service.d.ts

@@ -0,0 +1,15 @@
+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;
+    constructor(config: NEO4J_MODULE_CONFIG);
+    private extendSchemaDirectives;
+    private validateSchema;
+    private replaceAll;
+    augmentSchema(schema: GraphQLSchema): (driver: NEO4J_DRIVER) => Promise<GraphQLSchema>;
+    mergeSchemas(...schemas: GraphQLSchema[]): GraphQLSchema;
+    createDriver(): neo4j.Driver;
+    generateTypeDefs(schema: GraphQLSchema): string;
+    private findSchemaExtensions;
+}

package/dist/neo4j.service.js

@@ -0,0 +1,115 @@
+"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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(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 injection_tokens_1 = require("./injection.tokens");
+const graphql_tools_1 = require("graphql-tools");
+const neo4j = require("neo4j-driver");
+const graphql_1 = require("@neo4j/graphql");
+const graphql_2 = require("graphql");
+let UtilService = class UtilService {
+    constructor(config) {
+        this.config = config;
+    }
+    extendSchemaDirectives(augmentedSchema, schema) {
+        augmentedSchema['_directives'] = schema['_directives'];
+        return augmentedSchema;
+    }
+    validateSchema(schema) {
+        const schemaErrors = (0, graphql_2.validateSchema)(schema);
+        if (schemaErrors.length) {
+            throw new Error(JSON.stringify(schemaErrors));
+        }
+    }
+    replaceAll(value) {
+        return (search) => (replacement) => value.split(search).join(replacement);
+    }
+    augmentSchema(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,
+            });
+            const augmentedSchema = yield neoSchema.getSchema();
+            return this.extendSchemaDirectives(augmentedSchema, schema);
+        });
+    }
+    mergeSchemas(...schemas) {
+        return this.extendSchemaDirectives((0, graphql_tools_1.mergeSchemas)({
+            schemas: schemas.filter(s => !!s)
+        }), schemas.filter(s => !!s)[0]);
+    }
+    createDriver() {
+        return neo4j.driver(this.config.address || 'bolt://localhost:7687', neo4j.auth.basic(this.config.username, this.config.password));
+    }
+    generateTypeDefs(schema) {
+        return Object.values(this.findSchemaExtensions(schema)).reduce((curr, prev) => {
+            if (prev.extends) {
+                return `${curr}\n${prev.extends}`;
+            }
+            return this.replaceAll(curr)(prev.searchIndex)(prev.replaceWith);
+        }, (0, graphql_2.printSchema)(schema));
+    }
+    findSchemaExtensions(schema) {
+        const extensions = {};
+        for (const field of Object.values(schema.getQueryType()).filter(i => !!i)) {
+            if (typeof field !== 'string') {
+                Object.keys(field).reduce((prev, currentType) => {
+                    const type = field[currentType].type;
+                    if (type['extend']) {
+                        extensions[currentType] = {
+                            extends: `extend type ${type.name} ${type['extend']}`
+                        };
+                    }
+                    if (type && typeof type.getFields === 'function') {
+                        for (const [key, value] of Object.entries(type.getFields())) {
+                            extensions[key] =
+                                extensions[key] || {};
+                            const relation = value['relation'];
+                            const directive = typeof relation === 'object' ?
+                                `@relationship(type: "${relation.name}", direction: ${relation.direction})`
+                                :
+                                    value['directive'];
+                            if (directive) {
+                                extensions[key].searchIndex = `${key}: ${value.type}`;
+                                extensions[key].replaceWith = `${extensions[key].searchIndex} ${directive}`;
+                            }
+                        }
+                    }
+                    return prev;
+                }, {});
+            }
+        }
+        return extensions;
+    }
+};
+UtilService = __decorate([
+    (0, core_1.Injectable)(),
+    __param(0, (0, core_1.Inject)(injection_tokens_1.NEO4J_MODULE_CONFIG)),
+    __metadata("design:paramtypes", [Object])
+], UtilService);
+exports.UtilService = UtilService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rxdi/neo4j",
-  "version": "0.7.152",
+  "version": "0.7.154",
   "description": "",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -26,15 +26,15 @@
   },
   "homepage": "https://github.com/rxdi/neo4j/blob/master/README.md",
   "dependencies": {
-    "neo4j-driver": "^5.0.1",
-    "neo4j-graphql-js": "^2.19.4"
+    "@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.151",
-    "@rxdi/graphql": "^0.7.151",
+    "@rxdi/core": "^0.7.153",
+    "@rxdi/graphql": "^0.7.153",
     "@types/hapi": "^18.0.4",
     "@types/jest": "^24.0.22",
     "@types/node": "^12.0.10",

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/index.d.ts

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

package/dist/services/index.js

@@ -1,14 +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 });
-__exportStar(require("./type.service"), exports);
-__exportStar(require("./util.service"), 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;

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

@@ -1,14 +0,0 @@
-import { NEO4J_MODULE_CONFIG } from '../injection.tokens';
-import { GRAPHQL_PLUGIN_CONFIG } from '@rxdi/graphql';
-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);
-    private extendSchemaDirectives;
-    private validateSchema;
-    augmentSchema(schema: GraphQLSchema): GraphQLSchema;
-    mergeSchemas(...schemas: GraphQLSchema[]): GraphQLSchema;
-    assignDriverToContext(): neo4j.Driver;
-}

package/dist/services/util.service.js

@@ -1,64 +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;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-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_2 = require("graphql");
-let UtilService = class UtilService {
-    constructor(config, gqlConfig) {
-        this.config = config;
-        this.gqlConfig = gqlConfig;
-    }
-    extendSchemaDirectives(augmentedSchema, schema) {
-        augmentedSchema['_directives'] = schema['_directives'];
-        return augmentedSchema;
-    }
-    validateSchema(schema) {
-        const schemaErrors = (0, graphql_2.validateSchema)(schema);
-        if (schemaErrors.length) {
-            throw new Error(JSON.stringify(schemaErrors));
-        }
-    }
-    augmentSchema(schema) {
-        this.validateSchema(schema);
-        return this.extendSchemaDirectives(neo4jgql.makeAugmentedSchema({
-            typeDefs: (0, generate_type_defs_1.generateTypeDefs)(schema),
-            config: this.config.excludedTypes
-        }), schema);
-    }
-    mergeSchemas(...schemas) {
-        return this.extendSchemaDirectives((0, graphql_tools_1.mergeSchemas)({
-            schemas: schemas.filter(s => !!s)
-        }), 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;
-    }
-};
-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])
-], UtilService);
-exports.UtilService = UtilService;