@rxdi/neo4j 0.7.153 → 0.7.155

package/dist/index.d.ts

@@ -4,4 +4,4 @@ export declare class Neo4JModule {
     static forRoot(config?: NEO4J_MODULE_CONFIG): ModuleWithServices;
 }
 export * from './injection.tokens';
-export * from './services';
+export * from './neo4j.service';

package/dist/index.js

@@ -30,31 +30,23 @@ exports.Neo4JModule = void 0;
 const core_1 = require("@rxdi/core");
 const injection_tokens_1 = require("./injection.tokens");
 const graphql_1 = require("@rxdi/graphql");
-const util_service_1 = require("./services/util.service");
+const neo4j_service_1 = require("./neo4j.service");
+const ogm_provider_1 = require("./ogm.provider");
 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
                 },
-                ...(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()
-                        }
-                    ]),
+                {
+                    provide: injection_tokens_1.NEO4J_DRIVER,
+                    deps: [neo4j_service_1.UtilService],
+                    useFactory: (util) => util.createDriver()
+                },
                 ...(config.schemaOverride
                     ? [
                         {
@@ -65,7 +57,7 @@ let Neo4JModule = Neo4JModule_1 = class Neo4JModule {
                     : [
                         {
                             provide: graphql_1.SCHEMA_OVERRIDE,
-                            deps: [util_service_1.UtilService, injection_tokens_1.NEO4J_DRIVER],
+                            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); })
                         }
                     ])
@@ -75,9 +67,9 @@ let Neo4JModule = Neo4JModule_1 = class Neo4JModule {
 };
 Neo4JModule = Neo4JModule_1 = __decorate([
     (0, core_1.Module)({
-        providers: []
+        providers: [neo4j_service_1.UtilService, ogm_provider_1.OGMProvider]
     })
 ], Neo4JModule);
 exports.Neo4JModule = Neo4JModule;
 __exportStar(require("./injection.tokens"), exports);
-__exportStar(require("./services"), exports);
+__exportStar(require("./neo4j.service"), exports);

package/dist/injection.tokens.d.ts

@@ -1,20 +1,17 @@
 import { InjectionToken } from '@rxdi/core';
-import { GraphQLObjectType, GraphQLSchema } from 'graphql';
-import { ResponseToolkit } from 'hapi';
+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';
@@ -24,19 +21,10 @@ export interface Relationship {
 export interface RelationshipMap {
     [key: string]: RelationshipType;
 }
-export interface NEO4J_MODULE_CONFIG {
-    username?: string;
-    password?: string;
-    address?: string | 'bolt://localhost:7687';
-    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>;
 export declare type NEO4J_DRIVER = Driver;
 export { Driver } from 'neo4j-driver';
+export declare function gql(...args: any[]): any;

package/dist/injection.tokens.js

@@ -1,9 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NEO4J_DRIVER = exports.NEO4J_MODULE_CONFIG = void 0;
+exports.gql = exports.NEO4J_DRIVER = exports.NEO4J_MODULE_CONFIG = void 0;
 const core_1 = require("@rxdi/core");
 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');
+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/{services/util.service.d.ts → neo4j.service.d.ts}

@@ -1,14 +1,18 @@
-import { NEO4J_DRIVER, NEO4J_MODULE_CONFIG } from '../injection.tokens';
+import { NEO4J_DRIVER, NEO4J_MODULE_CONFIG } from './injection.tokens';
 import * as neo4j from 'neo4j-driver';
 import { GraphQLSchema } from 'graphql';
+import { OGMProvider } from './ogm.provider';
 export declare class UtilService {
     private config;
-    constructor(config: NEO4J_MODULE_CONFIG);
+    private ogmProvider;
+    constructor(config: NEO4J_MODULE_CONFIG, ogmProvider: OGMProvider);
     private extendSchemaDirectives;
     private validateSchema;
+    private replaceAll;
     augmentSchema(schema: GraphQLSchema): (driver: NEO4J_DRIVER) => Promise<GraphQLSchema>;
+    initOgmClient(typeDefs: string): (driver: NEO4J_DRIVER) => Promise<void>;
     mergeSchemas(...schemas: GraphQLSchema[]): GraphQLSchema;
-    assignDriverToContext(): neo4j.Driver;
+    createDriver(): neo4j.Driver;
     generateTypeDefs(schema: GraphQLSchema): string;
-    private findRelations;
+    private findSchemaExtensions;
 }

package/dist/{services/util.service.js → neo4j.service.js}

@@ -23,14 +23,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilService = void 0;
 const core_1 = require("@rxdi/core");
-const injection_tokens_1 = require("../injection.tokens");
+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");
+const ogm_provider_1 = require("./ogm.provider");
+const graphql_ogm_1 = require("@neo4j/graphql-ogm");
 let UtilService = class UtilService {
-    constructor(config) {
+    constructor(config, ogmProvider) {
         this.config = config;
+        this.ogmProvider = ogmProvider;
     }
     extendSchemaDirectives(augmentedSchema, schema) {
         augmentedSchema['_directives'] = schema['_directives'];
@@ -42,16 +45,34 @@ let UtilService = class UtilService {
             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);
+            yield this.initOgmClient(typeDefs)(driver);
             const neoSchema = new graphql_1.Neo4jGraphQL({
                 typeDefs,
                 driver,
                 assumeValidSDL: true,
             });
-            return this.extendSchemaDirectives(yield neoSchema.getSchema(), schema);
+            const augmentedSchema = yield neoSchema.getSchema();
+            const newSchema = this.extendSchemaDirectives(augmentedSchema, schema);
+            return newSchema;
+        });
+    }
+    initOgmClient(typeDefs) {
+        return (driver) => __awaiter(this, void 0, void 0, function* () {
+            const ogm = new graphql_ogm_1.OGM({
+                assumeValidSDL: true,
+                assumeValid: true,
+                typeDefs,
+                driver
+            });
+            yield ogm.init();
+            this.ogmProvider.client = ogm;
         });
     }
     mergeSchemas(...schemas) {
@@ -59,45 +80,53 @@ let UtilService = class UtilService {
             schemas: schemas.filter(s => !!s)
         }), schemas.filter(s => !!s)[0]);
     }
-    assignDriverToContext() {
+    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.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;
+        return Object.values(this.findSchemaExtensions(schema)).reduce((curr, prev) => {
+            if (prev.extends) {
+                return `${curr}\n${prev.extends}`;
             }
-            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 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 relations;
+                    }
+                    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])
+    __metadata("design:paramtypes", [Object, ogm_provider_1.OGMProvider])
 ], UtilService);
 exports.UtilService = UtilService;

package/dist/ogm.provider.d.ts

@@ -0,0 +1,4 @@
+import { OGM } from '@neo4j/graphql-ogm';
+export declare class OGMProvider<T = OGM> {
+    client: OGM<T>;
+}

package/dist/ogm.provider.js

@@ -0,0 +1,16 @@
+"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.OGMProvider = void 0;
+const core_1 = require("@gapi/core");
+let OGMProvider = class OGMProvider {
+};
+OGMProvider = __decorate([
+    (0, core_1.Injectable)()
+], OGMProvider);
+exports.OGMProvider = OGMProvider;

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "@rxdi/neo4j",
- "version": "0.7.153",
+ "version": "0.7.155",
  "description": "",
  "main": "./dist/index.js",
  "types": "./dist/index.d.ts",
@@ -26,15 +26,16 @@
  },
  "homepage": "https://github.com/rxdi/neo4j/blob/master/README.md",
  "dependencies": {
-  "@neo4j/graphql": "^3.8.0",
+  "@neo4j/graphql": "^3.9.0",
+  "@neo4j/graphql-ogm": "^3.9.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",
+  "@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/services/index.d.ts

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

package/dist/services/index.js

@@ -1,13 +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("./util.service"), exports);