@restorecommerce/facade 0.4.1 → 0.5.0

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [0.5.0](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.4.1...@restorecommerce/facade@0.5.0) (2022-06-10)
+
+
+### Bug Fixes
+
+* **facade:** fix building tests ([82485bf](https://github.com/restorecommerce/libs/commit/82485bfb7c6e19e0bc56f665538bf65d427a1178))
+* fix merge issues ([cc37d83](https://github.com/restorecommerce/libs/commit/cc37d8356df3b494af8c6af9e39304a49073301c))
+
+
+### Features
+
+* **facade:** support nested resolvers from proto options ([d319a5b](https://github.com/restorecommerce/libs/commit/d319a5bbf0066d9200d1c6bf38303461496bfa3a))
+
+
+
+
+
 ## [0.4.1](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.4.0...@restorecommerce/facade@0.4.1) (2022-05-16)
 
 

package/codegen/index.d.ts

@@ -0,0 +1,12 @@
+export interface GenerateSchemaTypingsArgs {
+    schema: any;
+    outputFile: string;
+    typescript?: {
+        [key: string]: any;
+    };
+    typescriptResolvers?: {
+        contextType?: string;
+        [key: string]: any;
+    };
+}
+export declare function generateSchemaTypings({ schema, outputFile, typescript, typescriptResolvers }: GenerateSchemaTypingsArgs): Promise<void>;

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

@@ -1,7 +1,7 @@
-import { GraphQLInputField, GraphQLOutputType, GraphQLResolveInfo, GraphQLSchema, ThunkObjMap } from "graphql";
-import { GraphQLEnumType, GraphQLFieldConfig, GraphQLFieldConfigMap, GraphQLInputObjectType, GraphQLInputType } from "graphql/type/definition";
-import { ServiceConfig, SubService, SubSpaceServiceConfig } from "./types";
-import { MethodDescriptorProto, ServiceDescriptorProto } from "ts-proto-descriptors";
+import { GraphQLInputField, GraphQLOutputType, GraphQLResolveInfo, GraphQLSchema, ThunkObjMap } from 'graphql';
+import { GraphQLEnumType, GraphQLFieldConfig, GraphQLFieldConfigMap, GraphQLInputObjectType, GraphQLInputType } from 'graphql/type/definition';
+import { ProtoMetadata, ServiceConfig, SubSpaceServiceConfig } from './types';
+import { MethodDescriptorProto, ServiceDescriptorProto } from 'ts-proto-descriptors';
 export declare const getGQLSchema: <TSource, TContext>(method: MethodDescriptorProto) => GraphQLFieldConfig<TSource, TContext, any>;
 export declare const getGQLSchemas: <TSource, TContext>(service: ServiceDescriptorProto) => GraphQLFieldConfigMap<TSource, TContext>;
 export declare const preprocessGQLInput: (data: any, model: GraphQLInputObjectType | GraphQLEnumType | GraphQLInputField | GraphQLInputType) => Promise<any>;
@@ -21,12 +21,12 @@ export declare const generateSchema: (setup: {
     prefix: string;
     namespace: string;
 }[]) => GraphQLSchema;
-export declare const getWhitelistBlacklistConfig: (metaService: ServiceDescriptorProto, queries: string[], config: ServiceConfig, entity: string) => {
+export declare const getWhitelistBlacklistConfig: (metaService: ServiceDescriptorProto, config: ServiceConfig, meta: ProtoMetadata, entity: string) => {
     queries: Set<string>;
     mutations: Set<string>;
 };
-export declare const getAndGenerateSchema: <TSource, TContext>(service: ServiceDescriptorProto, namespace: string, prefix: string, cfg: ServiceConfig, queryList: string[]) => GraphQLSchema;
-export declare const getAndGenerateResolvers: <T extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, T>, SRV = any, R = ResolverFn<any, any, ServiceClient<CTX, keyof CTX, T>, any>, NS extends keyof CTX = any>(service: ServiceDescriptorProto, namespace: NS, cfg: ServiceConfig, queryList: string[], subspace?: string | undefined, serviceKey?: string | undefined) => { [key in keyof SRV]: R; };
-export declare const generateSubServiceSchemas: (subServices: SubService[], config: SubSpaceServiceConfig, namespace: string, prefix: string) => GraphQLSchema;
-export declare const generateSubServiceResolvers: <T, M extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, M>>(subServices: SubService[], config: SubSpaceServiceConfig, namespace: string) => T;
+export declare const getAndGenerateSchema: <TSource, TContext>(service: ServiceDescriptorProto, namespace: string, prefix: string, cfg: ServiceConfig, meta: ProtoMetadata) => GraphQLSchema;
+export declare const getAndGenerateResolvers: <T extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, T>, SRV = any, R = ResolverFn<any, any, ServiceClient<CTX, keyof CTX, T>, any>, NS extends keyof CTX = any>(service: ServiceDescriptorProto, namespace: NS, cfg: ServiceConfig, meta: ProtoMetadata, subspace?: string | undefined, serviceKey?: string | undefined) => { [key in keyof SRV]: R; };
+export declare const generateSubServiceSchemas: (subServices: ProtoMetadata[], config: SubSpaceServiceConfig, namespace: string, prefix: string) => GraphQLSchema;
+export declare const generateSubServiceResolvers: <T, M extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, M>>(subServices: ProtoMetadata[], config: SubSpaceServiceConfig, namespace: string) => T;
 export {};

package/dist/gql/protos/graphql.js

@@ -8,6 +8,9 @@ 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();
@@ -19,14 +22,14 @@ const getGQLSchema = (method) => {
     };
     const responseTyping = (0, registry_1.getTyping)(method.outputType);
     if (!responseTyping) {
-        throw Error("Method doesn't have registered typings: " + method.outputType);
+        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);
+    const outName = 'Proto' + (0, utils_1.capitalizeProtoName)(method.outputType);
     let out = typeCache.get(outName);
     if (!out) {
         out = new graphql_1.GraphQLObjectType({
@@ -37,7 +40,7 @@ const getGQLSchema = (method) => {
     }
     const typing = (0, registry_1.getTyping)(method.inputType);
     if (!typing) {
-        throw Error("Method doesn't have registered typings: " + method.inputType);
+        throw Error('Method doesn\'t have registered typings: ' + method.inputType);
     }
     return {
         type: out,
@@ -100,7 +103,7 @@ const preprocessGQLInput = async (data, model) => {
     }
     if (model instanceof definition_1.GraphQLScalarType) {
         switch (model.name) {
-            case "Upload":
+            case 'Upload':
                 if (typeof data !== 'object') {
                     return Buffer.from(data.toString(), 'utf8');
                 }
@@ -496,10 +499,19 @@ const generateSchema = (setup) => {
     return new graphql_1.GraphQLSchema(config);
 };
 exports.generateSchema = generateSchema;
-const getWhitelistBlacklistConfig = (metaService, queries, config, entity) => {
+const getWhitelistBlacklistConfig = (metaService, config, meta, entity) => {
     var _a, _b, _c, _d;
-    const mut = new Set(metaService.method.map(m => m.name).filter(key => queries.indexOf(key) < 0));
-    const que = new Set(metaService.method.map(m => m.name).filter(key => queries.indexOf(key) >= 0));
+    const queryList = [];
+    if (meta.options && meta.options.services && meta.options.services[metaService.name] && meta.options.services[metaService.name].methods) {
+        const methods = meta.options.services[metaService.name].methods;
+        for (const key of Object.keys(methods)) {
+            if ('is_query' in methods[key] && methods[key]['is_query']) {
+                queryList.push(key);
+            }
+        }
+    }
+    const mut = new Set(metaService.method.map(m => m.name).filter(key => queryList.indexOf(key) < 0));
+    const que = new Set(metaService.method.map(m => m.name).filter(key => queryList.indexOf(key) >= 0));
     if (config[entity]) {
         if ((_b = (_a = config[entity]) === null || _a === void 0 ? void 0 : _a.methods) === null || _b === void 0 ? void 0 : _b.whitelist) {
             const whitelist = new Set(config[entity].methods.whitelist);
@@ -553,8 +565,8 @@ const getWhitelistBlacklistConfig = (metaService, queries, config, entity) => {
     };
 };
 exports.getWhitelistBlacklistConfig = getWhitelistBlacklistConfig;
-const getAndGenerateSchema = (service, namespace, prefix, cfg, queryList) => {
-    const { mutations, queries } = (0, exports.getWhitelistBlacklistConfig)(service, queryList, cfg, service.name);
+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);
@@ -562,8 +574,8 @@ const getAndGenerateSchema = (service, namespace, prefix, cfg, queryList) => {
     return (0, exports.generateSchema)([{ prefix, namespace }]);
 };
 exports.getAndGenerateSchema = getAndGenerateSchema;
-const getAndGenerateResolvers = (service, namespace, cfg, queryList, subspace = undefined, serviceKey = undefined) => {
-    const { mutations, queries } = (0, exports.getWhitelistBlacklistConfig)(service, queryList, cfg, service.name);
+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);
@@ -572,35 +584,137 @@ const getAndGenerateResolvers = (service, namespace, cfg, queryList, subspace =
 };
 exports.getAndGenerateResolvers = getAndGenerateResolvers;
 const generateSubServiceSchemas = (subServices, config, namespace, prefix) => {
-    subServices.forEach((sub) => {
-        const { mutations, queries } = (0, exports.getWhitelistBlacklistConfig)(sub.service, sub.queries, config, sub.name);
-        const schemas = (0, exports.getGQLSchemas)(sub.service);
-        Object.keys(schemas).forEach(key => {
-            (0, exports.registerResolverSchema)(config.root ? sub.name : namespace, key, schemas[key], !queries.has(key) && mutations.has(key), config.root ? undefined : sub.name, config);
+    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)(subServices.map(srv => ({
-            prefix: prefix + srv.name.substr(0, 1).toUpperCase() + srv.name.substr(1).toLowerCase(),
-            namespace: srv.name
+        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((sub) => {
-        const { mutations, queries } = (0, exports.getWhitelistBlacklistConfig)(sub.service, sub.queries, config, sub.name);
-        const func = (0, exports.getGQLResolverFunctions)(sub.service, namespace, sub.name || namespace, config);
-        Object.keys(func).forEach(k => {
-            const regNamespace = config.root ? sub.name : namespace;
-            const regSubspace = config.root ? undefined : sub.name;
-            (0, exports.registerResolverFunction)(regNamespace, k, func[k], !queries.has(k) && mutations.has(k), regSubspace, sub.service);
+    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)(...subServices.map(srv => srv.name));
+        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);
+        })));
     }
-    return (0, exports.generateResolver)(namespace);
+    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 result = await service[resolver.targetMethod](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);
+};

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

@@ -1,6 +1,6 @@
 import { GraphQLEnumTypeConfig, GraphQLInputObjectTypeConfig, GraphQLObjectType, GraphQLObjectTypeConfig } from "graphql";
 import { GraphQLEnumType, GraphQLInputObjectType, GraphQLScalarType } from "graphql/type/definition";
-import { ProtoMetadata } from "./types";
+import { ProtoMetadata, ProtoMetaMessageOptions } from './types';
 import { DescriptorProto, EnumDescriptorProto, MethodDescriptorProto } from "ts-proto-descriptors";
 export interface TypingData {
     output: GraphQLObjectType | GraphQLEnumType | GraphQLScalarType;
@@ -16,7 +16,7 @@ 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) => void;
+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 registerEnumTyping: <T = {
     [key: string]: any;
 }>(protoPackage: string, message: EnumDescriptorProto, opts?: Omit<Readonly<GraphQLEnumTypeConfig>, "values"> | undefined) => void;

package/dist/gql/protos/registry.js

@@ -35,15 +35,15 @@ exports.IGoogleProtobufAny = new definition_1.GraphQLInputObjectType({
 });
 const DateTime = new definition_1.GraphQLScalarType({
     name: 'DateTime',
-    description: `A date-time string at UTC, such as 2007-12-03T10:15:30Z, 
-                compliant with the date-time format outlined in section 5.6 of 
+    description: `A date-time string at UTC, such as 2007-12-03T10:15:30Z,
+                compliant with the date-time format outlined in section 5.6 of
                 the RFC 3339 profile of the ISO 8601 standard for representation
                 of dates and times using the Gregorian calendar.`,
 });
 const IDateTime = new definition_1.GraphQLScalarType({
     name: 'IDateTime',
-    description: `A date-time string at UTC, such as 2007-12-03T10:15:30Z, 
-                compliant with the date-time format outlined in section 5.6 of 
+    description: `A date-time string at UTC, such as 2007-12-03T10:15:30Z,
+                compliant with the date-time format outlined in section 5.6 of
                 the RFC 3339 profile of the ISO 8601 standard for representation
                 of dates and times using the Gregorian calendar.`,
 });
@@ -68,7 +68,7 @@ const registerPackagesRecursive = (...protoMetadata) => {
     protoMetadata.forEach(meta => {
         var _a, _b;
         meta.dependencies && (0, exports.registerPackagesRecursive)(...meta.dependencies);
-        meta.fileDescriptor.messageType && registerMessageTypesRecursive(meta.fileDescriptor.package, (_a = meta.fileDescriptor.service[0]) === null || _a === void 0 ? void 0 : _a.method, ...meta.fileDescriptor.messageType);
+        meta.fileDescriptor.messageType && registerMessageTypesRecursive(meta.fileDescriptor.package, (_a = meta.fileDescriptor.service[0]) === null || _a === void 0 ? void 0 : _a.method, meta.options, ...meta.fileDescriptor.messageType);
         (_b = meta.fileDescriptor.enumType) === null || _b === void 0 ? void 0 : _b.forEach((m) => {
             (0, exports.registerEnumTyping)(meta.fileDescriptor.package, m);
         });
@@ -126,16 +126,16 @@ const recursiveEnumCheck = (typeName, enumMap, prevFieldName, traversedFields) =
     return enumMap;
 };
 exports.recursiveEnumCheck = recursiveEnumCheck;
-const registerMessageTypesRecursive = (packageName, methodDef, ...types) => {
+const registerMessageTypesRecursive = (packageName, methodDef, options, ...types) => {
     types.forEach(m => {
-        (0, exports.registerTyping)(packageName, m, methodDef);
+        (0, exports.registerTyping)(packageName, m, methodDef, undefined, undefined, options && options.messages && options.messages[m.name]);
         if (m.enumType) {
             m.enumType.forEach((enumType) => {
                 (0, exports.registerEnumTyping)(packageName + '.' + m.name, enumType);
             });
         }
         if (m.nestedType) {
-            registerMessageTypesRecursive(packageName + '.' + m.name, methodDef, ...m.nestedType);
+            registerMessageTypesRecursive(packageName + '.' + m.name, methodDef, options, ...m.nestedType);
         }
     });
 };
@@ -153,7 +153,7 @@ const ModeType = new definition_1.GraphQLEnumType({
         },
     }
 });
-const registerTyping = (protoPackage, message, methodDef, opts, inputOpts) => {
+const registerTyping = (protoPackage, message, methodDef, opts, inputOpts, messageOptions) => {
     let insertMode = false;
     let crudOperation = false;
     const type = (protoPackage.startsWith('.') ? '' : '.') + protoPackage + '.' + message.name;
@@ -204,6 +204,21 @@ const registerTyping = (protoPackage, message, methodDef, opts, inputOpts) => {
                     type: resolvedMeta
                 };
             }
+            if (messageOptions && messageOptions.fields) {
+                if (field.name in messageOptions.fields) {
+                    const data = messageOptions.fields[field.name].resolver;
+                    const resolved = resolveMeta(data.fieldName, {
+                        type: ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_MESSAGE,
+                        label: field.label,
+                        typeName: data.targetType
+                    }, type, name, false);
+                    if (resolvedMeta !== null) {
+                        result[data.fieldName] = {
+                            type: resolved
+                        };
+                    }
+                }
+            }
         });
         return result;
     };

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

@@ -1,12 +1,62 @@
 import { GrpcClientConfig } from "@restorecommerce/grpc-client";
-import { FileDescriptorProto, ServiceDescriptorProto } from "ts-proto-descriptors";
+import { FileDescriptorProto } from "ts-proto-descriptors";
 export declare const authSubjectType = ".io.restorecommerce.auth.Subject";
+export declare type ProtoMetaMessageOptions = {
+    options?: {
+        [key: string]: any;
+    };
+    fields?: {
+        [key: string]: {
+            [key: string]: any;
+        };
+    };
+    oneof?: {
+        [key: string]: {
+            [key: string]: any;
+        };
+    };
+    nested?: {
+        [key: string]: ProtoMetaMessageOptions;
+    };
+};
 export interface ProtoMetadata {
     fileDescriptor: FileDescriptorProto;
     references: {
         [key: string]: any;
     };
     dependencies?: ProtoMetadata[];
+    options?: {
+        options?: {
+            [key: string]: any;
+        };
+        services?: {
+            [key: string]: {
+                options?: {
+                    [key: string]: any;
+                };
+                methods?: {
+                    [key: string]: {
+                        [key: string]: any;
+                    };
+                };
+            };
+        };
+        messages?: {
+            [key: string]: ProtoMetaMessageOptions;
+        };
+        enums?: {
+            [key: string]: {
+                options?: {
+                    [key: string]: any;
+                };
+                values?: {
+                    [key: string]: {
+                        [key: string]: any;
+                    };
+                };
+            };
+        };
+    };
 }
 export interface BlackListWhiteListConfig {
     whitelist?: string[];
@@ -22,8 +72,3 @@ export interface ServiceConfig {
 export interface SubSpaceServiceConfig extends ServiceConfig {
     root: boolean;
 }
-export interface SubService {
-    service: ServiceDescriptorProto;
-    name: string;
-    queries: string[];
-}

package/dist/modules/access-control/gql/types.d.ts

@@ -1,3 +1,3 @@
-import { SubService } from "../../../gql/protos";
+import { ProtoMetadata } from '../../../gql/protos';
 export declare function registerTypings(): void;
-export declare const subServices: SubService[];
+export declare const subServices: ProtoMetadata[];

package/dist/modules/access-control/gql/types.js

@@ -7,28 +7,12 @@ const policy_set_1 = require("@restorecommerce/rc-grpc-clients/dist/generated/io
 const access_control_1 = require("@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/access_control");
 const protos_1 = require("../../../gql/protos");
 function registerTypings() {
-    (0, protos_1.registerPackagesRecursive)(rule_1.protoMetadata, policy_1.protoMetadata, policy_set_1.protoMetadata, access_control_1.protoMetadata);
+    (0, protos_1.registerPackagesRecursive)(...exports.subServices);
 }
 exports.registerTypings = registerTypings;
 exports.subServices = [
-    {
-        name: 'access_control',
-        service: access_control_1.protoMetadata.fileDescriptor.service[0],
-        queries: ['IsAllowed', 'WhatIsAllowed']
-    },
-    {
-        name: 'policy',
-        service: policy_1.protoMetadata.fileDescriptor.service[0],
-        queries: ['Read']
-    },
-    {
-        name: 'rule',
-        service: rule_1.protoMetadata.fileDescriptor.service[0],
-        queries: ['Read']
-    },
-    {
-        name: 'policy_set',
-        service: policy_set_1.protoMetadata.fileDescriptor.service[0],
-        queries: ['Read']
-    },
+    access_control_1.protoMetadata,
+    policy_1.protoMetadata,
+    rule_1.protoMetadata,
+    policy_set_1.protoMetadata
 ];