@restorecommerce/facade 0.1.39 → 0.1.43

package/CHANGELOG.md

@@ -3,6 +3,45 @@
 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
+
+
+
+
+
+## [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
+
+
+
+
+
+## [0.1.40](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.1.39...@restorecommerce/facade@0.1.40) (2021-12-21)
+
+**Note:** Version bump only for package @restorecommerce/facade
+
+
+
+
+
 ## [0.1.39](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@0.1.38...@restorecommerce/facade@0.1.39) (2021-12-20)
 
 **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'];
@@ -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,7 +184,12 @@ 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 };
@@ -242,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}`);
@@ -352,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());
     }
@@ -374,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';
@@ -590,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);
 };
@@ -617,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/dist/modules/access-control/gql/schema.generated.d.ts

@@ -55,7 +55,7 @@ export declare type ProtoIoRestorecommerceAccessControlResponse = {
 export declare type IoRestorecommerceAccessControlResponse = {
     __typename?: 'IoRestorecommerceAccessControlResponse';
     decision?: Maybe<IoRestorecommerceAccessControlResponseDecision>;
-    obligation?: Maybe<Scalars['String']>;
+    obligation?: Maybe<Array<IoRestorecommerceAttributeAttribute>>;
     evaluationCacheable?: Maybe<Scalars['Boolean']>;
     operationStatus?: Maybe<IoRestorecommerceStatusOperationStatus>;
 };
@@ -65,6 +65,12 @@ export declare enum IoRestorecommerceAccessControlResponseDecision {
     NotApplicable = 2,
     Indeterminate = 3
 }
+export declare type IoRestorecommerceAttributeAttribute = {
+    __typename?: 'IoRestorecommerceAttributeAttribute';
+    id?: Maybe<Scalars['String']>;
+    value?: Maybe<Scalars['String']>;
+    attribute?: Maybe<Array<IoRestorecommerceAttributeAttribute>>;
+};
 export declare type IoRestorecommerceStatusOperationStatus = {
     __typename?: 'IoRestorecommerceStatusOperationStatus';
     code?: Maybe<Scalars['Int']>;
@@ -100,6 +106,7 @@ export declare type ProtoIoRestorecommerceAccessControlReverseQuery = {
 export declare type IoRestorecommerceAccessControlReverseQuery = {
     __typename?: 'IoRestorecommerceAccessControlReverseQuery';
     policySets?: Maybe<Array<IoRestorecommercePolicySetPolicySetRq>>;
+    obligation?: Maybe<Array<IoRestorecommerceAttributeAttribute>>;
     operationStatus?: Maybe<IoRestorecommerceStatusOperationStatus>;
 };
 export declare type IoRestorecommercePolicySetPolicySetRq = {
@@ -116,12 +123,6 @@ export declare type IoRestorecommerceRuleTarget = {
     resources?: Maybe<Array<IoRestorecommerceAttributeAttribute>>;
     action?: Maybe<Array<IoRestorecommerceAttributeAttribute>>;
 };
-export declare type IoRestorecommerceAttributeAttribute = {
-    __typename?: 'IoRestorecommerceAttributeAttribute';
-    id?: Maybe<Scalars['String']>;
-    value?: Maybe<Scalars['String']>;
-    attribute?: Maybe<Array<IoRestorecommerceAttributeAttribute>>;
-};
 export declare type IoRestorecommercePolicyPolicyRq = {
     __typename?: 'IoRestorecommercePolicyPolicyRQ';
     id?: Maybe<Scalars['String']>;
@@ -525,6 +526,7 @@ export declare type ResolversTypes = ResolversObject<{
     ProtoIoRestorecommerceAccessControlResponse: ResolverTypeWrapper<ProtoIoRestorecommerceAccessControlResponse>;
     IoRestorecommerceAccessControlResponse: ResolverTypeWrapper<IoRestorecommerceAccessControlResponse>;
     IoRestorecommerceAccessControlResponseDecision: IoRestorecommerceAccessControlResponseDecision;
+    IoRestorecommerceAttributeAttribute: ResolverTypeWrapper<IoRestorecommerceAttributeAttribute>;
     String: ResolverTypeWrapper<Scalars['String']>;
     Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
     IoRestorecommerceStatusOperationStatus: ResolverTypeWrapper<IoRestorecommerceStatusOperationStatus>;
@@ -539,7 +541,6 @@ export declare type ResolversTypes = ResolversObject<{
     IoRestorecommerceAccessControlReverseQuery: ResolverTypeWrapper<IoRestorecommerceAccessControlReverseQuery>;
     IoRestorecommercePolicySetPolicySetRQ: ResolverTypeWrapper<IoRestorecommercePolicySetPolicySetRq>;
     IoRestorecommerceRuleTarget: ResolverTypeWrapper<IoRestorecommerceRuleTarget>;
-    IoRestorecommerceAttributeAttribute: ResolverTypeWrapper<IoRestorecommerceAttributeAttribute>;
     IoRestorecommercePolicyPolicyRQ: ResolverTypeWrapper<IoRestorecommercePolicyPolicyRq>;
     IoRestorecommerceRuleRuleRQ: ResolverTypeWrapper<IoRestorecommerceRuleRuleRq>;
     IoRestorecommerceRuleEffect: IoRestorecommerceRuleEffect;
@@ -605,6 +606,7 @@ export declare type ResolversParentTypes = ResolversObject<{
     AccessControlAccessControlQuery: AccessControlAccessControlQuery;
     ProtoIoRestorecommerceAccessControlResponse: ProtoIoRestorecommerceAccessControlResponse;
     IoRestorecommerceAccessControlResponse: IoRestorecommerceAccessControlResponse;
+    IoRestorecommerceAttributeAttribute: IoRestorecommerceAttributeAttribute;
     String: Scalars['String'];
     Boolean: Scalars['Boolean'];
     IoRestorecommerceStatusOperationStatus: IoRestorecommerceStatusOperationStatus;
@@ -619,7 +621,6 @@ export declare type ResolversParentTypes = ResolversObject<{
     IoRestorecommerceAccessControlReverseQuery: IoRestorecommerceAccessControlReverseQuery;
     IoRestorecommercePolicySetPolicySetRQ: IoRestorecommercePolicySetPolicySetRq;
     IoRestorecommerceRuleTarget: IoRestorecommerceRuleTarget;
-    IoRestorecommerceAttributeAttribute: IoRestorecommerceAttributeAttribute;
     IoRestorecommercePolicyPolicyRQ: IoRestorecommercePolicyPolicyRq;
     IoRestorecommerceRuleRuleRQ: IoRestorecommerceRuleRuleRq;
     IoRestorecommerceRuleContextQuery: IoRestorecommerceRuleContextQuery;
@@ -690,7 +691,7 @@ export declare type ProtoIoRestorecommerceAccessControlResponseResolvers<Context
 }>;
 export declare type IoRestorecommerceAccessControlResponseResolvers<ContextType = AccessControlContext, ParentType extends ResolversParentTypes['IoRestorecommerceAccessControlResponse'] = ResolversParentTypes['IoRestorecommerceAccessControlResponse']> = ResolversObject<{
     decision?: Resolver<Maybe<ResolversTypes['IoRestorecommerceAccessControlResponseDecision']>, ParentType, ContextType>;
-    obligation?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    obligation?: Resolver<Maybe<Array<ResolversTypes['IoRestorecommerceAttributeAttribute']>>, ParentType, ContextType>;
     evaluationCacheable?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
     operationStatus?: Resolver<Maybe<ResolversTypes['IoRestorecommerceStatusOperationStatus']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
@@ -701,6 +702,12 @@ export declare type IoRestorecommerceAccessControlResponseDecisionResolvers = {
     NOT_APPLICABLE: 2;
     INDETERMINATE: 3;
 };
+export declare type IoRestorecommerceAttributeAttributeResolvers<ContextType = AccessControlContext, ParentType extends ResolversParentTypes['IoRestorecommerceAttributeAttribute'] = ResolversParentTypes['IoRestorecommerceAttributeAttribute']> = ResolversObject<{
+    id?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    value?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    attribute?: Resolver<Maybe<Array<ResolversTypes['IoRestorecommerceAttributeAttribute']>>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
 export declare type IoRestorecommerceStatusOperationStatusResolvers<ContextType = AccessControlContext, ParentType extends ResolversParentTypes['IoRestorecommerceStatusOperationStatus'] = ResolversParentTypes['IoRestorecommerceStatusOperationStatus']> = ResolversObject<{
     code?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
     message?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
@@ -715,6 +722,7 @@ export declare type ProtoIoRestorecommerceAccessControlReverseQueryResolvers<Con
 }>;
 export declare type IoRestorecommerceAccessControlReverseQueryResolvers<ContextType = AccessControlContext, ParentType extends ResolversParentTypes['IoRestorecommerceAccessControlReverseQuery'] = ResolversParentTypes['IoRestorecommerceAccessControlReverseQuery']> = ResolversObject<{
     policySets?: Resolver<Maybe<Array<ResolversTypes['IoRestorecommercePolicySetPolicySetRQ']>>, ParentType, ContextType>;
+    obligation?: Resolver<Maybe<Array<ResolversTypes['IoRestorecommerceAttributeAttribute']>>, ParentType, ContextType>;
     operationStatus?: Resolver<Maybe<ResolversTypes['IoRestorecommerceStatusOperationStatus']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
@@ -732,12 +740,6 @@ export declare type IoRestorecommerceRuleTargetResolvers<ContextType = AccessCon
     action?: Resolver<Maybe<Array<ResolversTypes['IoRestorecommerceAttributeAttribute']>>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
-export declare type IoRestorecommerceAttributeAttributeResolvers<ContextType = AccessControlContext, ParentType extends ResolversParentTypes['IoRestorecommerceAttributeAttribute'] = ResolversParentTypes['IoRestorecommerceAttributeAttribute']> = ResolversObject<{
-    id?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
-    value?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
-    attribute?: Resolver<Maybe<Array<ResolversTypes['IoRestorecommerceAttributeAttribute']>>, ParentType, ContextType>;
-    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
-}>;
 export declare type IoRestorecommercePolicyPolicyRqResolvers<ContextType = AccessControlContext, ParentType extends ResolversParentTypes['IoRestorecommercePolicyPolicyRQ'] = ResolversParentTypes['IoRestorecommercePolicyPolicyRQ']> = ResolversObject<{
     id?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     target?: Resolver<Maybe<ResolversTypes['IoRestorecommerceRuleTarget']>, ParentType, ContextType>;
@@ -977,13 +979,13 @@ export declare type Resolvers<ContextType = AccessControlContext> = ResolversObj
     ProtoIoRestorecommerceAccessControlResponse?: ProtoIoRestorecommerceAccessControlResponseResolvers<ContextType>;
     IoRestorecommerceAccessControlResponse?: IoRestorecommerceAccessControlResponseResolvers<ContextType>;
     IoRestorecommerceAccessControlResponseDecision?: IoRestorecommerceAccessControlResponseDecisionResolvers;
+    IoRestorecommerceAttributeAttribute?: IoRestorecommerceAttributeAttributeResolvers<ContextType>;
     IoRestorecommerceStatusOperationStatus?: IoRestorecommerceStatusOperationStatusResolvers<ContextType>;
     Upload?: GraphQLScalarType;
     ProtoIoRestorecommerceAccessControlReverseQuery?: ProtoIoRestorecommerceAccessControlReverseQueryResolvers<ContextType>;
     IoRestorecommerceAccessControlReverseQuery?: IoRestorecommerceAccessControlReverseQueryResolvers<ContextType>;
     IoRestorecommercePolicySetPolicySetRQ?: IoRestorecommercePolicySetPolicySetRqResolvers<ContextType>;
     IoRestorecommerceRuleTarget?: IoRestorecommerceRuleTargetResolvers<ContextType>;
-    IoRestorecommerceAttributeAttribute?: IoRestorecommerceAttributeAttributeResolvers<ContextType>;
     IoRestorecommercePolicyPolicyRQ?: IoRestorecommercePolicyPolicyRqResolvers<ContextType>;
     IoRestorecommerceRuleRuleRQ?: IoRestorecommerceRuleRuleRqResolvers<ContextType>;
     IoRestorecommerceRuleEffect?: IoRestorecommerceRuleEffectResolvers;