@orion-js/resolvers 3.9.0 → 3.11.6-alpha.0

package/lib/resolver/getArgs.d.ts

@@ -2,8 +2,10 @@ export declare const getArgs: (...args: any[]) => {
     parent: any;
     params: any;
     viewer: any;
+    info: any;
 } | {
     params: any;
     viewer: any;
+    info: any;
     parent?: undefined;
 };

package/lib/resolver/getArgs.js

@@ -2,21 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getArgs = void 0;
 const getArgs = function getArgs(...args) {
-    if (args.length === 3) {
+    if (args.length === 4) {
         return {
             parent: args[0],
             params: args[1] || {},
-            viewer: args[2] || {}
+            viewer: args[2] || {},
+            info: args[3] || {},
         };
     }
-    else if (args.length < 3) {
+    if (args.length < 4) {
         return {
             params: args[0] || {},
-            viewer: args[1] || {}
+            viewer: args[1] || {},
+            info: args[2] || {},
         };
     }
-    else {
-        throw new Error('A resolver must be called with 2 parameters only');
-    }
+    throw new Error('A resolver must be called with 2 parameters only');
 };
 exports.getArgs = getArgs;

package/lib/resolver/getExecute/checkPermissions.js

@@ -3,25 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const permisionsCheckers_1 = require("../permisionsCheckers");
 const helpers_1 = require("@orion-js/helpers");
 async function default_1(executeOptions, options) {
-    const { parent, params, viewer } = executeOptions;
+    const { parent, params, viewer, info } = executeOptions;
     if (viewer.app)
         return;
     await (0, permisionsCheckers_1.checkPermissions)({
         resolver: options,
         parent,
         params,
-        viewer
+        viewer,
+        info,
     });
     if (options.checkPermission) {
         const execute = async () => {
             if (parent) {
                 const checker = options.checkPermission;
-                return checker(parent, params, viewer);
-            }
-            else {
-                const checker = options.checkPermission;
-                return checker(params, viewer);
+                return checker(parent, params, viewer, info);
             }
+            const checker = options.checkPermission;
+            return checker(params, viewer, info);
         };
         const error = await execute();
         if (error) {

package/lib/resolver/getExecute/getCacheKey.js

@@ -2,25 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const helpers_1 = require("@orion-js/helpers");
 const getBaseKey = async (executeOptions) => {
-    const { parent, params, viewer, options } = executeOptions;
+    const { parent, params, viewer, info, options } = executeOptions;
     if (parent) {
         const getKey = options.getCacheKey;
-        return await getKey(parent, params, viewer);
-    }
-    else {
-        const getKey = options.getCacheKey;
-        return await getKey(params, viewer);
+        return await getKey(parent, params, viewer, info);
     }
+    const getKey = options.getCacheKey;
+    return await getKey(params, viewer, info);
 };
 async function default_1(executeOptions) {
-    const { parent, params, viewer, options } = executeOptions;
+    const { parent, params, options } = executeOptions;
     if (options.getCacheKey) {
         const baseKey = await getBaseKey(executeOptions);
-        return options.resolverId + '_' + baseKey;
-    }
-    else {
-        const key = (0, helpers_1.hashObject)({ parent, params, resolverId: options.resolverId });
-        return key;
+        return `${options.resolverId}_${baseKey}`;
     }
+    const key = (0, helpers_1.hashObject)({ parent, params, resolverId: options.resolverId });
+    return key;
 }
 exports.default = default_1;

package/lib/resolver/getExecute/getResult.js

@@ -5,26 +5,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const getCacheKey_1 = __importDefault(require("./getCacheKey"));
 async function default_1(executeOptions) {
-    const { parent, params, viewer, options } = executeOptions;
+    const { parent, params, viewer, info, options } = executeOptions;
     const executeResolver = async () => {
         const resultFunc = options.resolve;
         if (parent) {
-            return await resultFunc(parent, params, viewer);
-        }
-        else {
-            return await resultFunc(params, viewer);
+            return await resultFunc(parent, params, viewer, info);
         }
+        return await resultFunc(params, viewer, info);
     };
     if (options.cache && options.cacheProvider) {
         const key = await (0, getCacheKey_1.default)(executeOptions);
         const result = await options.cacheProvider.get(key, {
             fallback: executeResolver,
-            ttl: options.cache
+            ttl: options.cache,
         });
         return result.value;
     }
-    else {
-        return await executeResolver();
-    }
+    return await executeResolver();
 }
 exports.default = default_1;

package/lib/resolver/getExecute/getResult.test.js

@@ -8,16 +8,19 @@ const helpers_1 = require("@orion-js/helpers");
 const getResult_1 = __importDefault(require("./getResult"));
 const cacheProvider = cache_1.defaultCache;
 it('should execute the function', async () => {
-    const resolve = async function ({ num }) {
-        return num * 2;
-    };
+    const resolve = async ({ num }) => num * 2;
     const params = { num: 321 };
-    const result = await (0, getResult_1.default)({ options: { resolve }, params, viewer: {} });
+    const result = await (0, getResult_1.default)({
+        options: { resolve },
+        params,
+        viewer: {},
+        info: undefined,
+    });
     expect(result).toBe(321 * 2);
 });
 it('should use the cache if passed', async () => {
     let index = 1;
-    const resolve = async function () {
+    const resolve = async () => {
         index++;
         return index;
     };
@@ -27,7 +30,7 @@ it('should use the cache if passed', async () => {
         resolve,
         cacheProvider,
         cache,
-        resolverId
+        resolverId,
     };
     const emptyCall = { options: resolver, params: {}, viewer: {} };
     const result1 = await (0, getResult_1.default)(emptyCall);
@@ -39,15 +42,13 @@ it('should use the cache if passed', async () => {
     expect(result3).toBe(3);
 });
 it('should use the custom cache Provider', async () => {
-    const resolve = async function () {
-        return 1;
-    };
+    const resolve = async () => 1;
     const provider = {
         async get() {
             return { value: 'fromcache' };
         },
         async set() { },
-        async invalidate() { }
+        async invalidate() { },
     };
     const cache = 10;
     const resolverId = '1234';

package/lib/resolver/getExecute/getResultWithMiddlewares.js

@@ -8,12 +8,12 @@ const helpers_1 = require("@orion-js/helpers");
 const createResolverMiddleware_1 = require("../../createResolverMiddleware");
 const getResult_1 = __importDefault(require("./getResult"));
 async function getResultWithMiddlewares(executeOptions) {
-    const resolveMiddleware = (0, createResolverMiddleware_1.createResolverMiddleware)(async (executeOptions, next) => {
+    const resolveMiddleware = (0, createResolverMiddleware_1.createResolverMiddleware)(async (executeOptions) => {
         return await (0, getResult_1.default)(executeOptions);
     });
     const composedMiddlewares = (0, helpers_1.composeMiddlewares)([
         ...(executeOptions.options.middlewares || []),
-        resolveMiddleware
+        resolveMiddleware,
     ]);
     return await composedMiddlewares(executeOptions);
 }

package/lib/resolver/getExecute/index.js

@@ -12,11 +12,12 @@ function getExecute(options) {
         const executeOptions = {
             params: await (0, cleanAndValidate_1.default)({
                 params: options.params,
-                callParams: executeParams.params
+                callParams: executeParams.params,
             }),
             viewer: executeParams.viewer || {},
+            info: executeParams.info || {},
             parent: executeParams.parent,
-            options: options
+            options: options,
         };
         await (0, checkPermissions_1.default)(executeOptions, options);
         const result = await (0, getResultWithMiddlewares_1.getResultWithMiddlewares)(executeOptions);

package/lib/resolver/index.test.js

@@ -6,7 +6,7 @@ it('should return a function with a resolver id', () => {
     const resolver = (0, index_1.resolver)({
         params: {},
         returns: String,
-        async resolve() { }
+        async resolve() { },
     });
     expect(typeof resolver).toBe('object');
     expect(typeof resolver.resolve).toBe('function');
@@ -17,13 +17,13 @@ it('should execute the function', async () => {
     const resolver = (0, index_1.resolver)({
         params: {
             value: {
-                type: Number
-            }
+                type: Number,
+            },
         },
         returns: Number,
         async resolve({ value }) {
             return value * 2;
-        }
+        },
     });
     const result = await resolver.execute({ params: { value: 2 } });
     expect(result).toBe(4);
@@ -33,14 +33,14 @@ it('should get from cache', async () => {
     const resolver = (0, index_1.resolver)({
         params: {
             value: {
-                type: Number
-            }
+                type: Number,
+            },
         },
         returns: Number,
         cache: 100,
         async resolve(params) {
             return index++;
-        }
+        },
     });
     const result1 = await resolver.execute({ params: { value: 1 } }); // 1
     expect(result1).toBe(1);
@@ -58,19 +58,19 @@ it('should create typed resolvers', async () => {
     const resolver = (0, index_1.resolver)({
         params: {
             value: {
-                type: Number
-            }
+                type: Number,
+            },
         },
         returns: Number,
         resolve: async (params) => {
             return params.value * 2;
-        }
+        },
     });
     const result1 = await resolver.resolve({
-        value: 2
+        value: 2,
     });
     const result2 = await resolver.execute({
-        params: { value: 2 }
+        params: { value: 2 },
     });
     expect(result1).toBe(4);
     expect(result2).toBe(4);
@@ -78,15 +78,13 @@ it('should create typed resolvers', async () => {
 it('should create typed model resolvers', async () => {
     const resolver = (0, index_1.modelResolver)({
         returns: Number,
-        resolve: async function (model, params) {
-            return model.value * params.times;
-        }
+        resolve: async (model, params) => model.value * params.times,
     });
     await resolver.resolve({ value: 1 }, { times: 2 });
     const inModel = resolver.modelResolve;
     await resolver.execute({
         parent: { value: 1 },
-        params: { times: 2 }
+        params: { times: 2 },
     });
 });
 it('should accept a model as params', async () => {
@@ -96,13 +94,13 @@ it('should accept a model as params', async () => {
         getSchema() {
             return {
                 value: {
-                    type: 'string'
-                }
+                    type: 'string',
+                },
             };
         },
         initItem(item) {
             return item;
-        }
+        },
     };
     class TypedParams {
         constructor() {
@@ -117,7 +115,7 @@ it('should accept a model as params', async () => {
         returns: Number,
         resolve: async function (item, params) {
             return params.value * 2;
-        }
+        },
     });
     const inModel = resolver.modelResolve;
 });
@@ -128,13 +126,13 @@ it('should accept a model as returns', async () => {
         getSchema() {
             return {
                 value: {
-                    type: 'string'
-                }
+                    type: 'string',
+                },
             };
         },
         initItem(item) {
             return item;
-        }
+        },
     };
     class Returns {
         constructor() {
@@ -148,7 +146,7 @@ it('should accept a model as returns', async () => {
         returns: Returns,
         resolve: async () => {
             return { value: 2 };
-        }
+        },
     });
     const result = await resolver.resolve();
     expect(result.value).toBe(2);
@@ -157,7 +155,7 @@ it('should correctly clean params when no params are passed', async () => {
     const resolver = (0, index_1.resolver)({
         resolve: async ({ title }) => {
             return `${title}`;
-        }
+        },
     });
     expect(await resolver.execute({ params: { title: 'test' } })).toBe('test');
 });
@@ -165,12 +163,12 @@ it('should allow calling resolver.resolve', async () => {
     const resolver = (0, index_1.resolver)({
         resolve: async ({ title }) => {
             return `${title}`;
-        }
+        },
     });
     const modelResolver = (0, index_1.modelResolver)({
         resolve: async ({ title }) => {
             return `${title}`;
-        }
+        },
     });
     expect(await resolver.resolve({ title: 'test' })).toBe('test');
     expect(await modelResolver.resolve({ title: 'test' })).toBe('test');
@@ -179,11 +177,41 @@ it('only allow compliant resolve function', async () => {
     const resolver = (0, index_1.resolver)({
         resolve: async () => {
             return 'hello';
-        }
+        },
     });
     const modelResolver = (0, index_1.modelResolver)({
         resolve: async () => {
             return 'hello';
-        }
+        },
+    });
+});
+it('should allow to pass a fourth param with the info', async () => {
+    const resolver = (0, index_1.resolver)({
+        resolve: async (_params, _viewer, info) => {
+            expect(info.test).toBe(1);
+            return 'hello';
+        },
+    });
+    const modelResolver = (0, index_1.modelResolver)({
+        resolve: async (_parent, _params, _viewer, info) => {
+            expect(info.test).toBe(1);
+            return 'hello';
+        },
+    });
+    await resolver.execute({
+        params: {},
+        viewer: {},
+        info: {
+            test: 1,
+        },
+    });
+    await modelResolver.execute({
+        parent: {},
+        params: {},
+        viewer: {},
+        info: {
+            test: 1,
+        },
     });
+    expect.assertions(2);
 });

package/lib/resolver/types.d.ts

@@ -1,15 +1,16 @@
 import { OrionCache } from '@orion-js/cache';
 import { Blackbox } from '@orion-js/schema';
-export declare type GlobalResolverResolve = (params: any, viewer: any) => Promise<any>;
-export declare type ModelResolverResolve = (item: any, params: any, viewer: any) => Promise<any>;
-export declare type GlobalCheckPermissions = (params: any, viewer: any) => Promise<string | void>;
-export declare type ModelCheckPermissions = (parent: any, params: any, viewer: any) => Promise<string | void>;
-export declare type GlobalGetCacheKey = (params: any, viewer: any) => Promise<any>;
-export declare type ModelGetCacheKey = (parent: any, params: any, viewer: any) => Promise<any>;
+export declare type GlobalResolverResolve = (params: any, viewer: any, info?: any) => Promise<any>;
+export declare type ModelResolverResolve = (item: any, params: any, viewer: any, info?: any) => Promise<any>;
+export declare type GlobalCheckPermissions = (params: any, viewer: any, info?: any) => Promise<string | void>;
+export declare type ModelCheckPermissions = (parent: any, params: any, viewer: any, info?: any) => Promise<string | void>;
+export declare type GlobalGetCacheKey = (params: any, viewer: any, info: any) => Promise<any>;
+export declare type ModelGetCacheKey = (parent: any, params: any, viewer: any, info: any) => Promise<any>;
 export interface ExecuteOptions {
     params: Blackbox;
     viewer: any;
     parent?: any;
+    info?: any;
     options: ResolverOptions;
 }
 declare type Parameters<T> = T extends (...args: infer P) => any ? P : never;
@@ -19,6 +20,7 @@ export interface ExecuteParams<Resolve = Function, IsModel = undefined> {
     params?: ResolverParams<Resolve, IsModel>;
     viewer?: any;
     parent?: IsModel extends undefined ? undefined : Parameters<Resolve>[0];
+    info?: any;
 }
 export declare type Execute<Resolve = Function, IsModel = undefined> = (executeOptions: ExecuteParams<Resolve, IsModel>) => ReturnType<Resolve>;
 export interface SharedResolverOptions {
@@ -51,6 +53,7 @@ export interface PermissionCheckerOptions {
     parent: any;
     params: any;
     viewer: any;
+    info: any;
 }
 export declare type PermissionChecker = (options: PermissionCheckerOptions) => Promise<string | void>;
 export declare type ResolverMiddleware = (executeOptions: ExecuteOptions, next: () => Promise<any>) => Promise<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/resolvers",
-  "version": "3.9.0",
+  "version": "3.11.6-alpha.0",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -17,9 +17,9 @@
     "upgrade-interactive": "yarn upgrade-interactive"
   },
   "dependencies": {
-    "@orion-js/cache": "^3.9.0",
-    "@orion-js/helpers": "^3.9.0",
-    "@orion-js/schema": "^3.9.0"
+    "@orion-js/cache": "^3.11.6-alpha.0",
+    "@orion-js/helpers": "^3.11.6-alpha.0",
+    "@orion-js/schema": "^3.11.6-alpha.0"
   },
   "devDependencies": {
     "@shelf/jest-mongodb": "^2.1.0",
@@ -33,5 +33,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "23e0eda5348153dcc07b307a97b641d52eb41f39"
+  "gitHead": "cdcf47aed25cb864126e624cd808c08d7959b8a4"
 }