@orion-js/graphql 3.4.11 → 3.5.0

package/lib/errorHandler.js

@@ -5,10 +5,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const crypto_1 = __importDefault(require("crypto"));
 const helpers_1 = require("@orion-js/helpers");
+const graphql_1 = require("graphql");
 function errorHandler(error, data) {
     const message = `Error in resolver "${data.name}" ${data.model ? `of model "${data.model.name}"` : ''}`;
     if (error && error.isOrionError) {
         console.warn(message, error);
+        throw new graphql_1.GraphQLError(error.message, {
+            originalError: error,
+            extensions: {
+                isOrionError: !!error.isOrionError,
+                isValidationError: !!error.isValidationError,
+                code: error.code,
+                info: error.getInfo()
+            }
+        });
     }
     else {
         const hash = crypto_1.default

package/lib/index.d.ts

@@ -2,7 +2,7 @@ import subscription from './subscription';
 import startGraphQL from './startGraphQL';
 import startGraphiQL from './startGraphiQL';
 import resolversSchemas from './resolversSchemas';
-import ResolverParams from './resolversSchemas/ResolverParams';
+import ResolverParams from './resolversSchemas/ResolverParamsInfo';
 import serializeSchema from './resolversSchemas/serializeSchema';
 import getBasicResultQuery from './resolversSchemas/getBasicResultQuery';
 import * as GraphQL from 'graphql';

package/lib/index.js

@@ -38,8 +38,8 @@ const startGraphiQL_1 = __importDefault(require("./startGraphiQL"));
 exports.startGraphiQL = startGraphiQL_1.default;
 const resolversSchemas_1 = __importDefault(require("./resolversSchemas"));
 exports.resolversSchemas = resolversSchemas_1.default;
-const ResolverParams_1 = __importDefault(require("./resolversSchemas/ResolverParams"));
-exports.ResolverParams = ResolverParams_1.default;
+const ResolverParamsInfo_1 = __importDefault(require("./resolversSchemas/ResolverParamsInfo"));
+exports.ResolverParams = ResolverParamsInfo_1.default;
 const serializeSchema_1 = __importDefault(require("./resolversSchemas/serializeSchema"));
 exports.serializeSchema = serializeSchema_1.default;
 const getBasicResultQuery_1 = __importDefault(require("./resolversSchemas/getBasicResultQuery"));

package/lib/resolversSchemas/params.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const resolvers_1 = require("@orion-js/resolvers");
 const helpers_1 = require("@orion-js/helpers");
-const ResolverParams_1 = __importDefault(require("./ResolverParams"));
+const ResolverParamsInfo_1 = __importDefault(require("./ResolverParamsInfo"));
 const resolversStore_1 = require("../buildSchema/getResolvers/resolversStore");
 exports.default = (0, resolvers_1.resolver)({
     params: {
@@ -16,7 +16,7 @@ exports.default = (0, resolvers_1.resolver)({
             type: Boolean
         }
     },
-    returns: ResolverParams_1.default,
+    returns: ResolverParamsInfo_1.default,
     mutation: false,
     resolve: async function ({ mutation, name }, viewer) {
         const resolver = resolversStore_1.resolversStore[name];

package/lib/service/global.d.ts

@@ -3,8 +3,8 @@ export declare function Resolvers(): ClassDecorator;
 export interface GlobalResolverPropertyDescriptor extends Omit<PropertyDecorator, 'value'> {
     value?: GlobalResolverResolve;
 }
-export declare function Query(options: Omit<ResolverOptions<any>, 'resolve' | 'mutation'>): (target: any, propertyKey: string, descriptor: GlobalResolverPropertyDescriptor) => void;
-export declare function Mutation(options: Omit<ResolverOptions<any>, 'resolve' | 'mutation'>): (target: any, propertyKey: string, descriptor: GlobalResolverPropertyDescriptor) => void;
+export declare function Query(options?: Omit<ResolverOptions<any>, 'resolve' | 'mutation'>): (target: any, propertyKey: string, descriptor: GlobalResolverPropertyDescriptor) => void;
+export declare function Mutation(options?: Omit<ResolverOptions<any>, 'resolve' | 'mutation'>): (target: any, propertyKey: string, descriptor: GlobalResolverPropertyDescriptor) => void;
 export declare function getServiceResolvers(target: any): {
     [key: string]: Resolver<GlobalResolverResolve>;
 };

package/lib/service/global.js

@@ -4,6 +4,7 @@ exports.getServiceResolvers = exports.Mutation = exports.Query = exports.Resolve
 const services_1 = require("@orion-js/services");
 const resolvers_1 = require("@orion-js/resolvers");
 const helpers_1 = require("@orion-js/helpers");
+const otherParams_1 = require("./otherParams");
 function Resolvers() {
     return function (target) {
         (0, services_1.Service)()(target);
@@ -17,6 +18,9 @@ function Query(options) {
             throw new Error(`You must pass resolver function to ${propertyKey}`);
         target.resolvers = target.resolvers || {};
         target.resolvers[propertyKey] = (0, resolvers_1.resolver)({
+            params: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'params'),
+            returns: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'returns'),
+            middlewares: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'middlewares'),
             ...options,
             resolve: async (params, viewer) => {
                 const instance = (0, services_1.getInstance)(target.service);
@@ -32,6 +36,9 @@ function Mutation(options) {
             throw new Error(`You must pass resolver function to ${propertyKey}`);
         target.resolvers = target.resolvers || {};
         target.resolvers[propertyKey] = (0, resolvers_1.resolver)({
+            params: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'params'),
+            returns: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'returns'),
+            middlewares: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'middlewares'),
             ...options,
             mutation: true,
             resolve: async (params, viewer) => {

package/lib/service/index.d.ts

@@ -1,3 +1,4 @@
 export * from './global';
 export * from './model';
 export * from './subscription';
+export * from './otherParams';

package/lib/service/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./global"), exports);
 __exportStar(require("./model"), exports);
 __exportStar(require("./subscription"), exports);
+__exportStar(require("./otherParams"), exports);

package/lib/service/middlewares.test.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

package/lib/service/middlewares.test.js

@@ -0,0 +1,99 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const services_1 = require("@orion-js/services");
+const index_1 = require("./index");
+const otherParams_1 = require("./otherParams");
+const resolvers_1 = require("@orion-js/resolvers");
+const typed_model_1 = require("@orion-js/typed-model");
+describe('Resolvers with service injection and middlewares', () => {
+    it('should allow to pass resolver middlewares with decorators', async () => {
+        expect.assertions(3);
+        let ExampleRepo = class ExampleRepo {
+            getLastName() {
+                return 'Lopez';
+            }
+        };
+        ExampleRepo = __decorate([
+            (0, services_1.Service)()
+        ], ExampleRepo);
+        const exampleMiddleware = (0, resolvers_1.createResolverMiddleware)(async (executeOptions, next) => {
+            const result = await next();
+            expect(result).toBe('intercepted2');
+            return 'intercepted';
+        });
+        const CheckRoles = (rolesToCheck) => {
+            return (0, otherParams_1.UseMiddleware)(async (executeOptions, next) => {
+                // check roles here
+                await next();
+                return 'intercepted2';
+            });
+        };
+        let ExampleResolverService = class ExampleResolverService {
+            async sayHi(params) {
+                return 'text';
+            }
+        };
+        __decorate([
+            (0, index_1.Query)(),
+            (0, otherParams_1.ResolverParams)({ name: { type: 'string' } }),
+            (0, otherParams_1.ResolverReturns)(String),
+            (0, otherParams_1.UseMiddleware)(exampleMiddleware),
+            CheckRoles(['admin']),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", Promise)
+        ], ExampleResolverService.prototype, "sayHi", null);
+        ExampleResolverService = __decorate([
+            (0, index_1.Resolvers)()
+        ], ExampleResolverService);
+        const resolvers = (0, index_1.getServiceResolvers)(ExampleResolverService);
+        expect(resolvers.sayHi).toBeDefined();
+        const result = await resolvers.sayHi.execute({ params: { name: 'Orion' } });
+        expect(result).toBe(`intercepted`);
+    });
+    it('show also work with model resolvers', async () => {
+        let Person = class Person {
+        };
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", String)
+        ], Person.prototype, "name", void 0);
+        Person = __decorate([
+            (0, typed_model_1.TypedSchema)()
+        ], Person);
+        const NiceToMeetYou = (0, otherParams_1.UseMiddleware)(async (executeOptions, next) => {
+            const result = await next();
+            return `${result}, nice to meet you`;
+        });
+        let PersonResolvers = class PersonResolvers {
+            async getAge(person) {
+                return `hello ${person.name}`;
+            }
+        };
+        __decorate([
+            (0, index_1.ModelResolver)(),
+            (0, otherParams_1.ResolverReturns)(String),
+            NiceToMeetYou,
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Person]),
+            __metadata("design:returntype", Promise)
+        ], PersonResolvers.prototype, "getAge", null);
+        PersonResolvers = __decorate([
+            (0, index_1.ModelResolvers)(Person)
+        ], PersonResolvers);
+        const data = (0, index_1.getServiceModelResolvers)(PersonResolvers);
+        const item = { name: 'Orion' };
+        const result = await data.Person.getAge.execute({ parent: item });
+        expect(result).toBe(`hello Orion, nice to meet you`);
+    });
+});

package/lib/service/model.d.ts

@@ -2,7 +2,7 @@ import { GlobalResolverResolve, ResolverOptions, ModelResolverResolve, ModelReso
 export interface ModelResolverPropertyDescriptor extends Omit<PropertyDecorator, 'value'> {
     value?: ModelResolverResolve;
 }
-export declare function ModelResolver(options: Omit<ResolverOptions<any>, 'resolve'>): (target: any, propertyKey: string, descriptor: ModelResolverPropertyDescriptor) => void;
+export declare function ModelResolver(options?: Omit<ResolverOptions<any>, 'resolve' | 'middlewares'>): (target: any, propertyKey: string, descriptor: ModelResolverPropertyDescriptor) => void;
 export interface ModelResolversOptions {
     modelName?: string;
 }

package/lib/service/model.js

@@ -4,12 +4,16 @@ exports.getServiceModelResolvers = exports.ModelResolvers = exports.ModelResolve
 const services_1 = require("@orion-js/services");
 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) {
         if (!descriptor.value)
             throw new Error(`You must pass resolver function to ${propertyKey}`);
         target.resolvers = target.resolvers || {};
         target.resolvers[propertyKey] = (0, resolvers_1.modelResolver)({
+            params: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'params'),
+            returns: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'returns'),
+            middlewares: (0, otherParams_1.getTargetMetadata)(target, propertyKey, 'middlewares'),
             ...options,
             resolve: async (item, params, viewer) => {
                 const instance = (0, services_1.getInstance)(target.service);

package/lib/service/otherParams.d.ts

@@ -0,0 +1,7 @@
+import { ResolverMiddleware } from '@orion-js/resolvers';
+import { GlobalResolverPropertyDescriptor } from './global';
+import { ModelResolverPropertyDescriptor } from './model';
+export declare function getTargetMetadata(target: any, propertyKey: string, metadataKey: string): any;
+export declare const UseMiddleware: (metadata: ResolverMiddleware) => (target: any, propertyKey: string, descriptor: GlobalResolverPropertyDescriptor | ModelResolverPropertyDescriptor) => void;
+export declare const ResolverParams: (metadata: any) => (target: any, propertyKey: string, descriptor: GlobalResolverPropertyDescriptor | ModelResolverPropertyDescriptor) => void;
+export declare const ResolverReturns: (metadata: any) => (target: any, propertyKey: string, descriptor: GlobalResolverPropertyDescriptor | ModelResolverPropertyDescriptor) => void;

package/lib/service/otherParams.js

@@ -0,0 +1,28 @@
+"use strict";
+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) {
+            if (!descriptor.value)
+                throw new Error(`You must pass resolver function to ${propertyKey}`);
+            target[metadataKey] = target[metadataKey] || {};
+            if (isArray) {
+                target[metadataKey][propertyKey] = target[metadataKey][propertyKey] || [];
+                // push at the start of the array
+                target[metadataKey][propertyKey].unshift(metadata);
+            }
+            else {
+                target[metadataKey][propertyKey] = metadata;
+            }
+        };
+    };
+}
+function getTargetMetadata(target, propertyKey, metadataKey) {
+    const items = target[metadataKey] || {};
+    return items[propertyKey] || [];
+}
+exports.getTargetMetadata = getTargetMetadata;
+exports.UseMiddleware = createRegisterResolverMetadata('middlewares', true);
+exports.ResolverParams = createRegisterResolverMetadata('params');
+exports.ResolverReturns = createRegisterResolverMetadata('returns');

package/lib/startGraphQL.test.js

@@ -19,6 +19,7 @@ const supertest_1 = __importDefault(require("supertest"));
 const typed_model_1 = require("@orion-js/typed-model");
 const cleanResolvers_1 = require("./cleanResolvers");
 const models_1 = require("@orion-js/models");
+const helpers_1 = require("@orion-js/helpers");
 describe('Test GraphQL Server', () => {
     beforeEach(() => {
         (0, cleanResolvers_1.cleanResolvers)();
@@ -108,6 +109,129 @@ describe('Test GraphQL Server', () => {
         expect(response.statusCode).toBe(400);
         expect(response.body.errors[0].message).toEqual('Cannot query field "helloWorld_doesntExists" on type "Query".');
     });
+    it('should return validation errors correctly', async () => {
+        const resolvers = {
+            helloWorld: (0, resolvers_1.resolver)({
+                params: {
+                    name: {
+                        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
+        });
+        const response = await (0, supertest_1.default)(app)
+            .post('/graphql')
+            .send({
+            operationName: 'testOperation',
+            variables: {
+                name: 'Nico'
+            },
+            query: `query testOperation($name: String) {
+          helloWorld(name: $name)
+      }`
+        });
+        expect(response.statusCode).toBe(200);
+        expect(response.body).toEqual({
+            errors: [
+                {
+                    message: 'Validation Error: {name: notUnique}',
+                    locations: [
+                        {
+                            line: 2,
+                            column: 11
+                        }
+                    ],
+                    path: ['helloWorld'],
+                    extensions: {
+                        isOrionError: true,
+                        isValidationError: true,
+                        code: 'validationError',
+                        info: {
+                            error: 'validationError',
+                            message: 'Validation Error',
+                            validationErrors: {
+                                name: 'notUnique'
+                            }
+                        }
+                    }
+                }
+            ],
+            data: {
+                helloWorld: null
+            }
+        });
+    });
+    it('should return user errors correctly', async () => {
+        const resolvers = {
+            helloWorld: (0, resolvers_1.resolver)({
+                params: {
+                    name: {
+                        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
+        });
+        const response = await (0, supertest_1.default)(app)
+            .post('/graphql')
+            .send({
+            operationName: 'testOperation',
+            variables: {
+                name: 'Nico'
+            },
+            query: `query testOperation($name: String) {
+          helloWorld(name: $name)
+      }`
+        });
+        expect(response.statusCode).toBe(200);
+        expect(response.body).toEqual({
+            errors: [
+                {
+                    message: 'message',
+                    locations: [
+                        {
+                            line: 2,
+                            column: 11
+                        }
+                    ],
+                    path: ['helloWorld'],
+                    extensions: {
+                        isOrionError: true,
+                        isValidationError: false,
+                        code: 'code',
+                        info: {
+                            error: 'code',
+                            message: 'message'
+                        }
+                    }
+                }
+            ],
+            data: {
+                helloWorld: null
+            }
+        });
+    });
     it('Should make requests to schemas with typed models', async () => {
         let Params = class Params {
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/graphql",
-  "version": "3.4.11",
+  "version": "3.5.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.4.1",
-    "@orion-js/helpers": "^3.4.1",
-    "@orion-js/http": "^3.4.9",
-    "@orion-js/models": "^3.4.9",
-    "@orion-js/resolvers": "^3.4.9",
-    "@orion-js/schema": "^3.4.9",
-    "@orion-js/services": "^3.4.1",
-    "@orion-js/typed-model": "^3.4.9",
+    "@orion-js/env": "^3.5.0",
+    "@orion-js/helpers": "^3.5.0",
+    "@orion-js/http": "^3.5.0",
+    "@orion-js/models": "^3.5.0",
+    "@orion-js/resolvers": "^3.5.0",
+    "@orion-js/schema": "^3.5.0",
+    "@orion-js/services": "^3.5.0",
+    "@orion-js/typed-model": "^3.5.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": "99aec486f0d9343d9bc2c3bacf430217b0bc7dba"
+  "gitHead": "6fc8b0e40fad04d7ff84cf0849cbf260a66b6641"
 }