@agatee/graphql
Version:
Graphql module to use with Agatee
149 lines (148 loc) • 7.07 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.FinalPermissions = exports.FinalResolvers = exports.FinalTypeDefs = exports.GatGraphql = void 0;
const core_1 = require("@agatee/core");
const path_1 = __importDefault(require("path"));
require("reflect-metadata");
const graphql_import_1 = require("../graphql-import");
const FinalTypeDefsMethod = Symbol('FinalTypeDefsMethod');
const FinalResolversMethod = Symbol('CombinedResolversMethods');
const FinalPermissionMethod = Symbol('FinalPermissionMethod');
function GatGraphql(params) {
return function (constructorFunc) {
let newConstructorFunc = function (...args) {
var _a, _b;
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;
if ((_a = params.resolvers) === null || _a === void 0 ? void 0 : _a.length) {
let typeDefs = '';
let typeQuery = '';
let typeMutation = '';
let Queries = {};
let Mutations = {};
let CustomResovlers = {};
let QueryPermission = {};
let MutationPermission = {};
for (let resolver of params.resolvers.map(el => new el())) {
let resolverTypeDefs = ``;
if (resolver.__schema) {
resolverTypeDefs = (0, graphql_import_1.importSchema)(path_1.default.join(resolver.__dirname, resolver.__schema));
}
typeDefs += resolverTypeDefs;
if (resolver.__querieSchema) {
typeQuery += resolver.__querieSchema + '\n';
Object.assign(Queries, resolver.__queriesResolvers);
if (resolver.__queriesPermission) {
Object.assign(QueryPermission, resolver.__queriesPermission);
}
}
if (resolver.__mutationSchema) {
typeMutation += resolver.__mutationSchema + '\n';
Object.assign(Mutations, resolver.__mutationsResolvers);
if (resolver.__mutationPermission) {
Object.assign(MutationPermission, resolver.__mutationPermission);
}
}
if ((_b = resolver.__customResolvers) === null || _b === void 0 ? void 0 : _b.length) {
let customResolvers = {};
for (let custom of resolver.__customResolvers) {
Object.assign(customResolvers, custom());
}
if (customResolvers.Mutation) {
Object.assign(Mutations, customResolvers.Mutation);
delete customResolvers.Mutation;
}
if (customResolvers.Query) {
Object.assign(Queries, customResolvers.Query);
delete customResolvers.Query;
}
Object.assign(CustomResovlers, customResolvers);
}
}
let isDefaultQuery = false;
let queryMatch = typeDefs.split('\n').find(el => el.trim()[0] != '#' && el.match(/type\s+Query\s+{/));
if (typeQuery) {
typeDefs += `\ntype Query {${typeQuery}}`;
}
else if (!queryMatch) {
typeDefs += `\ntype Query {defaultQuery: String}`;
isDefaultQuery = true;
}
if (typeMutation) {
typeDefs += `\ntype Mutation {${typeMutation || ''}}`;
}
if (typeMutation) {
typeDefs += `\ntype Mutation {${typeMutation}}`;
}
const MainResolver = {};
const MainPermission = {};
if (Object.keys(Queries).length) {
MainResolver.Query = Queries;
}
if (Object.keys(Mutations).length) {
MainResolver.Mutation = Mutations;
}
if (Object.keys(CustomResovlers).length) {
Object.assign(MainResolver, CustomResovlers);
}
if (Object.keys(QueryPermission).length) {
MainPermission.Query = QueryPermission;
}
if (Object.keys(MutationPermission).length) {
MainPermission.Mutation = MutationPermission;
}
if (func.prototype[FinalTypeDefsMethod]) {
const key = func.prototype[FinalTypeDefsMethod];
func.prototype[key] = typeDefs;
}
if (func.prototype[FinalResolversMethod]) {
const key = func.prototype[FinalResolversMethod];
func.prototype[key] = MainResolver;
}
if (func.prototype[FinalPermissionMethod]) {
const key = func.prototype[FinalPermissionMethod];
func.prototype[key] = MainPermission;
}
}
else { // default query
let typeDefs = `\ntype Query {defaultQuery: String}`;
if (func.prototype[FinalTypeDefsMethod]) {
const key = func.prototype[FinalTypeDefsMethod];
func.prototype[key] = typeDefs;
}
if (func.prototype[FinalResolversMethod]) {
const key = func.prototype[FinalResolversMethod];
func.prototype[key] = {};
}
if (func.prototype[FinalPermissionMethod]) {
const key = func.prototype[FinalPermissionMethod];
func.prototype[key] = {};
}
}
let newInstance = new func();
return newInstance;
};
newConstructorFunc.prototype = constructorFunc.prototype;
return newConstructorFunc;
};
}
exports.GatGraphql = GatGraphql;
function FinalTypeDefs(target, propertyKey) {
target[FinalTypeDefsMethod] = propertyKey;
}
exports.FinalTypeDefs = FinalTypeDefs;
function FinalResolvers(target, propertyKey) {
target[FinalResolversMethod] = propertyKey;
}
exports.FinalResolvers = FinalResolvers;
function FinalPermissions(target, propertyKey) {
target[FinalPermissionMethod] = propertyKey;
}
exports.FinalPermissions = FinalPermissions;