@restorecommerce/facade 0.1.42 → 0.1.43

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.1.43](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.1.42...@restorecommerce/facade@0.1.43) (2022-02-02)
+
+
+### Bug Fixes
+
+* **facade:** enum convert string to integer ([47127ef](https://github.com/restorecommerce/libs/commit/47127ef323f5853a4c6573b01dd36c3725074d4e))
+* **facade:** fix for mutation resolvers to convert enums string values to integer ([28d0fea](https://github.com/restorecommerce/libs/commit/28d0fea912778b3cf4f748bc68b1e0fafaea60af))
+* **facade:** fixed read operations to convert enums to number ([81083c0](https://github.com/restorecommerce/libs/commit/81083c0162d605d6a3c8394e06ba093d1e29948e))
+* **facade:** move conversion of enum to int to utils ([72c9a1f](https://github.com/restorecommerce/libs/commit/72c9a1f0be269b68bc9b2501a38789ce7409453f))
+* **facade:** recursive enum path fix ([244f7fc](https://github.com/restorecommerce/libs/commit/244f7fc782d10ffb5f774f0245174446288cacb5))
+
+
+
+
+
 ## [0.1.42](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.1.41...@restorecommerce/facade@0.1.42) (2022-01-28)
 
 **Note:** Version bump only for package @restorecommerce/facade

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

@@ -15,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) => void;
+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 generateSchema: (setup: {

package/dist/gql/protos/graphql.js

@@ -10,6 +10,7 @@ const stream = require("stream");
 const _ = require("lodash");
 const typeCache = new Map();
 const Mutate = ['Create', 'Update', 'Upsert'];
+const inputMethodType = new Map();
 const getGQLSchema = (method) => {
     const fields = {
     // operationStatus: {
@@ -109,9 +110,8 @@ const getGQLResolverFunctions = (service, key, serviceKey, grpcClientConfig) =>
         }
         const defaults = typing.processor.fromPartial({});
         let subjectField = null;
-        const inputTyping = registry_1.getTyping(method.inputType);
-        if (inputTyping) {
-            for (let field of inputTyping.meta.field) {
+        if (typing) {
+            for (let field of typing.meta.field) {
                 if (field.typeName === types_1.authSubjectType) {
                     subjectField = field.name;
                     break;
@@ -124,11 +124,13 @@ const getGQLResolverFunctions = (service, key, serviceKey, grpcClientConfig) =>
             const service = client[serviceKey];
             try {
                 const converted = await exports.recursiveUploadToBuffer(args.input, typing.input);
-                const req = {
+                let req = {
                     // Fill defaults
                     ...defaults,
                     ...converted
                 };
+                // convert enum strings to integers
+                req = utils_1.convertEnumToInt(typing, req);
                 if (subjectField !== null) {
                     req.subject = registry_1.getTyping(types_1.authSubjectType).processor.fromPartial({});
                     const authToken = context.request.req.headers['authorization'];
@@ -251,6 +253,12 @@ const MutateResolver = async (req, ctx, schema) => {
         else if (mode === 'UPSERT') {
             method = 'Upsert';
         }
+        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);
+        }
         // check service object contains requested mode's method def
         if (!service[method]) {
             throw new Error(`Method ${method} not defined on ${module_name}`);
@@ -361,7 +369,7 @@ const MutateResolver = async (req, ctx, schema) => {
         };
     }
 };
-const registerResolverFunction = (namespace, name, func, mutation = false, subspace = undefined) => {
+const registerResolverFunction = (namespace, name, func, mutation = false, subspace = undefined, service) => {
     if (!namespaceResolverRegistry.has(namespace)) {
         namespaceResolverRegistry.set(namespace, new Map());
     }
@@ -383,6 +391,13 @@ const registerResolverFunction = (namespace, name, func, mutation = false, subsp
             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);
+        }
+    }
     // custom mutation resolver for create, update and upsert - Mutate
     if (Mutate.indexOf(name) > -1) {
         name = 'Mutate';
@@ -599,7 +614,7 @@ const getAndGenerateResolvers = (service, namespace, cfg, queryList, subspace =
     const { mutations, queries } = exports.getWhitelistBlacklistConfig(service, queryList, cfg);
     const func = 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);
+        exports.registerResolverFunction(namespace, k, func[k], !queries.has(k) && mutations.has(k), subspace, service);
     });
     return exports.generateResolver(namespace);
 };
@@ -626,7 +641,9 @@ const generateSubServiceResolvers = (subServices, config, namespace) => {
         const { mutations, queries } = exports.getWhitelistBlacklistConfig(sub.service, sub.queries, config);
         const func = exports.getGQLResolverFunctions(sub.service, namespace, sub.name || namespace, config.client);
         Object.keys(func).forEach(k => {
-            exports.registerResolverFunction(config.root ? sub.name : namespace, k, func[k], !queries.has(k) && mutations.has(k), config.root ? undefined : sub.name);
+            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);
         });
     });
     if (config.root) {

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

@@ -8,8 +8,13 @@ export interface TypingData {
     meta: DescriptorProto | EnumDescriptorProto;
     processor?: any;
 }
+export declare const registeredTypings: Map<string, TypingData>;
+export declare const scalarTypes: string[];
 export declare const clearRegistry: () => void;
 export declare const registerPackagesRecursive: (...protoMetadata: ProtoMetadata[]) => void;
+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 registerEnumTyping: <T = {
     [key: string]: any;

package/dist/gql/protos/registry.js

@@ -1,13 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTyping = exports.registerEnumTyping = exports.registerTyping = exports.registerPackagesRecursive = exports.clearRegistry = void 0;
+exports.getTyping = exports.registerEnumTyping = exports.registerTyping = exports.recursiveEnumCheck = exports.getNameSpaceTypeName = exports.getRegisteredEnumTypings = exports.registerPackagesRecursive = exports.clearRegistry = exports.scalarTypes = exports.registeredTypings = void 0;
 const graphql_1 = require("graphql");
 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 registeredTypings = new Map();
+const _ = require("lodash");
+exports.registeredTypings = new Map();
+exports.scalarTypes = ['Boolean', 'Int', 'Float', 'String', 'ID', 'Upload'];
+const typeNameAndNameSpaceMapping = new Map();
+const registeredEnumTypes = [];
 const MapScalar = new definition_1.GraphQLScalarType({
     name: 'MapScalar',
 });
@@ -22,7 +26,7 @@ const TodoScalar = new definition_1.GraphQLScalarType({
     }
 });
 const clearRegistry = () => {
-    registeredTypings.clear();
+    exports.registeredTypings.clear();
 };
 exports.clearRegistry = clearRegistry;
 const registerPackagesRecursive = (...protoMetadata) => {
@@ -34,11 +38,70 @@ const registerPackagesRecursive = (...protoMetadata) => {
             exports.registerEnumTyping(meta.fileDescriptor.package, m);
         });
         Object.keys(meta.references).forEach(key => {
-            registeredTypings.get(key).processor = meta.references[key];
+            exports.registeredTypings.get(key).processor = meta.references[key];
         });
     });
 };
 exports.registerPackagesRecursive = registerPackagesRecursive;
+const getRegisteredEnumTypings = () => {
+    return registeredEnumTypes;
+};
+exports.getRegisteredEnumTypings = getRegisteredEnumTypings;
+const getNameSpaceTypeName = (typeName) => {
+    return typeNameAndNameSpaceMapping.get(typeName);
+};
+exports.getNameSpaceTypeName = getNameSpaceTypeName;
+// Iterate through the object and collect list of all enum types with their keys / paths
+const recursiveEnumCheck = (typeName, enumMap, prevFieldName, traversedFields) => {
+    if (exports.scalarTypes.indexOf(typeName) <= -1) {
+        if (typeName && typeName.startsWith('[') && typeName.endsWith('!]')) {
+            typeName = typeName.substring(1, typeName.length - 2);
+        }
+        const objectNameSpace = exports.getNameSpaceTypeName(typeName);
+        if (objectNameSpace) {
+            const objectType = 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 = '';
+            }
+            else if (objectType === null || objectType === void 0 ? void 0 : objectType.input) {
+                // get nested fields from this object and check recursively
+                const gqlFields = objectType.input.getFields();
+                if (gqlFields) {
+                    const fieldNames = Object.keys(gqlFields);
+                    for (let fieldName of fieldNames) {
+                        let fieldType = gqlFields[fieldName].type.toString();
+                        // if fieldType is not basic type, get the object and make recursive check till no more objects are found
+                        let skipLoop = false;
+                        if (exports.scalarTypes.indexOf(fieldType) <= -1) {
+                            // check if fieldName already exists in the enumMap (to avoid circular reference for infinite loop)
+                            for (let [key, val] of enumMap) {
+                                const valueArray = val.split('.');
+                                // if fieldName already exists in enumMap, this field is a circular field ref
+                                // ignore it as its already traversed and enums are kept track of
+                                if (valueArray.indexOf(fieldName) > -1) {
+                                    skipLoop = true;
+                                }
+                            }
+                            if (skipLoop) {
+                                continue;
+                            }
+                            if (!prevFieldName || _.isEmpty(prevFieldName)) {
+                                prevFieldName = fieldName;
+                            }
+                            if (prevFieldName && prevFieldName != fieldName) {
+                                fieldName = prevFieldName + '.' + fieldName;
+                            }
+                            exports.recursiveEnumCheck(fieldType, enumMap, fieldName, traversedFields);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return enumMap;
+};
+exports.recursiveEnumCheck = recursiveEnumCheck;
 const registerMessageTypesRecursive = (packageName, methodDef, ...types) => {
     types.forEach(m => {
         exports.registerTyping(packageName, m, methodDef);
@@ -78,7 +141,7 @@ const registerTyping = (protoPackage, message, methodDef, opts, inputOpts) => {
             }
         }
     }
-    if (registeredTypings.has(type)) {
+    if (exports.registeredTypings.has(type)) {
         // TODO Log debug "Typings for object are already registered"
         return;
     }
@@ -125,7 +188,8 @@ const registerTyping = (protoPackage, message, methodDef, opts, inputOpts) => {
         ...(inputOpts || { name: inputName }),
         fields: inputFields,
     });
-    registeredTypings.set(type, {
+    typeNameAndNameSpaceMapping.set(resultInputObj.name, type);
+    exports.registeredTypings.set(type, {
         output: resultObj,
         input: resultInputObj,
         meta: message
@@ -135,7 +199,7 @@ exports.registerTyping = registerTyping;
 const registerEnumTyping = (protoPackage, message, opts) => {
     var _a;
     const type = (protoPackage.startsWith('.') ? '' : '.') + protoPackage + '.' + message.name;
-    if (registeredTypings.has(type)) {
+    if (exports.registeredTypings.has(type)) {
         // TODO Log debug "Typings for enum are already registered"
         return;
     }
@@ -150,7 +214,9 @@ const registerEnumTyping = (protoPackage, message, opts) => {
         ...(opts || { name }),
         values
     });
-    registeredTypings.set(type, {
+    registeredEnumTypes.push(name);
+    typeNameAndNameSpaceMapping.set(name, type);
+    exports.registeredTypings.set(type, {
         output: result,
         input: result,
         meta: message
@@ -158,7 +224,7 @@ const registerEnumTyping = (protoPackage, message, opts) => {
 };
 exports.registerEnumTyping = registerEnumTyping;
 const getTyping = (type) => {
-    return registeredTypings.get(type);
+    return exports.registeredTypings.get(type);
 };
 exports.getTyping = getTyping;
 const resolveMeta = (key, field, rootObjType, objName, input) => {
@@ -173,17 +239,17 @@ const resolveMeta = (key, field, rootObjType, objName, input) => {
         case descriptor_1.FieldDescriptorProto_Type.TYPE_ENUM:
         case descriptor_1.FieldDescriptorProto_Type.TYPE_MESSAGE:
             const objType = field.typeName;
-            if (!registeredTypings.has(objType)) {
+            if (!exports.registeredTypings.has(objType)) {
                 throw new Error("Typing '" + objType + "' not registered for key '" + key + "' in object: " + objName);
             }
             if (!input) {
-                result = registeredTypings.get(objType).output;
+                result = exports.registeredTypings.get(objType).output;
                 break;
             }
             if (objType === types_1.authSubjectType) {
                 return null;
             }
-            result = registeredTypings.get(objType).input;
+            result = exports.registeredTypings.get(objType).input;
             break;
         case descriptor_1.FieldDescriptorProto_Type.TYPE_BYTES:
             if (input) {

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

@@ -1,4 +1,25 @@
+import { TypingData } from './registry';
 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 {};

package/dist/gql/protos/utils.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeBufferFields = exports.getKeys = exports.convertyCamelToSnakeCase = exports.capitalizeProtoName = void 0;
+exports.convertEnumToInt = exports.updateJSON = exports.decodeBufferFields = exports.getKeys = exports.convertyCamelToSnakeCase = exports.capitalizeProtoName = void 0;
 const _ = require("lodash");
+const registry_1 = require("./registry");
 const capitalizeProtoName = (name) => {
     return name.replace(/(?:\.|^|_)(\w)/g, v => v.toUpperCase()).replace(/[._]/g, '');
 };
@@ -48,3 +49,89 @@ const decodeBufferFields = (items, bufferFields) => {
     }
 };
 exports.decodeBufferFields = decodeBufferFields;
+/**
+ * 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
+ */
+const updateJSON = (path, val, obj) => {
+    let fields = path.split('.');
+    let result = obj;
+    let j = 0;
+    for (let i = 0, n = fields.length; i < n && result !== undefined; i++) {
+        let field = fields[i];
+        if (i === n - 1) {
+            // reset value finally after iterating to the position (only if value already exists)
+            if (result[field]) {
+                const foundElement = val.find((e) => e.name === result[field]);
+                result[field] = foundElement === null || foundElement === void 0 ? void 0 : foundElement.number;
+            }
+        }
+        else {
+            if (_.isArray(result[field])) {
+                // till i < n concat new fields
+                let newField = '';
+                for (let k = i + 1; k < n; k++) {
+                    if (newField && !_.isEmpty(newField)) {
+                        newField = newField + '.' + fields[k];
+                    }
+                    else {
+                        newField = fields[k];
+                    }
+                }
+                for (; j < result[field].length; j++) {
+                    // recurisve call to update each element if its an array
+                    exports.updateJSON(newField, val, result[field][j]);
+                }
+            }
+            else {
+                // update object till final path is reached
+                result = result[field];
+            }
+        }
+    }
+};
+exports.updateJSON = updateJSON;
+/**
+ * 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
+ */
+const convertEnumToInt = (inputTyping, req) => {
+    let enumMap = new Map();
+    // enumMap populated with key as enum name space type and value as the path (to replace from request object)
+    if (inputTyping) {
+        const gqlInputObject = inputTyping.input;
+        const gqlFields = gqlInputObject.getFields();
+        if (gqlFields) {
+            const fieldNames = Object.keys(gqlFields);
+            for (let fieldName of fieldNames) {
+                // gql fieldName from input is of format [IIoRestorecommerceResourcebaseSort!]
+                // below check is to remove `[` and `!]`
+                let fieldType = gqlFields[fieldName].type.toString();
+                if (fieldType.startsWith('[') && fieldType.endsWith('!]')) {
+                    fieldType = fieldType.substring(1, fieldType.length - 2);
+                }
+                // if fieldType is not basic type, then check if its fieldType belongs to Enum
+                // if not get the object and make recursive check till no more objects are found
+                if (registry_1.scalarTypes.indexOf(fieldType) <= -1) {
+                    enumMap = registry_1.recursiveEnumCheck(fieldType, enumMap, fieldName, []);
+                }
+            }
+        }
+    }
+    for (let [key, val] of enumMap) {
+        const enumNameSpace = registry_1.getNameSpaceTypeName(key);
+        if (enumNameSpace && typeof enumNameSpace === 'string') {
+            const enumTyping = registry_1.getTyping(enumNameSpace);
+            const enumIntMapping = (enumTyping === null || enumTyping === void 0 ? void 0 : enumTyping.meta).value;
+            if (enumIntMapping && _.isArray(enumIntMapping) && enumIntMapping.length > 0) {
+                exports.updateJSON(val, enumIntMapping, req);
+            }
+        }
+    }
+    return req;
+};
+exports.convertEnumToInt = convertEnumToInt;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@restorecommerce/facade",
-  "version": "0.1.42",
+  "version": "0.1.43",
   "description": "Facade for Restorecommerce microservices",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -101,5 +101,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "39da173ebfb2496f76bd0cb8f041925b2be775ea"
+  "gitHead": "2b4964c14cf0a66ecfaf1e0af2a6d88f9a47fba7"
 }