@orion-js/resolvers 3.11.15 → 4.0.0-alpha.3

package/lib/resolver/index.test.js

@@ -1,217 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("./index");
-const helpers_1 = require("@orion-js/helpers");
-it('should return a function with a resolver id', () => {
-    const resolver = (0, index_1.resolver)({
-        params: {},
-        returns: String,
-        async resolve() { },
-    });
-    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.resolver)({
-        params: {
-            value: {
-                type: Number,
-            },
-        },
-        returns: Number,
-        async resolve({ value }) {
-            return value * 2;
-        },
-    });
-    const result = await resolver.execute({ params: { value: 2 } });
-    expect(result).toBe(4);
-});
-it('should get from cache', async () => {
-    let index = 1;
-    const resolver = (0, index_1.resolver)({
-        params: {
-            value: {
-                type: Number,
-            },
-        },
-        returns: Number,
-        cache: 100,
-        async resolve(params) {
-            return index++;
-        },
-    });
-    const result1 = await resolver.execute({ params: { value: 1 } }); // 1
-    expect(result1).toBe(1);
-    const result2 = await resolver.execute({ params: { value: 1 } }); // 1
-    expect(result2).toBe(1);
-    const result3 = await resolver.execute({ params: { value: 2 } }); // 2
-    expect(result3).toBe(2);
-    const result4 = await resolver.execute({ params: { value: 2 } }); // 2
-    expect(result4).toBe(2);
-    const result5 = await resolver.execute({ params: { value: 3 } }); // 3
-    expect(result5).toBe(3);
-    await (0, helpers_1.sleep)(100);
-});
-it('should create typed resolvers', async () => {
-    const resolver = (0, index_1.resolver)({
-        params: {
-            value: {
-                type: Number,
-            },
-        },
-        returns: Number,
-        resolve: async (params) => {
-            return params.value * 2;
-        },
-    });
-    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.modelResolver)({
-        returns: Number,
-        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 },
-    });
-});
-it('should accept a model as params', async () => {
-    const aModel = {
-        __isModel: true,
-        name: 'ResolverParams',
-        getSchema() {
-            return {
-                value: {
-                    type: 'string',
-                },
-            };
-        },
-        initItem(item) {
-            return item;
-        },
-    };
-    class TypedParams {
-        constructor() {
-            this.value = 1;
-        }
-        static getModel() {
-            return aModel;
-        }
-    }
-    const resolver = (0, index_1.modelResolver)({
-        params: TypedParams,
-        returns: Number,
-        resolve: async function (item, params) {
-            return params.value * 2;
-        },
-    });
-    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 {
-        constructor() {
-            this.value = 1;
-        }
-        static getModel() {
-            return aModel;
-        }
-    }
-    const resolver = (0, index_1.resolver)({
-        returns: Returns,
-        resolve: async () => {
-            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.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');
-});
-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/permisionsCheckers.d.ts

@@ -1,3 +0,0 @@
-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

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

package/lib/resolver/types.d.ts

@@ -1,60 +0,0 @@
-import { OrionCache } from '@orion-js/cache';
-import { Blackbox } from '@orion-js/schema';
-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;
-declare type ReturnType<T> = T extends (...args: any) => infer R ? R : any;
-declare type ResolverParams<Resolve, IsModel> = IsModel extends undefined ? Parameters<Resolve>[0] : Parameters<Resolve>[1];
-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 {
-    resolverId?: string;
-    params?: any;
-    returns?: any;
-    mutation?: boolean;
-    private?: boolean;
-    checkPermission?: GlobalCheckPermissions | ModelCheckPermissions;
-    getCacheKey?: GlobalGetCacheKey | ModelGetCacheKey;
-    cache?: number;
-    cacheProvider?: OrionCache;
-    permissionsOptions?: any;
-    middlewares?: ResolverMiddleware[];
-}
-export interface ResolverOptions<Resolve = Function> extends SharedResolverOptions {
-    resolve: Resolve;
-}
-declare type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R ? (...args: P) => R : never;
-export interface Resolver<Resolve = Function, IsModel = undefined> extends SharedResolverOptions {
-    execute: Execute<Resolve, IsModel>;
-    resolve: Resolve;
-    modelResolve: IsModel extends undefined ? undefined : OmitFirstArg<Resolve>;
-}
-export declare type ModelResolver<Resolve = Function> = Resolver<Resolve, true>;
-export declare type CreateResolver = <Resolve extends GlobalResolverResolve>(options: ResolverOptions<Resolve>) => Resolver<Resolve>;
-export declare type CreateModelResolver = <Resolve extends ModelResolverResolve>(options: ResolverOptions<Resolve>) => ModelResolver<Resolve>;
-export interface PermissionCheckerOptions {
-    resolver: ResolverOptions;
-    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>;
-export {};

package/lib/resolver/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });