@restorecommerce/facade 1.0.1 → 1.1.1

package/dist/gql/protos/graphql.js

@@ -1,65 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.camelCase = exports.generateSubServiceResolvers = exports.generateSubServiceSchemas = exports.getAndGenerateResolvers = exports.getAndGenerateSchema = exports.getWhitelistBlacklistConfig = exports.generateSchema = exports.registerResolverSchema = exports.generateResolver = exports.registerResolverFunction = exports.getGQLResolverFunctions = exports.postProcessGQLValue = exports.preprocessGQLInput = exports.getGQLSchemas = exports.getGQLSchema = void 0;
+exports.getWhitelistBlacklistConfig = exports.postProcessGQLValue = exports.preprocessGQLInput = exports.Mutate = void 0;
 const graphql_1 = require("graphql");
 const definition_1 = require("graphql/type/definition");
-const types_1 = require("./types");
-const registry_1 = require("./registry");
-const utils_1 = require("./utils");
-const stream = require("stream");
-const _ = require("lodash");
-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 array_prototype_flat_1 = require("array.prototype.flat");
-const typeCache = new Map();
-const Mutate = ['Create', 'Update', 'Upsert'];
-const inputMethodType = new Map();
-const getGQLSchema = (method) => {
-    const fields = {
-    // operationStatus: {
-    //   type: new GraphQLNonNull(OperationStatusType),
-    // },
-    };
-    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;
+exports.Mutate = ['Create', 'Update', 'Upsert'];
 const preprocessGQLInput = async (data, model) => {
     if (model instanceof definition_1.GraphQLEnumType) {
         return data;
@@ -153,353 +97,6 @@ const postProcessGQLValue = (data, model) => {
     return data;
 };
 exports.postProcessGQLValue = postProcessGQLValue;
-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 (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, exports.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 (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[camelCase(realMethod)] || service[realMethod];
-                const rawResult = await methodFunc(req);
-                const result = (0, exports.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 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;
-    }
-    return resolvers;
-};
-exports.generateResolver = generateResolver;
-const namespaceResolverSchemaRegistry = new Map();
-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 (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
-        });
-    }
-    return new graphql_1.GraphQLSchema(config);
-};
-exports.generateSchema = generateSchema;
 const getWhitelistBlacklistConfig = (metaService, config, meta, entity) => {
     var _a, _b, _c, _d;
     const queryList = [];
@@ -557,7 +154,7 @@ const getWhitelistBlacklistConfig = (metaService, config, meta, entity) => {
             }
         }
     }
-    if (Mutate.findIndex(val => mut.has(val)) > -1) {
+    if (exports.Mutate.findIndex(val => mut.has(val)) > -1) {
         mut.add('Mutate');
     }
     return {
@@ -566,161 +163,3 @@ const getWhitelistBlacklistConfig = (metaService, config, meta, entity) => {
     };
 };
 exports.getWhitelistBlacklistConfig = getWhitelistBlacklistConfig;
-const getAndGenerateSchema = (service, namespace, prefix, cfg, meta) => {
-    const { mutations, queries } = (0, exports.getWhitelistBlacklistConfig)(service, cfg, meta, service.name);
-    const schemas = (0, exports.getGQLSchemas)(service);
-    Object.keys(schemas).forEach(key => {
-        (0, exports.registerResolverSchema)(namespace, key, schemas[key], !queries.has(key) && mutations.has(key), undefined, cfg);
-    });
-    return (0, exports.generateSchema)([{ prefix, namespace }]);
-};
-exports.getAndGenerateSchema = getAndGenerateSchema;
-const getAndGenerateResolvers = (service, namespace, cfg, meta, subspace = undefined, serviceKey = undefined) => {
-    const { mutations, queries } = (0, exports.getWhitelistBlacklistConfig)(service, cfg, meta, service.name);
-    const func = (0, exports.getGQLResolverFunctions)(service, namespace, serviceKey || subspace || namespace, cfg);
-    Object.keys(func).forEach(k => {
-        (0, exports.registerResolverFunction)(namespace, k, func[k], !queries.has(k) && mutations.has(k), subspace, service);
-    });
-    return (0, exports.generateResolver)(namespace);
-};
-exports.getAndGenerateResolvers = getAndGenerateResolvers;
-const generateSubServiceSchemas = (subServices, config, namespace, prefix) => {
-    subServices.forEach((meta) => {
-        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, exports.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 (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.substr(0, 1).toUpperCase() + subName.substr(1).toLowerCase(),
-                        namespace: subName
-                    };
-                }
-                return null;
-            }).filter(s => s !== null);
-        })));
-    }
-    return (0, exports.generateSchema)([{ prefix, namespace }]);
-};
-exports.generateSubServiceSchemas = generateSubServiceSchemas;
-const generateSubServiceResolvers = (subServices, config, namespace) => {
-    subServices.forEach((meta) => {
-        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, exports.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 (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 = 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[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;
-const snakeToCamel = (s) => {
-    return s
-        .split('_')
-        .map((word, i) => {
-        if (i === 0) {
-            // if first symbol is "_" then skip it
-            return word ? word[0] + word.substring(1).toLowerCase() : '';
-        }
-        else {
-            return capitalize(word.toLowerCase());
-        }
-    })
-        .join('');
-};
-const capitalize = (s) => {
-    return s.substring(0, 1).toUpperCase() + s.substring(1);
-};
-function camelCase(s) {
-    return s.substring(0, 1).toLowerCase() + s.substring(1);
-}
-exports.camelCase = camelCase;

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

@@ -1,3 +1,6 @@
 export * from './types';
 export * from './registry';
 export * from './graphql';
+export * from './federation';
+export * from './resolvers';
+export * from './schema';

package/dist/gql/protos/index.js

@@ -17,3 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
 __exportStar(require("./registry"), exports);
 __exportStar(require("./graphql"), exports);
+__exportStar(require("./federation"), exports);
+__exportStar(require("./resolvers"), exports);
+__exportStar(require("./schema"), exports);

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

@@ -16,8 +16,8 @@ export declare const registerPackagesRecursive: (...protoMetadata: ProtoMetadata
 export declare const getRegisteredEnumTypings: () => string[];
 export declare const getNameSpaceTypeName: (typeName: string) => string | undefined;
 export declare const recursiveEnumCheck: (typeName: string, enumMap: Map<string, string>, prevFieldName: string, traversedFields: string[]) => Map<string, string>;
-export declare const registerTyping: (protoPackage: string, message: DescriptorProto, methodDef: MethodDescriptorProto[], opts?: Omit<Readonly<GraphQLObjectTypeConfig<any, any>>, "fields"> | undefined, inputOpts?: Omit<Readonly<GraphQLInputObjectTypeConfig>, "fields"> | undefined, messageOptions?: ProtoMetaMessageOptions | undefined) => void;
+export declare const registerTyping: (protoPackage: string, message: DescriptorProto, methodDef: MethodDescriptorProto[], opts?: Omit<Readonly<GraphQLObjectTypeConfig<any, any>>, 'fields'>, inputOpts?: Omit<Readonly<GraphQLInputObjectTypeConfig>, 'fields'>, messageOptions?: ProtoMetaMessageOptions) => void;
 export declare const registerEnumTyping: <T = {
     [key: string]: any;
-}>(protoPackage: string, message: EnumDescriptorProto, opts?: Omit<Readonly<GraphQLEnumTypeConfig>, "values"> | undefined) => void;
+}>(protoPackage: string, message: EnumDescriptorProto, opts?: Omit<Readonly<GraphQLEnumTypeConfig>, 'values'>) => void;
 export declare const getTyping: (type: string) => TypingData | undefined;

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

@@ -0,0 +1,9 @@
+import { ProtoMetadata, ServiceClient, ServiceConfig, SubSpaceServiceConfig } from './types';
+import { ServiceDescriptorProto } from 'ts-proto-descriptors';
+import { GraphQLResolveInfo } from 'graphql';
+export declare type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
+export declare type SubscribeResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncGenerator<TResult>;
+export declare const getGQLResolverFunctions: <T extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, T>, SRV = any, R = ResolverFn<any, any, ServiceClient<CTX, keyof CTX, T>, any>, B extends keyof T = any, NS extends keyof CTX = any>(service: ServiceDescriptorProto, key: NS, serviceKey: B, cfg: ServiceConfig) => { [key in keyof SRV]: R; };
+export declare const registerResolverFunction: <T extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, T>>(namespace: string, name: string, func: ResolverFn<any, any, ServiceClient<CTX, keyof CTX, T>, any>, mutation?: boolean, subspace?: string | undefined, service?: ServiceDescriptorProto) => void;
+export declare const generateResolver: (...namespaces: string[]) => any;
+export declare const generateSubServiceResolvers: <T, M extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, M>>(subServices: ProtoMetadata[], config: SubSpaceServiceConfig, namespace: string) => T;