@agatee/graphql/decorators/gat-resolver.js

Graphql module to use with Agatee

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Permission = exports.Custom = exports.Mutation = exports.Query = exports.GatGqlResolver = void 0;
const core_1 = require("@agatee/core");
require("reflect-metadata");
const callsite_1 = __importDefault(require("callsite"));
const path_1 = __importDefault(require("path"));
const QueryMethods = Symbol('QueryMethods');
const MutationMethods = Symbol('MutationMethods');
const CustomResolverMethods = Symbol('CustomResolverMethods');
const PermissionsMethods = Symbol('PermissionsMethods');
function GatGqlResolver(params) {
    var stack = (0, callsite_1.default)(), requester = stack[1].getFileName();
    params.__dirname = path_1.default.dirname(requester);
    return function (constructorFunc) {
        let newConstructorFunc = function (...args) {
            var _a, _b, _c, _d;
            let func = function () {
                let metadata = Reflect.getMetadata('design:paramtypes', constructorFunc) || [];
                let injections = metadata.map(token => core_1.Injector.resolve(token));
                return new constructorFunc(...injections);
            };
            func.prototype = constructorFunc.prototype;
            func.prototype.__schema = params.schema;
            func.prototype.__dirname = params.__dirname;
            let newInstance = new func();
            if (func.prototype[QueryMethods]) {
                let __querieSchema = '\n';
                let __queriesResolvers = {};
                let __queriesPermission = {};
                for (let [method, schema] of func.prototype[QueryMethods]) {
                    __querieSchema += `\t${schema}\n`;
                    __queriesResolvers[method] = newInstance[method].bind(newInstance);
                    if ((_a = func.prototype[PermissionsMethods]) === null || _a === void 0 ? void 0 : _a.get(method)) {
                        __queriesPermission[method] = (_b = func.prototype[PermissionsMethods]) === null || _b === void 0 ? void 0 : _b.get(method);
                    }
                }
                func.prototype.__querieSchema = __querieSchema;
                func.prototype.__queriesResolvers = __queriesResolvers;
                func.prototype.__queriesPermission = __queriesPermission;
            }
            if (func.prototype[MutationMethods]) {
                let __mutationSchema = '\n';
                let __mutationsResolvers = {};
                let __mutationPermission = {};
                for (let [method, schema] of func.prototype[MutationMethods]) {
                    __mutationSchema += `\t${schema}\n`;
                    __mutationsResolvers[method] = newInstance[method].bind(newInstance);
                    if ((_c = func.prototype[PermissionsMethods]) === null || _c === void 0 ? void 0 : _c.get(method)) {
                        __mutationPermission[method] = (_d = func.prototype[PermissionsMethods]) === null || _d === void 0 ? void 0 : _d.get(method);
                    }
                }
                func.prototype.__mutationSchema = __mutationSchema;
                func.prototype.__mutationsResolvers = __mutationsResolvers;
                func.prototype.__mutationPermission = __mutationPermission;
            }
            if (func.prototype[CustomResolverMethods]) {
                let __customResolvers = [];
                for (let method of func.prototype[CustomResolverMethods]) {
                    __customResolvers.push(newInstance[method].bind(newInstance));
                }
                func.prototype.__customResolvers = __customResolvers;
            }
            return newInstance;
        };
        newConstructorFunc.prototype = constructorFunc.prototype;
        return newConstructorFunc;
    };
}
exports.GatGqlResolver = GatGqlResolver;
function Query(schema) {
    return function (target, key, descriptor) {
        target[QueryMethods] = target[QueryMethods] || new Map();
        target[QueryMethods].set(key, schema || key.toLowerCase());
    };
}
exports.Query = Query;
function Mutation(schema) {
    return function (target, key, descriptor) {
        target[MutationMethods] = target[MutationMethods] || new Map();
        target[MutationMethods].set(key, schema || key.toLowerCase());
    };
}
exports.Mutation = Mutation;
function Custom() {
    return function (target, key, descriptor) {
        target[CustomResolverMethods] = target[CustomResolverMethods] || [];
        target[CustomResolverMethods].push(key);
    };
}
exports.Custom = Custom;
function Permission(rule) {
    return function (target, key, descriptor) {
        target[PermissionsMethods] = target[PermissionsMethods] || new Map();
        target[PermissionsMethods].set(key, rule);
    };
}
exports.Permission = Permission;