@pothos/plugin-scope-auth/lib/steps.js

A Pothos plugin for adding scope based authorization checks to your GraphQL Schema

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: Object.getOwnPropertyDescriptor(all, name).get
    });
}
_export(exports, {
    get createFieldAuthScopesStep () {
        return createFieldAuthScopesStep;
    },
    get createFieldGrantScopesStep () {
        return createFieldGrantScopesStep;
    },
    get createResolveStep () {
        return createResolveStep;
    },
    get createTypeAuthScopesStep () {
        return createTypeAuthScopesStep;
    },
    get createTypeGrantScopesStep () {
        return createTypeGrantScopesStep;
    }
});
const _core = require("@pothos/core");
function createTypeAuthScopesStep(authScopes, type) {
    if (typeof authScopes === 'function') {
        return {
            run: (state, parent, _args, _context, info)=>state.evaluateTypeScopeFunction(authScopes, type, parent, info),
            errorMessage: `Not authorized to read fields for ${type}`
        };
    }
    return {
        run: (state, _parent, _args, _context, info)=>state.evaluateScopeMap(authScopes, info),
        errorMessage: `Not authorized to read fields for ${type}`
    };
}
function createTypeGrantScopesStep(grantScopes, type, forField) {
    return {
        run: (state, parent, _args, context, info)=>state.grantTypeScopes(type, parent, forField ? info.path.prev : info.path, ()=>grantScopes(parent, context)),
        errorMessage: `Unknown error creating grants for ${type}`
    };
}
function createFieldAuthScopesStep(authScopes) {
    if (typeof authScopes === 'function') {
        return {
            errorMessage: (_parent, _args, _context, info)=>`Not authorized to resolve ${info.parentType}.${info.fieldName}`,
            run: (state, parent, args, context, info)=>{
                const scopeMap = authScopes(parent, args, context, info);
                if ((0, _core.isThenable)(scopeMap)) {
                    return scopeMap.then((resolved)=>state.evaluateScopeMap(resolved, info));
                }
                return state.evaluateScopeMap(scopeMap, info);
            }
        };
    }
    return {
        errorMessage: (_parent, _args, _context, info)=>`Not authorized to resolve ${info.parentType}.${info.fieldName}`,
        run: (state, _parent, _args, _context, info)=>state.evaluateScopeMap(authScopes, info)
    };
}
function createFieldGrantScopesStep(grantScopes) {
    return {
        errorMessage: (_parent, _args, _context, info)=>`Unknown issue generating grants for ${info.parentType}.${info.fieldName}`,
        run: (state, parent, args, context, info)=>{
            if (typeof grantScopes !== 'function') {
                state.saveGrantedScopes(grantScopes, info.path);
                return null;
            }
            const result = grantScopes(parent, args, context, info);
            if ((0, _core.isThenable)(result)) {
                return result.then((resolved)=>{
                    state.saveGrantedScopes(resolved, info.path);
                    return null;
                });
            }
            state.saveGrantedScopes(result, info.path);
            return null;
        }
    };
}
function createResolveStep(resolver) {
    return {
        errorMessage: (_parent, _args, _context, info)=>`Unknown issue resolving ${info.parentType}.${info.fieldName}`,
        run: (_state, parent, args, context, info, setResolved)=>{
            const result = resolver(parent, args, context, info);
            if ((0, _core.isThenable)(result)) {
                return Promise.resolve(result).then((resolved)=>{
                    setResolved(resolved);
                    return null;
                });
            }
            setResolved(result);
            return null;
        }
    };
}

//# sourceMappingURL=steps.js.map