@restorecommerce/facade 1.0.1 → 1.1.1

package/dist/gql/protos/resolvers.js

@@ -0,0 +1,427 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSubServiceResolvers = exports.generateResolver = exports.registerResolverFunction = exports.getGQLResolverFunctions = void 0;
+const types_1 = require("./types");
+const array_prototype_flat_1 = require("array.prototype.flat");
+const registry_1 = require("./registry");
+const graphql_1 = require("./graphql");
+const utils_1 = require("./utils");
+const rc_grpc_clients_1 = require("@restorecommerce/rc-grpc-clients");
+const resource_base_1 = require("@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/resource_base");
+const stream = require("stream");
+const _ = require("lodash");
+const kafka_client_1 = require("@restorecommerce/kafka-client");
+const inputMethodType = new Map();
+const getGQLResolverFunctions = (service, key, serviceKey, cfg) => {
+    if (!service.method) {
+        return {};
+    }
+    return service.method.reduce((obj, method) => {
+        var _a, _b, _c, _d;
+        if ((_b = (_a = cfg[serviceKey]) === null || _a === void 0 ? void 0 : _a.methods) === null || _b === void 0 ? void 0 : _b.blacklist) {
+            const blacklistMethods = (_d = (_c = cfg[serviceKey]) === null || _c === void 0 ? void 0 : _c.methods) === null || _d === void 0 ? void 0 : _d.blacklist;
+            if (blacklistMethods.includes(method.name)) {
+                return {};
+            }
+        }
+        const typing = (0, registry_1.getTyping)(method.inputType);
+        const outputTyping = (0, registry_1.getTyping)(method.outputType);
+        if (!typing) {
+            throw Error(`Method '${method.name}' could not find input type: ${method.inputType}`);
+        }
+        if (!outputTyping) {
+            throw Error(`Method '${method.name}' could not find output type: ${method.outputType}`);
+        }
+        if (!('fromPartial' in typing.processor)) {
+            throw Error(`Method ${method.name} input type '${method.inputType}' does not contain 'fromPartial' function`);
+        }
+        let subjectField = null;
+        if (typing) {
+            for (let field of typing.meta.field) {
+                if (field.typeName === types_1.authSubjectType) {
+                    subjectField = field.name;
+                    break;
+                }
+            }
+        }
+        let methodName = method.name;
+        if (graphql_1.Mutate.indexOf(method.name) > -1) {
+            methodName = 'Mutate';
+        }
+        if (methodName in obj) {
+            return obj;
+        }
+        obj[methodName] = async (args, context) => {
+            var _a, _b;
+            const client = context[key].client;
+            const service = client[serviceKey];
+            try {
+                const converted = await (0, graphql_1.preprocessGQLInput)(args.input, typing.input);
+                const scope = (_a = args === null || args === void 0 ? void 0 : args.input) === null || _a === void 0 ? void 0 : _a.scope;
+                let req = typing.processor.fromPartial(converted);
+                // convert enum strings to integers
+                req = (0, utils_1.convertEnumToInt)(typing, req);
+                if (subjectField !== null) {
+                    req.subject = (0, registry_1.getTyping)(types_1.authSubjectType).processor.fromPartial({});
+                    const authToken = context.request.req.headers['authorization'];
+                    if (authToken && authToken.startsWith('Bearer ')) {
+                        req.subject.token = authToken.split(' ')[1];
+                    }
+                    if (scope) {
+                        req.subject.scope = scope;
+                    }
+                }
+                let realMethod = method.name;
+                if (graphql_1.Mutate.indexOf(method.name) > -1) {
+                    const mode = (_b = args === null || args === void 0 ? void 0 : args.input) === null || _b === void 0 ? void 0 : _b.mode;
+                    if (!mode) {
+                        throw new Error('Please specify mode');
+                    }
+                    if (mode === 'CREATE') {
+                        realMethod = 'Create';
+                    }
+                    else if (mode === 'UPDATE') {
+                        realMethod = 'Update';
+                    }
+                    else if (mode === 'UPSERT') {
+                        realMethod = 'Upsert';
+                    }
+                }
+                const methodFunc = service[(0, utils_1.camelCase)(realMethod)] || service[realMethod];
+                const rawResult = await methodFunc(req);
+                const result = (0, graphql_1.postProcessGQLValue)(rawResult, outputTyping.output);
+                const grpcClientConfig = cfg.client;
+                const bufferFields = (0, utils_1.getKeys)(grpcClientConfig === null || grpcClientConfig === void 0 ? void 0 : grpcClientConfig.bufferFields);
+                if (result instanceof stream.Readable) {
+                    let operationStatus = { code: 0, message: '' };
+                    let aggregatedResponse = await new Promise((resolve, reject) => {
+                        let response = {};
+                        let combinedChunks = {};
+                        result.on('data', (chunk) => {
+                            const chunkObj = _.cloneDeep(chunk);
+                            if (!combinedChunks) {
+                                combinedChunks = chunk;
+                            }
+                            else {
+                                Object.assign(combinedChunks, chunk);
+                            }
+                            const existingBufferFields = _.intersection(Object.keys(chunk), bufferFields);
+                            for (let bufferField of existingBufferFields) {
+                                if (chunkObj[bufferField] && chunkObj[bufferField].value) {
+                                    if (!response[bufferField]) {
+                                        response[bufferField] = { value: [] };
+                                    }
+                                    if (response[bufferField] && response[bufferField].value && !_.isArray(response[bufferField].value)) {
+                                        response[bufferField].value = [];
+                                    }
+                                    let data = JSON.parse(chunkObj[bufferField].value.toString());
+                                    if (_.isArray(data)) {
+                                        for (let dataObj of data) {
+                                            response[bufferField].value.push(dataObj);
+                                        }
+                                    }
+                                    else {
+                                        response[bufferField].value.push(data);
+                                    }
+                                }
+                            }
+                        });
+                        result.on('error', (err) => {
+                            console.error(err);
+                            operationStatus.code = err.code ? err.code : 500;
+                            operationStatus.message = err.message;
+                        });
+                        result.on('end', () => {
+                            if (_.isEmpty(operationStatus.message)) {
+                                operationStatus.code = 200;
+                                operationStatus.message = 'success';
+                            }
+                            if (!_.isEmpty(response)) {
+                                resolve(response);
+                            }
+                            else if (!_.isEmpty(combinedChunks)) {
+                                resolve(combinedChunks);
+                            }
+                        });
+                    });
+                    return { details: aggregatedResponse, operationStatus };
+                }
+                if ('items' in result) {
+                    let items = (0, utils_1.decodeBufferFields)(result.items, bufferFields);
+                    return {
+                        details: {
+                            items: items,
+                            operationStatus: result.operationStatus // overall status
+                        },
+                    };
+                }
+                else {
+                    return {
+                        details: (0, utils_1.decodeBufferFields)([result], bufferFields)[0]
+                    };
+                }
+            }
+            catch (error) {
+                console.error(error);
+                return {
+                    details: {
+                        items: [],
+                        operationStatus: {
+                            code: error.code,
+                            message: error.message
+                        }
+                    }
+                };
+            }
+        };
+        return obj;
+    }, {});
+};
+exports.getGQLResolverFunctions = getGQLResolverFunctions;
+const namespaceResolverRegistry = new Map();
+const subscriptionResolvers = {};
+const registerResolverFunction = (namespace, name, func, mutation = false, subspace = undefined, service) => {
+    if (!namespaceResolverRegistry.has(namespace)) {
+        namespaceResolverRegistry.set(namespace, new Map());
+    }
+    if (!namespaceResolverRegistry.get(namespace).has(mutation)) {
+        namespaceResolverRegistry.get(namespace).set(mutation, new Map());
+    }
+    let space = namespaceResolverRegistry.get(namespace).get(mutation);
+    if (subspace) {
+        if (!space.has(subspace)) {
+            space.set(subspace, new Map());
+        }
+        space = space.get(subspace);
+    }
+    if (space.has(name)) {
+        if (subspace) {
+            throw new Error(`Namespace "${namespace}"."${subspace}" already contains a function: ${name} (mutation: ${mutation})`);
+        }
+        else {
+            throw new Error(`Namespace "${namespace}" already contains a function: ${name} (mutation: ${mutation})`);
+        }
+    }
+    if (service) {
+        const key = (namespace === null || namespace === void 0 ? void 0 : namespace.toLocaleLowerCase()) + '.' + (subspace === null || subspace === void 0 ? void 0 : subspace.toLocaleLowerCase()) + '.' + (name === null || name === void 0 ? void 0 : name.toLocaleLowerCase());
+        const value = service.method.find((m) => m.name === name);
+        if (key && (value === null || value === void 0 ? void 0 : value.inputType)) {
+            inputMethodType.set(key, value.inputType);
+        }
+    }
+    space.set(name, func);
+};
+exports.registerResolverFunction = registerResolverFunction;
+const generateResolver = (...namespaces) => {
+    const queryResolvers = {};
+    const mutationResolvers = {};
+    namespaces.forEach(ns => {
+        if (!namespaceResolverRegistry.has(ns)) {
+            throw new Error(`Namespace "${ns}" has no registered functions`);
+        }
+        if (namespaceResolverRegistry.get(ns).has(false)) {
+            const res = {};
+            namespaceResolverRegistry.get(ns).get(false).forEach((value, key) => {
+                if (value instanceof Map) {
+                    res[key] = Object.fromEntries(value);
+                }
+                else {
+                    res[key] = value;
+                }
+            });
+            queryResolvers[ns] = () => res;
+        }
+        if (namespaceResolverRegistry.get(ns).has(true)) {
+            const res = {};
+            namespaceResolverRegistry.get(ns).get(true).forEach((value, key) => {
+                if (value instanceof Map) {
+                    res[key] = Object.fromEntries(value);
+                }
+                else {
+                    res[key] = value;
+                }
+            });
+            mutationResolvers[ns] = () => res;
+        }
+    });
+    const resolvers = {};
+    if (Object.keys(queryResolvers).length > 0) {
+        resolvers.Query = queryResolvers;
+    }
+    if (Object.keys(mutationResolvers).length > 0) {
+        resolvers.Mutation = mutationResolvers;
+    }
+    if (Object.keys(subscriptionResolvers).length > 0) {
+        resolvers.Subscription = subscriptionResolvers;
+    }
+    return resolvers;
+};
+exports.generateResolver = generateResolver;
+const generateSubServiceResolvers = (subServices, config, namespace) => {
+    subServices.forEach((meta) => {
+        var _a;
+        meta.fileDescriptor.service.forEach(service => {
+            if (meta.options && meta.options.services && meta.options.services[service.name]) {
+                const subName = meta.options.services[service.name].options['service_name'];
+                const { mutations, queries } = (0, graphql_1.getWhitelistBlacklistConfig)(service, config, meta, subName);
+                const func = (0, exports.getGQLResolverFunctions)(service, namespace, subName || namespace, config);
+                Object.keys(func).forEach(k => {
+                    const regNamespace = config.root ? subName : namespace;
+                    const regSubspace = config.root ? undefined : subName;
+                    (0, exports.registerResolverFunction)(regNamespace, k, func[k], !queries.has(k) && mutations.has(k), regSubspace, service);
+                });
+            }
+        });
+        if (utils_1.useSubscriptions) {
+            Object.entries(((_a = meta.options) === null || _a === void 0 ? void 0 : _a.messages) || {}).forEach(([messageName, option]) => {
+                if (option.options && 'kafka_subscriber' in option.options) {
+                    const kafkaSubscriber = option.options.kafka_subscriber;
+                    const fieldName = namespace + (0, utils_1.capitalize)(kafkaSubscriber.plural);
+                    const baseMessageName = meta.fileDescriptor.package + '.' + messageName;
+                    const typing = (0, registry_1.getTyping)('.' + baseMessageName);
+                    if (typing) {
+                        subscriptionResolvers[fieldName] = {
+                            // resolve: (parent, args, context, info) => {
+                            //   const obj = parent[fieldName];
+                            //   let missing = false;
+                            //   for (const selection of info.operation.selectionSet.selections) {
+                            //     if ('name' in selection && !(selection.name.value in obj)) {
+                            //       missing = true;
+                            //       break;
+                            //     }
+                            //   }
+                            //   if (!missing) {
+                            //     return obj;
+                            //   }
+                            //   // TODO Implement user lookup
+                            //   return obj;
+                            // },
+                            subscribe: async (parent, args, context, info) => {
+                                const action = args.action || 'CREATED';
+                                let event = kafkaSubscriber.created;
+                                switch (action) {
+                                    case 'UPDATED':
+                                        event = kafkaSubscriber.updated;
+                                        break;
+                                    case 'DELETED':
+                                        event = kafkaSubscriber.deleted;
+                                        break;
+                                }
+                                const events = new kafka_client_1.Events({
+                                    provider: 'kafka',
+                                    kafka: {
+                                        ...context.kafkaConfig
+                                    },
+                                    [event]: {
+                                        messageObject: baseMessageName
+                                    }
+                                }, context.logger);
+                                await events.start();
+                                const commandTopic = await events.topic(kafkaSubscriber.topic);
+                                let deferred = null;
+                                const pending = [];
+                                commandTopic.on(event, (message) => {
+                                    pending.push({ id: message.id });
+                                    deferred === null || deferred === void 0 ? void 0 : deferred.resolve(false);
+                                });
+                                return {
+                                    [Symbol.asyncIterator]() {
+                                        return this;
+                                    },
+                                    async next() {
+                                        if (pending.length) {
+                                            return { value: { [fieldName]: pending.shift() } };
+                                        }
+                                        return (await new Promise((resolve, reject) => (deferred = { resolve, reject })))
+                                            ? { done: true, value: undefined }
+                                            : { value: { [fieldName]: pending.shift() } };
+                                    },
+                                    async throw(err) {
+                                        throw err;
+                                    },
+                                    async return() {
+                                        await events.stop();
+                                        return { done: true, value: undefined };
+                                    },
+                                };
+                            }
+                        };
+                    }
+                }
+            });
+        }
+    });
+    if (config.root) {
+        return (0, exports.generateResolver)(...(0, array_prototype_flat_1.default)(subServices.map(meta => {
+            return meta.fileDescriptor.service.map(service => {
+                if (meta.options && meta.options.services && meta.options.services[service.name]) {
+                    return meta.options.services[service.name].options['service_name'];
+                }
+                return null;
+            }).filter(s => s !== null);
+        })));
+    }
+    const finalResolver = (0, exports.generateResolver)(namespace);
+    subServices.forEach((meta) => {
+        meta.fileDescriptor.service.forEach(service => {
+            if (meta.options && meta.options.messages) {
+                for (const key of Object.keys(meta.options.messages)) {
+                    const message = meta.options.messages[key];
+                    if (message.fields) {
+                        const typing = (0, registry_1.getTyping)('.' + meta.fileDescriptor.package + '.' + key);
+                        if (typing) {
+                            const result = {};
+                            for (const fieldName of Object.keys(message.fields)) {
+                                const field = message.fields[fieldName];
+                                if ('resolver' in field) {
+                                    const fieldJsonName = (0, utils_1.snakeToCamel)(fieldName);
+                                    const resolver = field['resolver'];
+                                    // TODO This creates an N+1 problem!
+                                    result[resolver.fieldName] = async (parent, _, ctx) => {
+                                        if (!parent || !(fieldJsonName in parent) || parent[fieldJsonName] === undefined) {
+                                            return undefined;
+                                        }
+                                        const client = ctx[resolver.targetService].client;
+                                        const service = client[resolver.targetSubService];
+                                        const idList = Array.isArray(parent[fieldJsonName]) ? parent[fieldJsonName] : [parent[fieldJsonName]];
+                                        // TODO Support custom input messages
+                                        const req = rc_grpc_clients_1.ReadRequest.fromPartial({
+                                            filters: [{
+                                                    filter: idList.map(id => ({
+                                                        field: 'id',
+                                                        operation: resource_base_1.Filter_Operation.eq,
+                                                        value: id,
+                                                        type: resource_base_1.Filter_ValueType.STRING
+                                                    })),
+                                                    operator: resource_base_1.FilterOp_Operator.or
+                                                }]
+                                        });
+                                        req.subject = (0, registry_1.getTyping)(types_1.authSubjectType).processor.fromPartial({});
+                                        const authToken = ctx.request.req.headers['authorization'];
+                                        if (authToken && authToken.startsWith('Bearer ')) {
+                                            req.subject.token = authToken.split(' ')[1];
+                                        }
+                                        const methodFunc = service[(0, utils_1.camelCase)(resolver.targetMethod)] || service[resolver.targetMethod];
+                                        const result = await methodFunc(req);
+                                        if (result && result.items && result.items.length) {
+                                            if (Array.isArray(parent[fieldJsonName])) {
+                                                return result.items.map((item) => item.payload);
+                                            }
+                                            else {
+                                                return result.items[0].payload;
+                                            }
+                                        }
+                                        return undefined;
+                                    };
+                                }
+                            }
+                            finalResolver[typing.output.name] = result;
+                        }
+                    }
+                }
+            }
+        });
+    });
+    return finalResolver;
+};
+exports.generateSubServiceResolvers = generateSubServiceResolvers;

package/dist/gql/protos/schema.d.ts

@@ -0,0 +1,14 @@
+import { MethodDescriptorProto, ServiceDescriptorProto } from 'ts-proto-descriptors';
+import { ProtoMetadata, ServiceConfig, SubSpaceServiceConfig } from './types';
+import { GraphQLSchema, ThunkObjMap } from 'graphql';
+import { GraphQLFieldConfig, GraphQLFieldConfigMap } from 'graphql/type/definition';
+export declare const getGQLSchema: <TSource, TContext>(method: MethodDescriptorProto) => GraphQLFieldConfig<TSource, TContext, any>;
+export declare const getGQLSchemas: <TSource, TContext>(service: ServiceDescriptorProto) => GraphQLFieldConfigMap<TSource, TContext>;
+declare type SchemaBaseOrSub = ThunkObjMap<GraphQLFieldConfig<any, any>> | Map<string, ThunkObjMap<GraphQLFieldConfig<any, any>>>;
+export declare const registerResolverSchema: (namespace: string, name: string, schema: SchemaBaseOrSub, mutation: boolean | undefined, subspace: string | undefined, config: ServiceConfig) => void;
+export declare const generateSchema: (setup: {
+    prefix: string;
+    namespace: string;
+}[]) => GraphQLSchema;
+export declare const generateSubServiceSchemas: (subServices: ProtoMetadata[], config: SubSpaceServiceConfig, namespace: string, prefix: string) => GraphQLSchema;
+export {};

package/dist/gql/protos/schema.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSubServiceSchemas = exports.generateSchema = exports.registerResolverSchema = exports.getGQLSchemas = exports.getGQLSchema = void 0;
+const graphql_1 = require("graphql");
+const array_prototype_flat_1 = require("array.prototype.flat");
+const graphql_2 = require("./graphql");
+const utils_1 = require("./utils");
+const registry_1 = require("./registry");
+const typeCache = new Map();
+const subscriptionAction = new graphql_1.GraphQLEnumType({
+    name: 'SubscriptionAction',
+    values: {
+        CREATED: { value: 'CREATED' },
+        UPDATED: { value: 'UPDATED' },
+        DELETED: { value: 'DELETED' }
+    }
+});
+const subscriptionInput = {
+    action: {
+        type: subscriptionAction
+    }
+};
+const subscriptionOutput = new graphql_1.GraphQLObjectType({
+    name: 'SubscriptionOutput',
+    fields: {
+        id: {
+            type: graphql_1.GraphQLString
+        }
+    }
+});
+const getGQLSchema = (method) => {
+    const fields = {};
+    const responseTyping = (0, registry_1.getTyping)(method.outputType);
+    if (!responseTyping) {
+        throw Error('Method doesn\'t have registered typings: ' + method.outputType);
+    }
+    if (method.outputType !== '.google.protobuf.Empty') {
+        fields['details'] = {
+            type: responseTyping.output,
+        };
+    }
+    const outName = 'Proto' + (0, utils_1.capitalizeProtoName)(method.outputType);
+    let out = typeCache.get(outName);
+    if (!out) {
+        out = new graphql_1.GraphQLObjectType({
+            name: outName,
+            fields,
+        });
+        typeCache.set(outName, out);
+    }
+    const typing = (0, registry_1.getTyping)(method.inputType);
+    if (!typing) {
+        throw Error('Method doesn\'t have registered typings: ' + method.inputType);
+    }
+    return {
+        type: out,
+        args: method.inputType === '.google.protobuf.Empty' ? undefined : {
+            input: {
+                type: new graphql_1.GraphQLNonNull(typing.input)
+            }
+        }
+    };
+};
+exports.getGQLSchema = getGQLSchema;
+const getGQLSchemas = (service) => {
+    var _a;
+    return (_a = service.method) === null || _a === void 0 ? void 0 : _a.reduce((obj, method) => {
+        obj[method.name] = (0, exports.getGQLSchema)(method);
+        return obj;
+    }, {});
+};
+exports.getGQLSchemas = getGQLSchemas;
+const namespaceResolverSchemaRegistry = new Map();
+const subscriptionFields = {};
+const registerResolverSchema = (namespace, name, schema, mutation = false, subspace = undefined, config) => {
+    if (!namespaceResolverSchemaRegistry.has(namespace)) {
+        namespaceResolverSchemaRegistry.set(namespace, new Map());
+    }
+    if (subspace && config[subspace]) {
+        const blacklistMethods = config[subspace].methods.blacklist;
+        if (blacklistMethods.includes(name)) {
+            return;
+        }
+    }
+    if (!namespaceResolverSchemaRegistry.get(namespace).has(mutation)) {
+        namespaceResolverSchemaRegistry.get(namespace).set(mutation, new Map());
+    }
+    let space = namespaceResolverSchemaRegistry.get(namespace).get(mutation);
+    if (subspace) {
+        if (!space.has(subspace)) {
+            space.set(subspace, new Map());
+        }
+        space = space.get(subspace);
+    }
+    if (space.has(name)) {
+        if (subspace) {
+            throw new Error(`Namespace "${namespace}"."${subspace}" already contains a schema: ${name} (mutation: ${mutation})`);
+        }
+        else {
+            throw new Error(`Namespace "${namespace}" already contains a schema: ${name} (mutation: ${mutation})`);
+        }
+    }
+    // register create, update and upsert with Mutate
+    if (graphql_2.Mutate.indexOf(name) > -1) {
+        name = 'Mutate';
+    }
+    space.set(name, schema);
+};
+exports.registerResolverSchema = registerResolverSchema;
+const generateSchema = (setup) => {
+    const queryFields = {};
+    const mutationFields = {};
+    setup.forEach(s => {
+        if (!namespaceResolverSchemaRegistry.has(s.namespace)) {
+            throw new Error(`Namespace "${s.namespace}" has no registered schemas`);
+        }
+        if (namespaceResolverSchemaRegistry.get(s.namespace).has(false)) {
+            const fields = {};
+            namespaceResolverSchemaRegistry.get(s.namespace).get(false).forEach((value, key) => {
+                if (value instanceof Map) {
+                    const capitalName = (0, utils_1.capitalizeProtoName)(key);
+                    fields[key] = {
+                        type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
+                            name: s.prefix + capitalName + 'Query',
+                            fields: Object.fromEntries(value),
+                        }))
+                    };
+                }
+                else {
+                    fields[key] = value;
+                }
+            });
+            queryFields[s.namespace] = {
+                type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
+                    name: s.prefix + 'Query',
+                    fields
+                }))
+            };
+        }
+        if (namespaceResolverSchemaRegistry.get(s.namespace).has(true)) {
+            const fields = {};
+            namespaceResolverSchemaRegistry.get(s.namespace).get(true).forEach((value, key) => {
+                if (value instanceof Map) {
+                    const capitalName = (0, utils_1.capitalizeProtoName)(key);
+                    fields[key] = {
+                        type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
+                            name: s.prefix + capitalName + 'Mutation',
+                            fields: Object.fromEntries(value),
+                        }))
+                    };
+                }
+                else {
+                    fields[key] = value;
+                }
+            });
+            mutationFields[s.namespace] = {
+                type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
+                    name: s.prefix + 'Mutation',
+                    fields
+                }))
+            };
+        }
+    });
+    const config = {};
+    if (Object.keys(queryFields).length > 0) {
+        config.query = new graphql_1.GraphQLObjectType({
+            name: 'Query',
+            fields: queryFields
+        });
+    }
+    if (Object.keys(mutationFields).length > 0) {
+        config.mutation = new graphql_1.GraphQLObjectType({
+            name: 'Mutation',
+            fields: mutationFields
+        });
+    }
+    if (Object.keys(subscriptionFields).length > 0) {
+        config.subscription = new graphql_1.GraphQLObjectType({
+            name: 'Subscription',
+            fields: subscriptionFields
+        });
+    }
+    return new graphql_1.GraphQLSchema({
+        ...config,
+    });
+};
+exports.generateSchema = generateSchema;
+const generateSubServiceSchemas = (subServices, config, namespace, prefix) => {
+    subServices.forEach((meta) => {
+        var _a;
+        meta.fileDescriptor.service.forEach(service => {
+            if (meta.options && meta.options.services && meta.options.services[service.name]) {
+                const subName = meta.options.services[service.name].options['service_name'];
+                const { mutations, queries } = (0, graphql_2.getWhitelistBlacklistConfig)(service, config, meta, subName);
+                const schemas = (0, exports.getGQLSchemas)(service);
+                Object.keys(schemas).forEach(key => {
+                    (0, exports.registerResolverSchema)(config.root ? subName : namespace, key, schemas[key], !queries.has(key) && mutations.has(key), config.root ? undefined : subName, config);
+                });
+            }
+        });
+        if (utils_1.useSubscriptions) {
+            Object.entries(((_a = meta.options) === null || _a === void 0 ? void 0 : _a.messages) || {}).forEach(([messageName, option]) => {
+                if (option.options && 'kafka_subscriber' in option.options) {
+                    const fieldName = namespace + (0, utils_1.capitalize)(option.options.kafka_subscriber.plural);
+                    const typing = (0, registry_1.getTyping)('.' + meta.fileDescriptor.package + '.' + messageName);
+                    if (typing) {
+                        subscriptionFields[fieldName] = {
+                            // TODO Implement user lookup
+                            // type: typing?.output!,
+                            type: subscriptionOutput,
+                            args: subscriptionInput
+                        };
+                    }
+                }
+            });
+        }
+    });
+    if (config.root) {
+        return (0, exports.generateSchema)((0, array_prototype_flat_1.default)(subServices.map(meta => {
+            return meta.fileDescriptor.service.map(service => {
+                if (meta.options && meta.options.services && meta.options.services[service.name]) {
+                    const subName = meta.options.services[service.name].options['service_name'];
+                    return {
+                        prefix: prefix + subName.substring(0, 1).toUpperCase() + subName.substring(1).toLowerCase(),
+                        namespace: subName
+                    };
+                }
+                return null;
+            }).filter(s => s !== null);
+        })));
+    }
+    return (0, exports.generateSchema)([{ prefix, namespace }]);
+};
+exports.generateSubServiceSchemas = generateSubServiceSchemas;