@orion-js/graphql 3.9.0 → 3.10.0

package/lib/buildSchema/getResolvers/index.js

@@ -13,7 +13,7 @@ async function default_1(options, mutation) {
         .map(key => {
         return {
             name: key,
-            resolver: resolvers[key]
+            resolver: resolvers[key],
         };
     })
         .filter(({ resolver }) => !!resolver.mutation === !!mutation)
@@ -26,16 +26,16 @@ async function default_1(options, mutation) {
         fields[name] = {
             type,
             args,
-            async resolve(root, params, context) {
+            async resolve(root, params, context, info) {
                 try {
-                    const result = await resolver.resolve(params, context);
+                    const result = await resolver.resolve(params, context, info);
                     return result;
                 }
                 catch (error) {
                     (0, errorHandler_1.default)(error, { context, resolver, options, name });
                     throw error;
                 }
-            }
+            },
         };
     }
     return fields;

package/lib/buildSchema/getResolvers/index.test.js

@@ -46,9 +46,9 @@ describe('Test get resolvers schema', () => {
                 return {
                     userId: params.userId,
                     name: 'test',
-                    age: 10
+                    age: 10,
                 };
-            }
+            },
         });
         const resolvers = { globalResolver };
         const mutation = false;
@@ -59,7 +59,7 @@ describe('Test get resolvers schema', () => {
         expect(await schema.globalResolver.resolve(null, { userId: '1' })).toEqual({
             userId: '1',
             name: 'test',
-            age: 10
+            age: 10,
         });
     });
 });

package/lib/buildSchema/getType/enum.test.js

@@ -34,7 +34,7 @@ describe('Enum test', () => {
             returns: colorsEnum,
             async resolve(params) {
                 return params.color;
-            }
+            },
         });
         const resolvers = { globalResolver };
         const mutation = false;
@@ -62,7 +62,7 @@ describe('Enum test', () => {
             returns: Clone1,
             async resolve(params) {
                 return params;
-            }
+            },
         });
         const Clone2 = (0, typed_model_1.cloneSchemaClass)(TestParams, { name: 'TestParams3', pickFields: ['color'] });
         const Clone3 = (0, typed_model_1.cloneSchemaClass)(TestParams, { name: 'TestParams4', pickFields: ['color'] });
@@ -71,7 +71,7 @@ describe('Enum test', () => {
             returns: Clone3,
             async resolve(params) {
                 return params;
-            }
+            },
         });
         const resolvers = { globalResolver, globalResolver2 };
         const options = { resolvers };

package/lib/buildSchema/getType/getTypeAsResolver.d.ts

@@ -6,5 +6,5 @@ export default function ({ resolver, getGraphQLType, options, model }: {
 }): {
     type: any;
     args: {};
-    resolve(item: any, params: any, context: any): Promise<any>;
+    resolve(item: any, params: any, context: any, info: any): Promise<any>;
 };

package/lib/buildSchema/getType/getTypeAsResolver.js

@@ -11,16 +11,16 @@ function default_1({ resolver, getGraphQLType, options, model }) {
     return {
         type,
         args,
-        async resolve(item, params, context) {
+        async resolve(item, params, context, info) {
             try {
-                const result = await resolver.resolve(item, params, context);
+                const result = await resolver.resolve(item, params, context, info);
                 return result;
             }
             catch (error) {
                 (0, errorHandler_1.default)(error, { context, resolver, options, model });
                 throw error;
             }
-        }
+        },
     };
 }
 exports.default = default_1;

package/lib/service/global.js

@@ -6,14 +6,14 @@ const resolvers_1 = require("@orion-js/resolvers");
 const helpers_1 = require("@orion-js/helpers");
 const otherParams_1 = require("./otherParams");
 function Resolvers() {
-    return function (target) {
+    return (target) => {
         (0, services_1.Service)()(target);
         target.prototype.service = target;
     };
 }
 exports.Resolvers = Resolvers;
 function Query(options) {
-    return function (target, propertyKey, descriptor) {
+    return (target, propertyKey, descriptor) => {
         if (!descriptor.value)
             throw new Error(`You must pass resolver function to ${propertyKey}`);
         target.resolvers = target.resolvers || {};
@@ -23,16 +23,16 @@ function Query(options) {
             returns: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'returns'),
             middlewares: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'middlewares'),
             ...options,
-            resolve: async (params, viewer) => {
+            resolve: async (params, viewer, info) => {
                 const instance = (0, services_1.getInstance)(target.service);
-                return await instance[propertyKey](params, viewer);
-            }
+                return await instance[propertyKey](params, viewer, info);
+            },
         });
     };
 }
 exports.Query = Query;
 function Mutation(options) {
-    return function (target, propertyKey, descriptor) {
+    return (target, propertyKey, descriptor) => {
         if (!descriptor.value)
             throw new Error(`You must pass resolver function to ${propertyKey}`);
         target.resolvers = target.resolvers || {};
@@ -43,10 +43,10 @@ function Mutation(options) {
             middlewares: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'middlewares'),
             ...options,
             mutation: true,
-            resolve: async (params, viewer) => {
+            resolve: async (params, viewer, info) => {
                 const instance = (0, services_1.getInstance)(target.service);
-                return await instance[propertyKey](params, viewer);
-            }
+                return await instance[propertyKey](params, viewer, info);
+            },
         });
     };
 }

package/lib/service/index.test.js

@@ -40,7 +40,7 @@ describe('Resolvers with service injection', () => {
         __decorate([
             (0, index_1.Query)({
                 params: { name: { type: 'string' } },
-                returns: String
+                returns: String,
             }),
             __metadata("design:type", Function),
             __metadata("design:paramtypes", [Object]),

package/lib/service/model.d.ts

@@ -1,4 +1,4 @@
-import { GlobalResolverResolve, ResolverOptions, ModelResolverResolve, ModelResolver } from '@orion-js/resolvers';
+import { GlobalResolverResolve, ResolverOptions, ModelResolverResolve, ModelResolver as ModelResolverType } from '@orion-js/resolvers';
 export interface ModelResolverPropertyDescriptor extends Omit<PropertyDecorator, 'value'> {
     value?: ModelResolverResolve;
 }
@@ -9,6 +9,6 @@ export interface ModelResolversOptions {
 export declare function ModelResolvers(typedSchema: any, options?: ModelResolversOptions): ClassDecorator;
 export declare function getServiceModelResolvers(target: any): {
     [key: string]: {
-        [key: string]: ModelResolver<GlobalResolverResolve>;
+        [key: string]: ModelResolverType<GlobalResolverResolve>;
     };
 };

package/lib/service/model.js

@@ -6,7 +6,7 @@ const resolvers_1 = require("@orion-js/resolvers");
 const helpers_1 = require("@orion-js/helpers");
 const otherParams_1 = require("./otherParams");
 function ModelResolver(options) {
-    return function (target, propertyKey, descriptor) {
+    return (target, propertyKey, descriptor) => {
         if (!descriptor.value)
             throw new Error(`You must pass resolver function to ${propertyKey}`);
         target.resolvers = target.resolvers || {};
@@ -15,20 +15,20 @@ function ModelResolver(options) {
             returns: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'returns'),
             middlewares: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'middlewares'),
             ...options,
-            resolve: async (item, params, viewer) => {
+            resolve: async (item, params, viewer, info) => {
                 const instance = (0, services_1.getInstance)(target.service);
-                return await instance[propertyKey](item, params, viewer);
-            }
+                return await instance[propertyKey](item, params, viewer, info);
+            },
         });
     };
 }
 exports.ModelResolver = ModelResolver;
 function ModelResolvers(typedSchema, options = {}) {
-    return function (target) {
+    return (target) => {
         (0, services_1.Service)()(target);
         target.prototype.modelName = options.modelName || typedSchema.name;
         if (!target.prototype.modelName) {
-            throw new Error(`The specified model has no name or is not a model`);
+            throw new Error('The specified model has no name or is not a model');
         }
         target.prototype.typedSchema = typedSchema;
         target.prototype.service = target;
@@ -42,7 +42,7 @@ function getServiceModelResolvers(target) {
         throw new helpers_1.UserError('You must pass a class to getResolvers');
     }
     return {
-        [target.prototype.modelName]: target.prototype.resolvers || {}
+        [target.prototype.modelName]: target.prototype.resolvers || {},
     };
 }
 exports.getServiceModelResolvers = getServiceModelResolvers;

package/lib/service/otherParams.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResolverReturns = exports.ResolverParams = exports.UseMiddleware = exports.getTargetMetadata = void 0;
 function createRegisterResolverMetadata(metadataKey, isArray = false) {
     return (metadata) => {
-        return function (target, propertyKey, descriptor) {
+        return (target, propertyKey, descriptor) => {
             if (!descriptor.value)
                 throw new Error(`You must pass resolver function to ${propertyKey}`);
             target[metadataKey] = target[metadataKey] || {};

package/lib/service/subscription.js

@@ -5,7 +5,7 @@ const services_1 = require("@orion-js/services");
 const helpers_1 = require("@orion-js/helpers");
 const __1 = require("..");
 function Subscriptions() {
-    return function (target) {
+    return (target) => {
         (0, services_1.Service)()(target);
         target.prototype.service = target;
         target.prototype.serviceType = 'subscriptions';
@@ -13,10 +13,10 @@ function Subscriptions() {
 }
 exports.Subscriptions = Subscriptions;
 function Subscription(options) {
-    return function (object, propertyName, index) {
+    return (object, propertyName, index) => {
         const sub = (0, __1.subscription)({
             name: propertyName,
-            ...options
+            ...options,
         });
         object.subscriptions = object.subscriptions || {};
         object.subscriptions[propertyName] = sub;
@@ -24,12 +24,12 @@ function Subscription(options) {
             object,
             propertyName,
             index,
-            value: containerInstance => {
+            value: _containerInstance => {
                 if (!object.serviceType || object.serviceType !== 'subscriptions') {
                     throw new Error('You must pass a class decorated with @Subscriptions if you want to use @Subscription');
                 }
                 return sub;
-            }
+            },
         });
     };
 }

package/lib/startGraphQL.test.js

@@ -29,19 +29,19 @@ describe('Test GraphQL Server', () => {
             helloWorld: (0, resolvers_1.resolver)({
                 params: {
                     name: {
-                        type: 'string'
-                    }
+                        type: 'string',
+                    },
                 },
                 returns: 'string',
                 async resolve({ name }) {
                     return `Hello ${name}`;
-                }
-            })
+                },
+            }),
         };
         const app = (0, http_1.express)();
         await (0, _1.startGraphQL)({
             resolvers,
-            app
+            app,
         });
     });
     it('should startGraphQL and make a request', async () => {
@@ -49,30 +49,30 @@ describe('Test GraphQL Server', () => {
             helloWorld: (0, resolvers_1.resolver)({
                 params: {
                     name: {
-                        type: 'string'
-                    }
+                        type: 'string',
+                    },
                 },
                 returns: 'string',
                 async resolve({ name }) {
                     return `Hello ${name}`;
-                }
-            })
+                },
+            }),
         };
         const app = (0, http_1.express)();
         await (0, _1.startGraphQL)({
             resolvers,
-            app
+            app,
         });
         const response = await (0, supertest_1.default)(app)
             .post('/graphql')
             .send({
             operationName: 'testOperation',
             variables: {
-                name: 'Nico'
+                name: 'Nico',
             },
             query: `query testOperation($name: String) {
         helloWorld(name: $name)
-      }`
+      }`,
         });
         expect(response.body.data).toEqual({ helloWorld: 'Hello Nico' });
     });
@@ -81,30 +81,30 @@ describe('Test GraphQL Server', () => {
             helloWorld: (0, resolvers_1.resolver)({
                 params: {
                     name: {
-                        type: 'string'
-                    }
+                        type: 'string',
+                    },
                 },
                 returns: 'string',
                 async resolve({ name }) {
                     return `Hello ${name}`;
-                }
-            })
+                },
+            }),
         };
         const app = (0, http_1.express)();
         await (0, _1.startGraphQL)({
             resolvers,
-            app
+            app,
         });
         const response = await (0, supertest_1.default)(app)
             .post('/graphql')
             .send({
             operationName: 'testOperation',
             variables: {
-                name: 'Nico'
+                name: 'Nico',
             },
             query: `query testOperation($name: String) {
         helloWorld_doesntExists(name: $name)
-      }`
+      }`,
         });
         expect(response.statusCode).toBe(400);
         expect(response.body.errors[0].message).toEqual('Cannot query field "helloWorld_doesntExists" on type "Query".');
@@ -117,30 +117,30 @@ describe('Test GraphQL Server', () => {
                         type: 'string',
                         validate: () => {
                             return 'notUnique';
-                        }
-                    }
+                        },
+                    },
                 },
                 returns: 'string',
                 async resolve({ name }) {
                     return `Hello ${name}`;
-                }
-            })
+                },
+            }),
         };
         const app = (0, http_1.express)();
         await (0, _1.startGraphQL)({
             resolvers,
-            app
+            app,
         });
         const response = await (0, supertest_1.default)(app)
             .post('/graphql')
             .send({
             operationName: 'testOperation',
             variables: {
-                name: 'Nico'
+                name: 'Nico',
             },
             query: `query testOperation($name: String) {
           helloWorld(name: $name)
-      }`
+      }`,
         });
         expect(response.statusCode).toBe(200);
         expect(response.body).toEqual({
@@ -150,8 +150,8 @@ describe('Test GraphQL Server', () => {
                     locations: [
                         {
                             line: 2,
-                            column: 11
-                        }
+                            column: 11,
+                        },
                     ],
                     path: ['helloWorld'],
                     extensions: {
@@ -163,15 +163,15 @@ describe('Test GraphQL Server', () => {
                             error: 'validationError',
                             message: 'Validation Error',
                             validationErrors: {
-                                name: 'notUnique'
-                            }
-                        }
-                    }
-                }
+                                name: 'notUnique',
+                            },
+                        },
+                    },
+                },
             ],
             data: {
-                helloWorld: null
-            }
+                helloWorld: null,
+            },
         });
     });
     it('should return user errors correctly', async () => {
@@ -179,31 +179,31 @@ describe('Test GraphQL Server', () => {
             helloWorld: (0, resolvers_1.resolver)({
                 params: {
                     name: {
-                        type: 'string'
-                    }
+                        type: 'string',
+                    },
                 },
                 returns: 'string',
                 async resolve({ name }) {
                     throw new helpers_1.UserError('code', 'message');
                     return `Hello ${name}`;
-                }
-            })
+                },
+            }),
         };
         const app = (0, http_1.express)();
         await (0, _1.startGraphQL)({
             resolvers,
-            app
+            app,
         });
         const response = await (0, supertest_1.default)(app)
             .post('/graphql')
             .send({
             operationName: 'testOperation',
             variables: {
-                name: 'Nico'
+                name: 'Nico',
             },
             query: `query testOperation($name: String) {
           helloWorld(name: $name)
-      }`
+      }`,
         });
         expect(response.statusCode).toBe(200);
         expect(response.body).toEqual({
@@ -213,8 +213,8 @@ describe('Test GraphQL Server', () => {
                     locations: [
                         {
                             line: 2,
-                            column: 11
-                        }
+                            column: 11,
+                        },
                     ],
                     path: ['helloWorld'],
                     extensions: {
@@ -224,14 +224,14 @@ describe('Test GraphQL Server', () => {
                         hash: '6f9b9af3cd',
                         info: {
                             error: 'code',
-                            message: 'message'
-                        }
-                    }
-                }
+                            message: 'message',
+                        },
+                    },
+                },
             ],
             data: {
-                helloWorld: null
-            }
+                helloWorld: null,
+            },
         });
     });
     it('should return server errors correctly', async () => {
@@ -239,31 +239,31 @@ describe('Test GraphQL Server', () => {
             helloWorld: (0, resolvers_1.resolver)({
                 params: {
                     name: {
-                        type: 'string'
-                    }
+                        type: 'string',
+                    },
                 },
                 returns: 'string',
                 async resolve({ name }) {
                     throw new Error('message');
                     return `Hello ${name}`;
-                }
-            })
+                },
+            }),
         };
         const app = (0, http_1.express)();
         await (0, _1.startGraphQL)({
             resolvers,
-            app
+            app,
         });
         const response = await (0, supertest_1.default)(app)
             .post('/graphql')
             .send({
             operationName: 'testOperation',
             variables: {
-                name: 'Nico'
+                name: 'Nico',
             },
             query: `query testOperation($name: String) {
           helloWorld(name: $name)
-      }`
+      }`,
         });
         expect(response.statusCode).toBe(200);
         const hash = '6f9b9af3cd';
@@ -274,21 +274,21 @@ describe('Test GraphQL Server', () => {
                     locations: [
                         {
                             line: 2,
-                            column: 11
-                        }
+                            column: 11,
+                        },
                     ],
                     path: ['helloWorld'],
                     extensions: {
                         isOrionError: false,
                         isValidationError: false,
                         code: 'INTERNAL_SERVER_ERROR',
-                        hash: hash
-                    }
-                }
+                        hash: hash,
+                    },
+                },
             ],
             data: {
-                helloWorld: null
-            }
+                helloWorld: null,
+            },
         });
     });
     it('Should make requests to schemas with typed models', async () => {
@@ -319,51 +319,96 @@ describe('Test GraphQL Server', () => {
                 return null;
             return {
                 name: 'Nico',
-                age: 20
+                age: 20,
             };
         };
         const user = (0, resolvers_1.resolver)({
             params: Params,
             returns: User,
-            resolve
+            resolve,
         });
         const model = (0, models_1.createModel)({
             name: 'Model',
             schema: {
-                user: { type: User }
-            }
+                user: { type: User },
+            },
         });
         const modelMutation = (0, resolvers_1.resolver)({
             params: Params,
             returns: [model],
             mutation: true,
-            resolve
+            resolve,
         });
         const resolvers = { user, modelMutation };
         const app = (0, http_1.express)();
         await (0, _1.startGraphQL)({
             resolvers,
-            app
+            app,
         });
         const response = await (0, supertest_1.default)(app)
             .post('/graphql')
             .send({
             variables: {
-                userId: '1'
+                userId: '1',
             },
             query: `query ($userId: String) {
         user(userId: $userId) {
           name
           age
         }
-      }`
+      }`,
         });
         expect(response.statusCode).toBe(200);
         expect(response.body.data).toEqual({
             user: {
                 name: 'Nico',
-                age: 20
-            }
+                age: 20,
+            },
+        });
+    });
+    it('Should pass graphql request info in fourth param', async () => {
+        let User = class User {
+        };
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", String)
+        ], User.prototype, "name", void 0);
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", Number)
+        ], User.prototype, "age", void 0);
+        User = __decorate([
+            (0, typed_model_1.TypedSchema)()
+        ], User);
+        let resolveInfo;
+        const user = (0, resolvers_1.resolver)({
+            params: {},
+            returns: User,
+            async resolve(_params, _viewer, info) {
+                resolveInfo = info;
+                return {
+                    name: 'Nico',
+                    age: 20,
+                };
+            },
         });
+        const resolvers = { user };
+        const app = (0, http_1.express)();
+        await (0, _1.startGraphQL)({
+            resolvers,
+            app,
+        });
+        const response = await (0, supertest_1.default)(app)
+            .post('/graphql')
+            .send({
+            query: `query {
+        user {
+          name
+          age
+        }
+      }`,
+        });
+        expect(response.statusCode).toBe(200);
+        expect(resolveInfo.fieldName).toEqual('user');
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/graphql",
-  "version": "3.9.0",
+  "version": "3.10.0",
   "main": "lib/index.js",
   "author": "nicolaslopezj",
   "license": "MIT",
@@ -15,14 +15,14 @@
   "dependencies": {
     "@apollo/server": "^4.3.0",
     "@graphql-tools/schema": "^9.0.12",
-    "@orion-js/env": "^3.9.0",
-    "@orion-js/helpers": "^3.9.0",
-    "@orion-js/http": "^3.9.0",
-    "@orion-js/models": "^3.9.0",
-    "@orion-js/resolvers": "^3.9.0",
-    "@orion-js/schema": "^3.9.0",
-    "@orion-js/services": "^3.9.0",
-    "@orion-js/typed-model": "^3.9.0",
+    "@orion-js/env": "^3.10.0",
+    "@orion-js/helpers": "^3.10.0",
+    "@orion-js/http": "^3.10.0",
+    "@orion-js/models": "^3.10.0",
+    "@orion-js/resolvers": "^3.10.0",
+    "@orion-js/schema": "^3.10.0",
+    "@orion-js/services": "^3.10.0",
+    "@orion-js/typed-model": "^3.10.0",
     "graphql-iso-date": "^3.6.1",
     "graphql-subscriptions": "2.0.0",
     "graphql-ws": "^5.11.2",
@@ -51,5 +51,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "23e0eda5348153dcc07b307a97b641d52eb41f39"
+  "gitHead": "68036a0293066cc23feb3000ab44e58600540615"
 }