@restorecommerce/facade 0.3.2 → 0.3.5

package/CHANGELOG.md

@@ -3,6 +3,37 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.3.5](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.3.4...@restorecommerce/facade@0.3.5) (2022-03-04)
+
+
+### Bug Fixes
+
+* **facade:** added null check ([2ff25fe](https://github.com/restorecommerce/libs/commit/2ff25febd04ffa624d2ba4a7b50179726abfe8da))
+
+
+
+
+
+## [0.3.4](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.3.3...@restorecommerce/facade@0.3.4) (2022-03-04)
+
+
+### Bug Fixes
+
+* **facade:** added scope for all mutations and queries ([3b4df19](https://github.com/restorecommerce/libs/commit/3b4df196fa8bbbdc169846c588d3d53c85a4c091))
+* **facade:** fixed enum type mapping for nested object ([f452229](https://github.com/restorecommerce/libs/commit/f452229fc3ceec7205d079884a55076578e5a975))
+
+
+
+
+
+## [0.3.3](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.3.2...@restorecommerce/facade@0.3.3) (2022-03-01)
+
+**Note:** Version bump only for package @restorecommerce/facade
+
+
+
+
+
 ## [0.3.2](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.3.1...@restorecommerce/facade@0.3.2) (2022-02-23)
 
 **Note:** Version bump only for package @restorecommerce/facade

package/codegen/index.js

@@ -33,7 +33,7 @@ async function generateSchemaTypings({ schema, outputFile, typescript, typescrip
                 typescriptResolvers: typescriptResolversPlugin,
             },
         };
-        const output = await core_1.codegen(codegenConfig);
+        const output = await (0, core_1.codegen)(codegenConfig);
         fs.writeFileSync(outputFile, output);
         console.log('Schema typings generated in' + outputFile);
     }

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

@@ -48,13 +48,9 @@ export interface CreateSchemaCRUDFieldsArgs {
 }
 export declare function createSchemaCRUDFields(args: CreateSchemaCRUDFieldsArgs): {
     queryFields: {
-        [x: string]: GraphQLFieldConfig<any, any, {
-            [argName: string]: any;
-        }>;
+        [x: string]: GraphQLFieldConfig<any, any, any>;
     };
     mutationFields: {
-        [x: string]: GraphQLFieldConfig<any, any, {
-            [argName: string]: any;
-        }>;
+        [x: string]: GraphQLFieldConfig<any, any, any>;
     };
 };

package/dist/gql/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

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

@@ -1,11 +1,9 @@
-import { GraphQLInputField, GraphQLResolveInfo, GraphQLSchema } from "graphql";
-import { GraphQLEnumType, GraphQLFieldConfig, GraphQLFieldConfigMap, GraphQLInputObjectType, GraphQLInputType, Thunk } from "graphql/type/definition";
+import { GraphQLInputField, 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/google/protobuf/descriptor";
+import { MethodDescriptorProto, ServiceDescriptorProto } from "ts-proto-descriptors";
 import { GrpcClientConfig } from "@restorecommerce/grpc-client";
-export declare const getGQLSchema: <TSource, TContext>(method: MethodDescriptorProto) => GraphQLFieldConfig<TSource, TContext, {
-    [argName: string]: any;
-}>;
+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 recursiveUploadToBuffer: (data: any, model: GraphQLInputObjectType | GraphQLEnumType | GraphQLInputField | GraphQLInputType) => Promise<any>;
 export declare type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
@@ -17,7 +15,7 @@ declare type ServiceClient<Context extends Pick<Context, Key>, Key extends keyof
 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, grpcClientConfig: GrpcClientConfig) => { [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 | undefined) => void;
 export declare const generateResolver: (...namespaces: string[]) => any;
-export declare const registerResolverSchema: (namespace: string, name: string, schema: Thunk<GraphQLFieldConfig<any, any>>, mutation?: boolean, subspace?: string | undefined) => void;
+export declare const registerResolverSchema: (namespace: string, name: string, schema: ThunkObjMap<GraphQLFieldConfig<any, any>>, mutation?: boolean, subspace?: string | undefined) => void;
 export declare const generateSchema: (setup: {
     prefix: string;
     namespace: string;

package/dist/gql/protos/graphql.js

@@ -17,7 +17,7 @@ const getGQLSchema = (method) => {
     //   type: new GraphQLNonNull(OperationStatusType),
     // },
     };
-    const responseTyping = registry_1.getTyping(method.outputType);
+    const responseTyping = (0, registry_1.getTyping)(method.outputType);
     if (!responseTyping) {
         throw Error("Method doesn't have registered typings: " + method.outputType);
     }
@@ -26,7 +26,7 @@ const getGQLSchema = (method) => {
             type: responseTyping.output,
         };
     }
-    const outName = "Proto" + 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({
@@ -35,7 +35,7 @@ const getGQLSchema = (method) => {
         });
         typeCache.set(outName, out);
     }
-    const typing = registry_1.getTyping(method.inputType);
+    const typing = (0, registry_1.getTyping)(method.inputType);
     if (!typing) {
         throw Error("Method doesn't have registered typings: " + method.inputType);
     }
@@ -43,7 +43,7 @@ const getGQLSchema = (method) => {
         type: out,
         args: method.inputType === '.google.protobuf.Empty' ? undefined : {
             input: {
-                type: graphql_1.GraphQLNonNull(typing.input)
+                type: new graphql_1.GraphQLNonNull(typing.input)
             }
         }
     };
@@ -52,7 +52,7 @@ 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] = exports.getGQLSchema(method);
+        obj[method.name] = (0, exports.getGQLSchema)(method);
         return obj;
     }, {});
 };
@@ -64,17 +64,17 @@ const recursiveUploadToBuffer = async (data, model) => {
     if (model instanceof definition_1.GraphQLInputObjectType) {
         const fields = model.getFields();
         for (let key of Object.keys(fields)) {
-            if (key in data) {
-                data[key] = await exports.recursiveUploadToBuffer(data[key], fields[key].type);
+            if (data && key in data) {
+                data[key] = await (0, exports.recursiveUploadToBuffer)(data[key], fields[key].type);
             }
         }
     }
     if (model instanceof graphql_1.GraphQLNonNull) {
-        return await exports.recursiveUploadToBuffer(data, model.ofType);
+        return await (0, exports.recursiveUploadToBuffer)(data, model.ofType);
     }
     if (model instanceof graphql_1.GraphQLList) {
         for (let i = 0; i < data.length; i++) {
-            data[i] = await exports.recursiveUploadToBuffer(data[i], model.ofType);
+            data[i] = await (0, exports.recursiveUploadToBuffer)(data[i], model.ofType);
         }
     }
     if (model instanceof definition_1.GraphQLScalarType) {
@@ -101,7 +101,7 @@ const getGQLResolverFunctions = (service, key, serviceKey, grpcClientConfig) =>
         return {};
     }
     return service.method.reduce((obj, method) => {
-        const typing = registry_1.getTyping(method.inputType);
+        const typing = (0, registry_1.getTyping)(method.inputType);
         if (!typing) {
             throw Error(`Method '${method.name}' could not find input type: ${method.inputType}`);
         }
@@ -119,27 +119,26 @@ const getGQLResolverFunctions = (service, key, serviceKey, grpcClientConfig) =>
             }
         }
         obj[method.name] = async (args, context) => {
-            var _a;
             const client = context[key].client;
             const service = client[serviceKey];
             try {
-                const converted = await exports.recursiveUploadToBuffer(args.input, typing.input);
+                const converted = await (0, exports.recursiveUploadToBuffer)(args.input, typing.input);
                 let req = {
                     // Fill defaults
                     ...defaults,
                     ...converted
                 };
                 // convert enum strings to integers
-                req = utils_1.convertEnumToInt(typing, req);
+                req = (0, utils_1.convertEnumToInt)(typing, req);
                 if (subjectField !== null) {
-                    req.subject = registry_1.getTyping(types_1.authSubjectType).processor.fromPartial({});
+                    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];
                     }
                 }
                 const result = await service[method.name](req);
-                const bufferFields = utils_1.getKeys((_a = grpcClientConfig) === null || _a === void 0 ? void 0 : _a.bufferFields);
+                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) => {
@@ -195,7 +194,7 @@ const getGQLResolverFunctions = (service, key, serviceKey, grpcClientConfig) =>
                     return { details: aggregatedResponse, operationStatus };
                 }
                 if ('items' in result) {
-                    let items = utils_1.decodeBufferFields(result.items, bufferFields);
+                    let items = (0, utils_1.decodeBufferFields)(result.items, bufferFields);
                     return {
                         details: {
                             items: items,
@@ -205,7 +204,7 @@ const getGQLResolverFunctions = (service, key, serviceKey, grpcClientConfig) =>
                 }
                 else {
                     return {
-                        details: utils_1.decodeBufferFields([result], bufferFields)[0]
+                        details: (0, utils_1.decodeBufferFields)([result], bufferFields)[0]
                     };
                 }
             }
@@ -240,8 +239,8 @@ const MutateResolver = async (req, ctx, schema) => {
         }
     }
     if (key && module_name) {
-        module_name = utils_1.convertyCamelToSnakeCase(module_name);
-        key = utils_1.convertyCamelToSnakeCase(key);
+        module_name = (0, utils_1.convertyCamelToSnakeCase)(module_name);
+        key = (0, utils_1.convertyCamelToSnakeCase)(key);
         service = (_e = ctx[module_name]) === null || _e === void 0 ? void 0 : _e.client[key];
     }
     try {
@@ -263,8 +262,8 @@ const MutateResolver = async (req, ctx, schema) => {
         const inputMethodTypeKey = module_name.toLowerCase() + '.' + key.toLowerCase() + '.' + method.toLowerCase();
         const nsType = inputMethodType.get(inputMethodTypeKey);
         if (nsType) {
-            const inputTyping = registry_1.getTyping(nsType);
-            utils_1.convertEnumToInt(inputTyping, input);
+            const inputTyping = (0, registry_1.getTyping)(nsType);
+            (0, utils_1.convertEnumToInt)(inputTyping, input);
         }
         // check service object contains requested mode's method def
         if (!service[method]) {
@@ -496,9 +495,9 @@ const generateSchema = (setup) => {
             const fields = {};
             namespaceResolverSchemaRegistry.get(s.namespace).get(false).forEach((value, key) => {
                 if (value instanceof Map) {
-                    const capitalName = utils_1.capitalizeProtoName(key);
+                    const capitalName = (0, utils_1.capitalizeProtoName)(key);
                     fields[key] = {
-                        type: graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
+                        type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
                             name: s.prefix + capitalName + 'Query',
                             fields: Object.fromEntries(value),
                         }))
@@ -509,7 +508,7 @@ const generateSchema = (setup) => {
                 }
             });
             queryFields[s.namespace] = {
-                type: graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
+                type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
                     name: s.prefix + 'Query',
                     fields
                 }))
@@ -519,9 +518,9 @@ const generateSchema = (setup) => {
             const fields = {};
             namespaceResolverSchemaRegistry.get(s.namespace).get(true).forEach((value, key) => {
                 if (value instanceof Map) {
-                    const capitalName = utils_1.capitalizeProtoName(key);
+                    const capitalName = (0, utils_1.capitalizeProtoName)(key);
                     fields[key] = {
-                        type: graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
+                        type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
                             name: s.prefix + capitalName + 'Mutation',
                             fields: Object.fromEntries(value),
                         }))
@@ -532,7 +531,7 @@ const generateSchema = (setup) => {
                 }
             });
             mutationFields[s.namespace] = {
-                type: graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
+                type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLObjectType({
                     name: s.prefix + 'Mutation',
                     fields
                 }))
@@ -609,53 +608,53 @@ const getWhitelistBlacklistConfig = (metaService, queries, config) => {
 };
 exports.getWhitelistBlacklistConfig = getWhitelistBlacklistConfig;
 const getAndGenerateSchema = (service, namespace, prefix, cfg, queryList) => {
-    const { mutations, queries } = exports.getWhitelistBlacklistConfig(service, queryList, cfg);
-    const schemas = exports.getGQLSchemas(service);
+    const { mutations, queries } = (0, exports.getWhitelistBlacklistConfig)(service, queryList, cfg);
+    const schemas = (0, exports.getGQLSchemas)(service);
     Object.keys(schemas).forEach(key => {
-        exports.registerResolverSchema(namespace, key, schemas[key], !queries.has(key) && mutations.has(key));
+        (0, exports.registerResolverSchema)(namespace, key, schemas[key], !queries.has(key) && mutations.has(key));
     });
-    return exports.generateSchema([{ prefix, namespace }]);
+    return (0, exports.generateSchema)([{ prefix, namespace }]);
 };
 exports.getAndGenerateSchema = getAndGenerateSchema;
 const getAndGenerateResolvers = (service, namespace, cfg, queryList, subspace = undefined, serviceKey = undefined) => {
-    const { mutations, queries } = exports.getWhitelistBlacklistConfig(service, queryList, cfg);
-    const func = exports.getGQLResolverFunctions(service, namespace, serviceKey || subspace || namespace, cfg.client);
+    const { mutations, queries } = (0, exports.getWhitelistBlacklistConfig)(service, queryList, cfg);
+    const func = (0, exports.getGQLResolverFunctions)(service, namespace, serviceKey || subspace || namespace, cfg.client);
     Object.keys(func).forEach(k => {
-        exports.registerResolverFunction(namespace, k, func[k], !queries.has(k) && mutations.has(k), subspace, service);
+        (0, exports.registerResolverFunction)(namespace, k, func[k], !queries.has(k) && mutations.has(k), subspace, service);
     });
-    return exports.generateResolver(namespace);
+    return (0, exports.generateResolver)(namespace);
 };
 exports.getAndGenerateResolvers = getAndGenerateResolvers;
 const generateSubServiceSchemas = (subServices, config, namespace, prefix) => {
     subServices.forEach((sub) => {
-        const { mutations, queries } = exports.getWhitelistBlacklistConfig(sub.service, sub.queries, config);
-        const schemas = exports.getGQLSchemas(sub.service);
+        const { mutations, queries } = (0, exports.getWhitelistBlacklistConfig)(sub.service, sub.queries, config);
+        const schemas = (0, exports.getGQLSchemas)(sub.service);
         Object.keys(schemas).forEach(key => {
-            exports.registerResolverSchema(config.root ? sub.name : namespace, key, schemas[key], !queries.has(key) && mutations.has(key), config.root ? undefined : sub.name);
+            (0, exports.registerResolverSchema)(config.root ? sub.name : namespace, key, schemas[key], !queries.has(key) && mutations.has(key), config.root ? undefined : sub.name);
         });
     });
     if (config.root) {
-        return exports.generateSchema(subServices.map(srv => ({
+        return (0, exports.generateSchema)(subServices.map(srv => ({
             prefix: prefix + srv.name.substr(0, 1).toUpperCase() + srv.name.substr(1).toLowerCase(),
             namespace: srv.name
         })));
     }
-    return exports.generateSchema([{ prefix, namespace }]);
+    return (0, exports.generateSchema)([{ prefix, namespace }]);
 };
 exports.generateSubServiceSchemas = generateSubServiceSchemas;
 const generateSubServiceResolvers = (subServices, config, namespace) => {
     subServices.forEach((sub) => {
-        const { mutations, queries } = exports.getWhitelistBlacklistConfig(sub.service, sub.queries, config);
-        const func = exports.getGQLResolverFunctions(sub.service, namespace, sub.name || namespace, config.client);
+        const { mutations, queries } = (0, exports.getWhitelistBlacklistConfig)(sub.service, sub.queries, config);
+        const func = (0, exports.getGQLResolverFunctions)(sub.service, namespace, sub.name || namespace, config.client);
         Object.keys(func).forEach(k => {
             const regNamespace = config.root ? sub.name : namespace;
             const regSubspace = config.root ? undefined : sub.name;
-            exports.registerResolverFunction(regNamespace, k, func[k], !queries.has(k) && mutations.has(k), regSubspace, sub.service);
+            (0, exports.registerResolverFunction)(regNamespace, k, func[k], !queries.has(k) && mutations.has(k), regSubspace, sub.service);
         });
     });
     if (config.root) {
-        return exports.generateResolver(...subServices.map(srv => srv.name));
+        return (0, exports.generateResolver)(...subServices.map(srv => srv.name));
     }
-    return exports.generateResolver(namespace);
+    return (0, exports.generateResolver)(namespace);
 };
 exports.generateSubServiceResolvers = generateSubServiceResolvers;

package/dist/gql/protos/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

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

@@ -1,6 +1,6 @@
 import { GrpcClientRpcMethodDefinition, GrpcService, GrpcServiceMethods } from "@restorecommerce/grpc-client";
 import { RestoreCommerceGrpcClient } from "@restorecommerce/rc-grpc-clients";
-import { ServiceDescriptorProto, MethodDescriptorProto } from "ts-proto-descriptors/google/protobuf/descriptor";
+import { ServiceDescriptorProto, MethodDescriptorProto } from "ts-proto-descriptors";
 export declare const getProtoFunction: (method: MethodDescriptorProto) => GrpcClientRpcMethodDefinition<any, any>;
 export declare const getProtoFunctions: <M extends GrpcService = any>(service: ServiceDescriptorProto) => GrpcServiceMethods<M>;
 export declare const getGRPCService: <T extends Record<string, any>>(self: RestoreCommerceGrpcClient, packageName: string, service: ServiceDescriptorProto) => T;

package/dist/gql/protos/protos.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGRPCService = exports.getProtoFunctions = exports.getProtoFunction = void 0;
 const registry_1 = require("./registry");
 const getProtoFunction = (method) => {
-    const inputMessage = registry_1.getTyping(method.inputType);
-    const outputMessage = registry_1.getTyping(method.outputType);
+    const inputMessage = (0, registry_1.getTyping)(method.inputType);
+    const outputMessage = (0, registry_1.getTyping)(method.outputType);
     if (!inputMessage) {
         throw Error(`Method '${method.name}' could not find input type: ${method.inputType}`);
     }
@@ -40,7 +40,7 @@ exports.getProtoFunction = getProtoFunction;
 const getProtoFunctions = (service) => {
     var _a;
     return (_a = service.method) === null || _a === void 0 ? void 0 : _a.reduce((obj, method) => {
-        obj[method.name] = exports.getProtoFunction(method);
+        obj[method.name] = (0, exports.getProtoFunction)(method);
         return obj;
     }, {});
 };
@@ -49,7 +49,7 @@ const getGRPCService = (self, packageName, service) => {
     return self['createService']({
         packageName,
         serviceName: service.name,
-        methods: exports.getProtoFunctions(service)
+        methods: (0, exports.getProtoFunctions)(service)
     });
 };
 exports.getGRPCService = getGRPCService;

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

@@ -1,7 +1,7 @@
 import { GraphQLEnumTypeConfig, GraphQLInputObjectTypeConfig, GraphQLObjectType, GraphQLObjectTypeConfig } from "graphql";
 import { GraphQLEnumType, GraphQLInputObjectType } from "graphql/type/definition";
 import { ProtoMetadata } from "./types";
-import { DescriptorProto, EnumDescriptorProto, MethodDescriptorProto } from "ts-proto-descriptors/google/protobuf/descriptor";
+import { DescriptorProto, EnumDescriptorProto, MethodDescriptorProto } from "ts-proto-descriptors";
 export interface TypingData {
     output: GraphQLObjectType | GraphQLEnumType;
     input: GraphQLInputObjectType | GraphQLEnumType;

package/dist/gql/protos/registry.js

@@ -6,8 +6,7 @@ const definition_1 = require("graphql/type/definition");
 const graphql_upload_1 = require("graphql-upload");
 const utils_1 = require("./utils");
 const types_1 = require("./types");
-const descriptor_1 = require("ts-proto-descriptors/google/protobuf/descriptor");
-const _ = require("lodash");
+const ts_proto_descriptors_1 = require("ts-proto-descriptors");
 exports.registeredTypings = new Map();
 exports.scalarTypes = ['Boolean', 'Int', 'Float', 'String', 'ID', 'Upload'];
 const typeNameAndNameSpaceMapping = new Map();
@@ -32,10 +31,10 @@ exports.clearRegistry = clearRegistry;
 const registerPackagesRecursive = (...protoMetadata) => {
     protoMetadata.forEach(meta => {
         var _a, _b;
-        meta.dependencies && exports.registerPackagesRecursive(...meta.dependencies);
+        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);
         (_b = meta.fileDescriptor.enumType) === null || _b === void 0 ? void 0 : _b.forEach((m) => {
-            exports.registerEnumTyping(meta.fileDescriptor.package, m);
+            (0, exports.registerEnumTyping)(meta.fileDescriptor.package, m);
         });
         Object.keys(meta.references).forEach(key => {
             exports.registeredTypings.get(key).processor = meta.references[key];
@@ -57,9 +56,9 @@ const recursiveEnumCheck = (typeName, enumMap, prevFieldName, traversedFields) =
         if (typeName && typeName.startsWith('[') && typeName.endsWith('!]')) {
             typeName = typeName.substring(1, typeName.length - 2);
         }
-        const objectNameSpace = exports.getNameSpaceTypeName(typeName);
+        const objectNameSpace = (0, exports.getNameSpaceTypeName)(typeName);
         if (objectNameSpace) {
-            const objectType = exports.getTyping(objectNameSpace);
+            const objectType = (0, exports.getTyping)(objectNameSpace);
             if ((objectType === null || objectType === void 0 ? void 0 : objectType.input) && (registeredEnumTypes.indexOf(objectType.input.toString()) > -1)) {
                 enumMap.set(objectType === null || objectType === void 0 ? void 0 : objectType.input.toString(), prevFieldName);
                 prevFieldName = '';
@@ -81,13 +80,7 @@ const recursiveEnumCheck = (typeName, enumMap, prevFieldName, traversedFields) =
                                 // skip loop as this GQL type is already traversed
                                 continue;
                             }
-                            if (!prevFieldName || _.isEmpty(prevFieldName)) {
-                                prevFieldName = fieldName;
-                            }
-                            if (prevFieldName && prevFieldName != fieldName) {
-                                fieldName = prevFieldName + '.' + fieldName;
-                            }
-                            exports.recursiveEnumCheck(fieldType, enumMap, fieldName, traversedFields);
+                            (0, exports.recursiveEnumCheck)(fieldType, enumMap, fieldName, traversedFields);
                         }
                     }
                 }
@@ -99,10 +92,10 @@ const recursiveEnumCheck = (typeName, enumMap, prevFieldName, traversedFields) =
 exports.recursiveEnumCheck = recursiveEnumCheck;
 const registerMessageTypesRecursive = (packageName, methodDef, ...types) => {
     types.forEach(m => {
-        exports.registerTyping(packageName, m, methodDef);
+        (0, exports.registerTyping)(packageName, m, methodDef);
         if (m.enumType) {
             m.enumType.forEach((enumType) => {
-                exports.registerEnumTyping(packageName + '.' + m.name, enumType);
+                (0, exports.registerEnumTyping)(packageName + '.' + m.name, enumType);
             });
         }
         if (m.nestedType) {
@@ -140,7 +133,7 @@ const registerTyping = (protoPackage, message, methodDef, opts, inputOpts) => {
         // TODO Log debug "Typings for object are already registered"
         return;
     }
-    const name = (opts === null || opts === void 0 ? void 0 : opts.name) || utils_1.capitalizeProtoName(type);
+    const name = (opts === null || opts === void 0 ? void 0 : opts.name) || (0, utils_1.capitalizeProtoName)(type);
     const inputName = (inputOpts === null || inputOpts === void 0 ? void 0 : inputOpts.name) || 'I' + name;
     const fields = () => {
         var _a;
@@ -173,6 +166,13 @@ const registerTyping = (protoPackage, message, methodDef, opts, inputOpts) => {
                 type: ModeType
             };
         }
+        // add scope to all mutations / queries
+        if (!result.scope) {
+            result['scope'] = {
+                description: 'target scope',
+                type: graphql_1.GraphQLString
+            };
+        }
         return result;
     };
     const resultObj = new graphql_1.GraphQLObjectType({
@@ -204,7 +204,7 @@ const registerEnumTyping = (protoPackage, message, opts) => {
             value: entry.number
         };
     });
-    const name = (opts === null || opts === void 0 ? void 0 : opts.name) || utils_1.capitalizeProtoName(type);
+    const name = (opts === null || opts === void 0 ? void 0 : opts.name) || (0, utils_1.capitalizeProtoName)(type);
     const result = new definition_1.GraphQLEnumType({
         ...(opts || { name }),
         values
@@ -226,14 +226,14 @@ const resolveMeta = (key, field, rootObjType, objName, input) => {
     var _a;
     let result;
     switch (field.type) {
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_BOOL:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_BOOL:
             result = graphql_1.GraphQLBoolean;
             break;
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_STRING:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_STRING:
             result = graphql_1.GraphQLString;
             break;
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_ENUM:
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_MESSAGE:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_ENUM:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_MESSAGE:
             const objType = field.typeName;
             if (!exports.registeredTypings.has(objType)) {
                 throw new Error("Typing '" + objType + "' not registered for key '" + key + "' in object: " + objName);
@@ -256,7 +256,7 @@ const resolveMeta = (key, field, rootObjType, objName, input) => {
             }
             result = typingData.input;
             break;
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_BYTES:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_BYTES:
             if (input) {
                 result = graphql_upload_1.GraphQLUpload;
                 break;
@@ -264,30 +264,30 @@ const resolveMeta = (key, field, rootObjType, objName, input) => {
             // TODO Output Buffer
             result = TodoScalar;
             break;
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_INT32:
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_UINT32:
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_INT64:
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_UINT64:
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_SINT32:
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_SINT64:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_INT32:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_UINT32:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_INT64:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_UINT64:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SINT32:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SINT64:
             result = graphql_1.GraphQLInt;
             break;
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_DOUBLE:
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_FLOAT:
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_FIXED64:
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_FIXED32:
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_SFIXED32:
-        case descriptor_1.FieldDescriptorProto_Type.TYPE_SFIXED64:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_DOUBLE:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FLOAT:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FIXED64:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FIXED32:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SFIXED32:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SFIXED64:
             result = graphql_1.GraphQLFloat;
             break;
         default:
             throw new Error("unknown typing type '" + field.type + "' for key '" + key + "' in: " + objName);
     }
-    if (field.label === descriptor_1.FieldDescriptorProto_Label.LABEL_REPEATED) {
-        result = graphql_1.GraphQLList(graphql_1.GraphQLNonNull(result));
+    if (field.label === ts_proto_descriptors_1.FieldDescriptorProto_Label.LABEL_REPEATED) {
+        result = new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(result));
     }
-    if (field.label === descriptor_1.FieldDescriptorProto_Label.LABEL_REQUIRED) {
-        result = graphql_1.GraphQLNonNull(result);
+    if (field.label === ts_proto_descriptors_1.FieldDescriptorProto_Label.LABEL_REQUIRED) {
+        result = new graphql_1.GraphQLNonNull(result);
     }
     return result;
 };

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

@@ -1,5 +1,5 @@
 import { GrpcClientConfig } from "@restorecommerce/grpc-client";
-import { FileDescriptorProto, ServiceDescriptorProto } from "ts-proto-descriptors/google/protobuf/descriptor";
+import { FileDescriptorProto, ServiceDescriptorProto } from "ts-proto-descriptors";
 export declare const authSubjectType = ".io.restorecommerce.auth.Subject";
 export interface ProtoMetadata {
     fileDescriptor: FileDescriptorProto;

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

@@ -3,23 +3,9 @@ export declare const capitalizeProtoName: (name: string) => string;
 export declare const convertyCamelToSnakeCase: (entity: string) => string;
 export declare const getKeys: (obj: any) => string[];
 export declare const decodeBufferFields: (items: any, bufferFields: string[]) => any;
-interface EnumMetaData {
-    name: string;
-    number: number;
-    options?: any;
-}
-/**
- * recursively find the path and updates the object with given value, this function
- * also takes care to handle if there is an array at any position in the path
- * @param path path in dot notation
- * @param val value to be updated in Object
- * @param obj Object
- */
-export declare const updateJSON: (path: string, val: EnumMetaData[], obj: any) => void;
 /**
  * converts enum string values to integers reading from the inputTyping
  * @param TypingData input typing
  * @param req request object from which the enum strings to be replaced
  */
 export declare const convertEnumToInt: (inputTyping: TypingData, req: any) => any;
-export {};