@restorecommerce/facade 0.1.41 → 0.2.0

package/CHANGELOG.md

@@ -3,6 +3,51 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [0.2.0](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.1.44...@restorecommerce/facade@0.2.0) (2022-02-09)
+
+
+### Features
+
+* add oauth ([3e7798e](https://github.com/restorecommerce/libs/commit/3e7798e3aa10ef092872928f5254cd5fbb125f3b))
+
+
+
+
+
+## [0.1.44](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.1.43...@restorecommerce/facade@0.1.44) (2022-02-02)
+
+
+### Bug Fixes
+
+* **facade:** for recursive circular references (ex: attributes -> having nested attributes) ([59c2904](https://github.com/restorecommerce/libs/commit/59c29049c23ecb5f3265ea37a6757ca551023b38))
+
+
+
+
+
+## [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
+
+
+
+
+
 ## [0.1.41](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.1.40...@restorecommerce/facade@0.1.41) (2021-12-22)
 
 **Note:** Version bump only for package @restorecommerce/facade

package/debug-run.ts

@@ -51,6 +51,7 @@ function createTestFacade() {
         ],
         jwks,
       },
+      oauth: true,
       apiKey: 'api_key'
     }))
     .useModule(resourceModule({config: serviceConfig.get('resource')}))

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'];
@@ -142,17 +144,21 @@ const getGQLResolverFunctions = (service, key, serviceKey, grpcClientConfig) =>
                     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 (!response) {
-                                response = chunk;
+                            if (!combinedChunks) {
+                                combinedChunks = chunk;
                             }
                             else {
-                                Object.assign(response, chunk);
+                                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 = [];
                                     }
@@ -178,18 +184,30 @@ const getGQLResolverFunctions = (service, key, serviceKey, grpcClientConfig) =>
                                 operationStatus.code = 200;
                                 operationStatus.message = 'success';
                             }
-                            resolve(response);
+                            if (!_.isEmpty(response)) {
+                                resolve(response);
+                            }
+                            else if (!_.isEmpty(combinedChunks)) {
+                                resolve(combinedChunks);
+                            }
                         });
                     });
                     return { details: aggregatedResponse, operationStatus };
                 }
-                let items = utils_1.decodeBufferFields(result.items, bufferFields);
-                return {
-                    details: {
-                        items: items,
-                        operationStatus: result.operationStatus // overall status
-                    },
-                };
+                if ('items' in result) {
+                    let items = utils_1.decodeBufferFields(result.items, bufferFields);
+                    return {
+                        details: {
+                            items: items,
+                            operationStatus: result.operationStatus // overall status
+                        },
+                    };
+                }
+                else {
+                    return {
+                        details: utils_1.decodeBufferFields([result], bufferFields)[0]
+                    };
+                }
             }
             catch (error) {
                 console.error(error);
@@ -242,6 +260,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}`);
@@ -352,7 +376,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());
     }
@@ -374,6 +398,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';
@@ -590,7 +621,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);
 };
@@ -617,7 +648,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,65 @@ 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
+                        if (exports.scalarTypes.indexOf(fieldType) <= -1) {
+                            // check if fieldName already exists in the traversedFields (to avoid circular reference for infinite loop)
+                            if (traversedFields.indexOf(fieldName) <= -1) {
+                                traversedFields.push(fieldName);
+                            }
+                            else if (traversedFields.indexOf(fieldName) > -1) {
+                                // 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);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return enumMap;
+};
+exports.recursiveEnumCheck = recursiveEnumCheck;
 const registerMessageTypesRecursive = (packageName, methodDef, ...types) => {
     types.forEach(m => {
         exports.registerTyping(packageName, m, methodDef);
@@ -78,7 +136,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 +183,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 +194,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 +209,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 +219,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 +234,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;