@orion-js/resolvers 3.0.0-alpha.20 → 3.0.6

package/lib/index.d.ts

@@ -1,3 +1,7 @@
-import resolver from './resolver';
+import { resolver, modelResolver } from './resolver';
 export * from './resolver/types';
-export { resolver };
+import checkPermissions from './resolver/getExecute/checkPermissions';
+import { addPermissionChecker } from './resolver/permisionsCheckers';
+import cleanParams from './resolver/cleanParams';
+import cleanReturns from './resolver/cleanReturns';
+export { resolver, modelResolver, checkPermissions, addPermissionChecker, cleanParams, cleanReturns };

package/lib/index.js

@@ -13,7 +13,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolver = void 0;
-const resolver_1 = __importDefault(require("./resolver"));
-exports.resolver = resolver_1.default;
+exports.cleanReturns = exports.cleanParams = exports.addPermissionChecker = exports.checkPermissions = exports.modelResolver = exports.resolver = void 0;
+const resolver_1 = require("./resolver");
+Object.defineProperty(exports, "resolver", { enumerable: true, get: function () { return resolver_1.resolver; } });
+Object.defineProperty(exports, "modelResolver", { enumerable: true, get: function () { return resolver_1.modelResolver; } });
 __exportStar(require("./resolver/types"), exports);
+const checkPermissions_1 = __importDefault(require("./resolver/getExecute/checkPermissions"));
+exports.checkPermissions = checkPermissions_1.default;
+const permisionsCheckers_1 = require("./resolver/permisionsCheckers");
+Object.defineProperty(exports, "addPermissionChecker", { enumerable: true, get: function () { return permisionsCheckers_1.addPermissionChecker; } });
+const cleanParams_1 = __importDefault(require("./resolver/cleanParams"));
+exports.cleanParams = cleanParams_1.default;
+const cleanReturns_1 = __importDefault(require("./resolver/cleanReturns"));
+exports.cleanReturns = cleanReturns_1.default;

package/lib/resolver/cleanParams.js

@@ -7,6 +7,10 @@ const clone_1 = __importDefault(require("lodash/clone"));
 function default_1(rawParams) {
     if (!rawParams)
         return;
+    // for typed model
+    if (rawParams.getModel) {
+        rawParams = rawParams.getModel();
+    }
     if (rawParams.__isModel) {
         rawParams = rawParams.getSchema();
     }

package/lib/resolver/cleanReturns.d.ts

@@ -0,0 +1 @@
+export default function (rawReturns: any): any;

package/lib/resolver/cleanReturns.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1(rawReturns) {
+    if (!rawReturns)
+        return;
+    // for typed model
+    if (rawReturns.getModel) {
+        return rawReturns.getModel();
+    }
+    return rawReturns;
+}
+exports.default = default_1;

package/lib/resolver/getArgs.d.ts

@@ -0,0 +1,9 @@
+export declare const getArgs: (...args: any[]) => {
+    parent: any;
+    params: any;
+    viewer: any;
+} | {
+    params: any;
+    viewer: any;
+    parent?: undefined;
+};

package/lib/resolver/getArgs.js

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

package/lib/resolver/getExecute/checkPermissions.js

@@ -6,9 +6,11 @@ async function default_1(executeOptions, options) {
     const { parent, params, viewer } = executeOptions;
     if (viewer.app)
         return;
-    await (0, permisionsCheckers_1.checkPermissions)(options.permissionsOptions, viewer, {
+    await (0, permisionsCheckers_1.checkPermissions)({
+        resolver: options,
         parent,
-        params
+        params,
+        viewer
     });
     if (options.checkPermission) {
         const execute = async () => {

package/lib/resolver/getExecute/index.d.ts

@@ -1,2 +1,2 @@
 import { ResolverOptions, Execute } from '../types';
-export default function (options: ResolverOptions): Execute<any>;
+export default function (options: ResolverOptions): Execute<import("../types").Params, any, undefined>;

package/lib/resolver/getExecute/initResult.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const isArray_1 = __importDefault(require("lodash/isArray"));
 const isNil_1 = __importDefault(require("lodash/isNil"));
 function default_1(options, result) {
-    const { returns } = options;
+    let { returns } = options;
     if (returns) {
         if ((0, isArray_1.default)(returns) && returns[0].__isModel) {
             if ((0, isNil_1.default)(result)) {

package/lib/resolver/index.d.ts

@@ -1,3 +1,5 @@
 import { CreateResolver } from './types';
+import { CreateModelResolver } from '..';
 declare const resolver: CreateResolver;
-export default resolver;
+declare const modelResolver: CreateModelResolver;
+export { resolver, modelResolver };

package/lib/resolver/index.js

@@ -3,24 +3,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelResolver = exports.resolver = void 0;
 const getExecute_1 = __importDefault(require("./getExecute"));
 const cleanParams_1 = __importDefault(require("./cleanParams"));
 const helpers_1 = require("@orion-js/helpers");
 const cache_1 = require("@orion-js/cache");
-const resolver = function (options) {
+const cleanReturns_1 = __importDefault(require("./cleanReturns"));
+const getArgs_1 = require("./getArgs");
+const createResolver = function (options) {
     options.params = (0, cleanParams_1.default)(options.params);
+    options.returns = (0, cleanReturns_1.default)(options.returns);
     if (!options.cacheProvider) {
         options.cacheProvider = cache_1.defaultCache;
     }
     if (!options.resolverId) {
         options.resolverId = (0, helpers_1.generateId)();
     }
-    const resolve = options.resolve;
+    const execute = (0, getExecute_1.default)(options);
+    const resolve = async (...args) => {
+        let { parent, params, viewer } = (0, getArgs_1.getArgs)(...args);
+        const executeOptions = { parent, params, viewer };
+        return await execute(executeOptions);
+    };
     const resolver = {
         ...options,
         resolve,
-        execute: (0, getExecute_1.default)(options)
+        execute
     };
     return resolver;
 };
-exports.default = resolver;
+const resolver = createResolver;
+exports.resolver = resolver;
+const modelResolver = createResolver;
+exports.modelResolver = modelResolver;

package/lib/resolver/index.test.js

@@ -1,21 +1,19 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = __importDefault(require("./index"));
+const index_1 = require("./index");
 it('should return a function with a resolver id', () => {
-    const resolver = (0, index_1.default)({
+    const resolver = (0, index_1.resolver)({
         params: {},
         returns: String,
         async resolve(params, viewer) { }
     });
     expect(typeof resolver).toBe('object');
+    expect(typeof resolver.resolve).toBe('function');
     expect(typeof resolver.execute).toBe('function');
     expect(typeof resolver.resolverId).toBe('string');
 });
 it('should execute the function', async () => {
-    const resolver = (0, index_1.default)({
+    const resolver = (0, index_1.resolver)({
         params: {
             value: {
                 type: Number
@@ -31,7 +29,7 @@ it('should execute the function', async () => {
 });
 it('should get from cache', async () => {
     let index = 1;
-    const resolver = (0, index_1.default)({
+    const resolver = (0, index_1.resolver)({
         params: {
             value: {
                 type: Number
@@ -55,39 +53,35 @@ it('should get from cache', async () => {
     expect(result5).toBe(3);
 });
 it('should create typed resolvers', async () => {
-    const resolve = async (params) => {
-        return params.value * 2;
-    };
-    const resolver = (0, index_1.default)({
+    const resolver = (0, index_1.resolver)({
         params: {
             value: {
                 type: Number
             }
         },
         returns: Number,
-        resolve
+        resolve: async (params, viewer) => {
+            return params.value * 2;
+        }
     });
-    const result = await resolver.execute({ params: { value: 2 } });
-    expect(result).toBe(4);
+    const result1 = await resolver.resolve({
+        value: 2
+    });
+    const result2 = await resolver.execute({
+        params: { value: 2 }
+    });
+    expect(result1).toBe(4);
+    expect(result2).toBe(4);
 });
 it('should create typed model resolvers', async () => {
-    const resolver = (0, index_1.default)({
-        params: {
-            value: {
-                type: Number
-            }
-        },
+    const resolver = (0, index_1.modelResolver)({
         returns: Number,
-        resolve: async function (model, params) {
+        resolve: async function (model, params, viewer) {
             return model.value * 2;
         }
     });
-    const inModel = resolver.resolve;
-    const inModelResult = await inModel({ value: 2 });
-    /**
-     * We are testing the typescript removes one argument on the resolve function.
-     */
-    expect(inModelResult).toBe(4);
+    resolver.resolve({}, { value: '' });
+    const inModel = resolver.modelResolve;
 });
 it('should accept a model as params', async () => {
     const aModel = {
@@ -99,27 +93,73 @@ it('should accept a model as params', async () => {
                     type: 'string'
                 }
             };
+        },
+        initItem(item) {
+            return item;
         }
     };
-    const resolver = (0, index_1.default)({
-        params: aModel,
+    class TypedParams {
+        static getModel() {
+            return aModel;
+        }
+    }
+    const resolver = (0, index_1.modelResolver)({
+        params: TypedParams,
         returns: Number,
-        resolve: async function (params) {
+        resolve: async function (item, params, viewer) {
             return params.value * 2;
         }
     });
-    const inModel = resolver.resolve;
-    const inModelResult = await inModel({ value: 2 });
-    /**
-     * We are testing the typescript removes one argument on the resolve function.
-     */
-    expect(inModelResult).toBe(4);
+    const inModel = resolver.modelResolve;
+});
+it('should accept a model as returns', async () => {
+    const aModel = {
+        __isModel: true,
+        name: 'Returns',
+        getSchema() {
+            return {
+                value: {
+                    type: 'string'
+                }
+            };
+        },
+        initItem(item) {
+            return item;
+        }
+    };
+    class Returns {
+        static getModel() {
+            return aModel;
+        }
+    }
+    const resolver = (0, index_1.resolver)({
+        returns: Returns,
+        resolve: async (params, viewer) => {
+            return { value: 2 };
+        }
+    });
+    const result = await resolver.resolve({});
+    expect(result.value).toBe(2);
 });
 it('should correctly clean params when no params are passed', async () => {
-    const resolver = (0, index_1.default)({
+    const resolver = (0, index_1.resolver)({
         resolve: async ({ title }) => {
             return `${title}`;
         }
     });
     expect(await resolver.execute({ params: { title: 'test' } })).toBe('test');
 });
+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');
+});

package/lib/resolver/permisionsCheckers.d.ts

@@ -1,2 +1,3 @@
-export declare const addPermissionChecker: (func: any) => void;
-export declare const checkPermissions: (...args: any[]) => Promise<void>;
+import { PermissionChecker, PermissionCheckerOptions } from './types';
+export declare const addPermissionChecker: (func: PermissionChecker) => void;
+export declare const checkPermissions: (options: PermissionCheckerOptions) => Promise<void>;

package/lib/resolver/permisionsCheckers.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkPermissions = exports.addPermissionChecker = void 0;
 const helpers_1 = require("@orion-js/helpers");
-const checkers = [];
+global.checkers = [];
 const addPermissionChecker = function (func) {
-    checkers.push(func);
+    global.checkers.push(func);
 };
 exports.addPermissionChecker = addPermissionChecker;
-const checkPermissions = async function (...args) {
-    for (const checker of checkers) {
-        const errorMessage = await checker(...args);
+const checkPermissions = async function (options) {
+    for (const checker of global.checkers) {
+        const errorMessage = await checker(options);
         if (errorMessage) {
             throw new helpers_1.PermissionsError(errorMessage);
         }

package/lib/resolver/types.d.ts

@@ -1,6 +1,6 @@
 import { OrionCache } from '@orion-js/cache';
-export declare type GlobalResolve<T = Promise<any>> = (params: any, viewer: any) => T;
-export declare type ModelResolve<T = Promise<any>> = (parent: any, params: any, viewer?: any) => T;
+export declare type GlobalResolverResolve<ParamsType = any, ReturnType = any> = (params?: ParamsType, viewer?: any) => Promise<ReturnType>;
+export declare type ModelResolverResolve<ModelType = any, ParamsType = any, ReturnType = any> = (item: ModelType, params?: ParamsType, viewer?: any) => Promise<ReturnType>;
 export declare type GlobalCheckPermissions = (params: any, viewer: any) => Promise<string>;
 export declare type ModelCheckPermissions = (parent: any, params: any, viewer: any) => Promise<string>;
 export declare type GlobalGetCacheKey = (params: any, viewer: any) => Promise<any>;
@@ -13,15 +13,15 @@ export interface ExecuteOptions {
     viewer: any;
     parent?: any;
 }
-export interface ExecuteParams {
-    params?: Params;
+export interface ExecuteParams<ParamsType extends Params = Params, ModelType = undefined> {
+    params?: ParamsType;
     viewer?: any;
-    parent?: any;
+    parent?: ModelType;
 }
-export declare type Execute<ReturnType = any> = (executeOptions: ExecuteParams) => Promise<ReturnType>;
+export declare type Execute<ParamsType = Params, ReturnType = any, ModelType = undefined> = (executeOptions: ExecuteParams<ParamsType, ModelType>) => Promise<ReturnType>;
 export interface SharedResolverOptions {
     resolverId?: string;
-    params?: Params;
+    params?: any;
     returns?: any;
     mutation?: boolean;
     private?: boolean;
@@ -31,15 +31,24 @@ export interface SharedResolverOptions {
     cacheProvider?: OrionCache;
     permissionsOptions?: any;
 }
-export interface ResolverOptions extends SharedResolverOptions {
-    resolve: GlobalResolve | ModelResolve;
+export interface ResolverOptions<ParamsType extends Params = Params, ReturnType = any, ModelType = undefined> extends SharedResolverOptions {
+    resolve: ModelType extends undefined ? GlobalResolverResolve<ParamsType, ReturnType> : ModelResolverResolve<ModelType, Params, ReturnType>;
+}
+export interface Resolver<ParamsType = any, ReturnType = any, ModelType = undefined> extends SharedResolverOptions {
+    execute: Execute<ParamsType, ReturnType, ModelType>;
+    resolve: ModelType extends undefined ? GlobalResolverResolve<ParamsType, ReturnType> : ModelResolverResolve<ModelType, Params, ReturnType>;
+    modelResolve?: ModelType extends undefined ? undefined : GlobalResolverResolve<ParamsType, ReturnType>;
 }
-declare type AnyFunction = (...args: any) => any;
-export interface Resolver<ResolveFunction extends AnyFunction = AnyFunction> extends SharedResolverOptions {
-    execute: Execute<ReturnType<ResolveFunction>>;
-    resolve: ResolveFunction;
+export declare type CreateResolver = <ParamsType, ReturnType>(options: {
+    resolve: (params?: ParamsType, viewer?: any) => Promise<ReturnType>;
+} & ResolverOptions<ParamsType, ReturnType>) => Resolver<ParamsType, ReturnType, undefined>;
+export declare type CreateModelResolver = <ModelType, ParamsType, ReturnType>(options: {
+    resolve: (item: ModelType, params?: ParamsType, viewer?: any) => Promise<ReturnType>;
+} & ResolverOptions<ParamsType, ReturnType, ModelType>) => Resolver<ParamsType, ReturnType, ModelType>;
+export interface PermissionCheckerOptions {
+    resolver: ResolverOptions;
+    parent: any;
+    params: any;
+    viewer: any;
 }
-export declare type CreateResolver = <ResolveFunction extends AnyFunction>(options: ResolverOptions) => Resolver<ResolveFunction>;
-declare type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R ? (...args: P) => R : never;
-export declare type ModelResolverFunction<F extends ModelResolve> = OmitFirstArg<F>;
-export {};
+export declare type PermissionChecker = (options: PermissionCheckerOptions) => Promise<string | void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/resolvers",
-  "version": "3.0.0-alpha.20",
+  "version": "3.0.6",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -16,9 +16,9 @@
     "watch": "yarn run clean && tsc -w"
   },
   "dependencies": {
-    "@orion-js/cache": "^3.0.0-alpha.10",
-    "@orion-js/helpers": "^3.0.0-alpha.11",
-    "@orion-js/schema": "^3.0.0-alpha.13"
+    "@orion-js/cache": "^3.0.0-alpha.23",
+    "@orion-js/helpers": "^3.0.0",
+    "@orion-js/schema": "^3.0.0"
   },
   "devDependencies": {
     "@shelf/jest-mongodb": "^2.1.0",
@@ -31,5 +31,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "145e17f5a9d6bbf02f166c5faa416be60752a42f"
+  "gitHead": "91b207f9f7afa418177b5aeace2e5f9b0a0ef04d"
 }