@orion-js/graphql 3.4.9 → 3.4.11

package/lib/buildSchema/getResolvers/resolversStore.d.ts

@@ -1,2 +1,3 @@
-declare const resolversStore: {};
+import { GlobalResolversMap } from '@orion-js/models';
+declare const resolversStore: GlobalResolversMap;
 export { resolversStore };

package/lib/resolversSchemas/ResolverParams.js

@@ -7,6 +7,7 @@ const serializeSchema_1 = __importDefault(require("./serializeSchema"));
 const getBasicResultQuery_1 = __importDefault(require("./getBasicResultQuery"));
 const models_1 = require("@orion-js/models");
 const resolvers_1 = require("@orion-js/resolvers");
+const lodash_1 = require("lodash");
 const resolverReturnsIsModel = (returns) => {
     return returns && returns.__isModel;
 };
@@ -27,14 +28,18 @@ exports.default = (0, models_1.createModel)({
         result: (0, resolvers_1.resolver)({
             returns: String,
             resolve: async function ({ resolver }) {
-                return resolver.returns.name;
+                const returns = (0, lodash_1.isArray)(resolver.returns) ? resolver.returns[0] : resolver.returns;
+                if (resolverReturnsIsModel(returns))
+                    return returns.name;
+                return;
             }
         }),
         basicResultQuery: (0, resolvers_1.resolver)({
             returns: String,
             resolve: async function ({ resolver }) {
+                const returns = (0, lodash_1.isArray)(resolver.returns) ? resolver.returns[0] : resolver.returns;
                 return await (0, getBasicResultQuery_1.default)({
-                    type: resolverReturnsIsModel(resolver.returns) ? resolver.returns.getSchema() : ''
+                    type: resolverReturnsIsModel(returns) ? returns.getSchema() : ''
                 });
             }
         })

package/lib/resolversSchemas/index.d.ts

@@ -1,6 +1,6 @@
 declare const _default: {
     params: import("@orion-js/resolvers").Resolver<({ mutation, name }: any, viewer: any) => Promise<{
-        resolver: any;
+        resolver: import("@orion-js/resolvers").Resolver<import("@orion-js/resolvers").GlobalResolverResolve, undefined>;
         name: any;
     }>, undefined>;
 };

package/lib/resolversSchemas/params.d.ts

@@ -1,5 +1,5 @@
 declare const _default: import("@orion-js/resolvers").Resolver<({ mutation, name }: any, viewer: any) => Promise<{
-    resolver: any;
+    resolver: import("@orion-js/resolvers").Resolver<import("@orion-js/resolvers").GlobalResolverResolve, undefined>;
     name: any;
 }>, undefined>;
 export default _default;

package/lib/resolversSchemas/params.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/resolversSchemas/params.test.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const params_1 = __importDefault(require("./params"));
+const resolversStore_1 = require("../buildSchema/getResolvers/resolversStore");
+const resolvers_1 = require("@orion-js/resolvers");
+const models_1 = require("@orion-js/models");
+describe('Get params tests', () => {
+    it('Should return the correct information for a resolver that returns a string array', async () => {
+        resolversStore_1.resolversStore.aResolver = (0, resolvers_1.resolver)({
+            params: {
+                aParam: {
+                    type: String
+                }
+            },
+            returns: [String],
+            async resolve() {
+                return ['a', 'b'];
+            }
+        });
+        const response = (await params_1.default.execute({
+            params: {
+                name: 'aResolver',
+                mutation: false
+            }
+        }));
+        const params = await response.params();
+        const result = await response.result();
+        const basicResultQuery = await response.basicResultQuery();
+        expect(response.name).toEqual('aResolver');
+        expect(params).toEqual({ aParam: { type: 'string', __graphQLType: 'String' } });
+        expect(result).toEqual(undefined);
+        expect(basicResultQuery).toEqual('');
+    });
+    it('Should return the correct information for a resolver that returns a string', async () => {
+        resolversStore_1.resolversStore.aaResolver = (0, resolvers_1.resolver)({
+            params: {
+                aParam: {
+                    type: String
+                }
+            },
+            returns: [String],
+            async resolve() {
+                return 'a';
+            }
+        });
+        const response = (await params_1.default.execute({
+            params: {
+                name: 'aaResolver',
+                mutation: false
+            }
+        }));
+        const params = await response.params();
+        const result = await response.result();
+        const basicResultQuery = await response.basicResultQuery();
+        expect(response.name).toEqual('aaResolver');
+        expect(params).toEqual({ aParam: { type: 'string', __graphQLType: 'String' } });
+        expect(result).toEqual(undefined);
+        expect(basicResultQuery).toEqual('');
+    });
+    it('Should return the correct information for a resolver that returns a array of a model', async () => {
+        const model = (0, models_1.createModel)({
+            name: 'Item',
+            schema: {
+                name: {
+                    type: String
+                }
+            }
+        });
+        resolversStore_1.resolversStore.bResolver = (0, resolvers_1.resolver)({
+            params: {
+                aParam: {
+                    type: String
+                }
+            },
+            returns: [model],
+            async resolve() {
+                return [{ name: 'Nico' }];
+            }
+        });
+        const response = (await params_1.default.execute({
+            params: {
+                name: 'bResolver',
+                mutation: false
+            }
+        }));
+        const params = await response.params();
+        const result = await response.result();
+        const basicResultQuery = await response.basicResultQuery();
+        expect(response.name).toEqual('bResolver');
+        expect(params).toEqual({ aParam: { type: 'string', __graphQLType: 'String' } });
+        expect(result).toEqual('Item');
+        expect(basicResultQuery).toEqual('{ name }');
+    });
+    it('Should return the correct information for a resolver that returns a model', async () => {
+        const model2 = (0, models_1.createModel)({
+            name: 'Item2',
+            schema: {
+                name: {
+                    type: String
+                }
+            }
+        });
+        resolversStore_1.resolversStore.cResolver = (0, resolvers_1.resolver)({
+            params: {
+                aParam: {
+                    type: String
+                }
+            },
+            returns: model2,
+            async resolve() {
+                return [{ name: 'Nico' }];
+            }
+        });
+        const response = (await params_1.default.execute({
+            params: {
+                name: 'cResolver',
+                mutation: false
+            }
+        }));
+        const params = await response.params();
+        const result = await response.result();
+        const basicResultQuery = await response.basicResultQuery();
+        expect(response.name).toEqual('cResolver');
+        expect(params).toEqual({ aParam: { type: 'string', __graphQLType: 'String' } });
+        expect(result).toEqual('Item2');
+        expect(basicResultQuery).toEqual('{ name }');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/graphql",
-  "version": "3.4.9",
+  "version": "3.4.11",
   "main": "lib/index.js",
   "author": "nicolaslopezj",
   "license": "MIT",
@@ -51,5 +51,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "e9c223e70752b6c613f58e63f8fd9fab471618de"
+  "gitHead": "99aec486f0d9343d9bc2c3bacf430217b0bc7dba"
 }