@izara_project/izara-core-generate-service-code 1.0.74 → 1.0.75

package/src/emit/relationship/templates/UpdateRelationshipComplete_HdrSqs.ejs

@@ -0,0 +1,99 @@
+import { middlewareHandler as middleware } from '@izara_project/izara-middleware';
+import { recordHandlerSharedLib } from '@izara_project/izara-core-library-record-handler';
+import Logger from '@izara_project/izara-core-library-logger';
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+import UpdateRelationshipComplete from './UpdateRelationshipComplete_Main.js';
+
+//(<optionalRequire>)
+//(</optionalRequire>)
+
+// validate event properties in body.Message of sqs event
+let perRecordsValidatorSchema = {
+  type: 'object',
+  properties: {
+    returnValue: {
+      type: 'object'
+    },
+    parentFlowId: {
+      type: 'string'
+    },
+    status: {
+      type: 'string'
+    },
+    errorsFound: {
+      type: 'array'
+    },
+    graphServiceTag: {
+      type: 'string'
+    }
+  },
+  required: [
+    'returnValue',
+    'parentFlowId',
+    'status',
+    'errorsFound',
+    'graphServiceTag'
+  ]
+  //(<validatorSchema>)
+  //(</validatorSchema>)
+};
+
+let messageAttributeValidatorSchema = null;
+middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
+
+export const main = middleware.wrap(async (event, context) => {
+  try {
+    let recordPromises = [];
+
+    // loop each record and send to mainFunction
+    await Promise.all(
+      event.Records.map(async (record) => {
+        let passOnProperties = [];
+        record._izContext.logger.debug('record ReceiveMsgOutHdrSqs', record);
+
+        //validate message (and MessageAttributes)
+        await recordHandlerSharedLib.validateRecord(
+          record, // one record will send to mainFunction
+          'UpdateRelationshipCompleteHdrSqs', // queue name that need to retry or send to dlq
+          perRecordsValidatorSchema, // schema for record.Message
+          messageAttributeValidatorSchema
+        );
+
+        // add argument (to invoke lambda) to passOnProperties[]
+        passOnProperties.push(record.body.Message);
+        passOnProperties.push(
+          callingFlowSharedLib.addPassBackPropertiesToPassOnProperties(
+            record.body.Message
+          )
+        );
+        //(<additionalParams>)
+        //(</additionalParams>)
+        record._izContext.logger.debug(
+          'passOnProperties in handler',
+          passOnProperties
+        );
+
+        // call recordHandlerSharedLib.recordHandler with 3 parameters and return promise(resolve)
+        let recordPromise = recordHandlerSharedLib.recordHandler(
+          record, // one record will send to mainFunction
+          UpdateRelationshipComplete, // mainFunction that need to invoke.
+          'UpdateRelationshipCompleteHdrSqs', // queue name that need to retry or send to dlq
+          passOnProperties // all parameters that mainFunction needed.
+        );
+        record._izContext.logger.debug('after recordPromise in handler');
+        recordPromises.push(recordPromise); // push promise to recordPromises
+      })
+    );
+    try {
+      await Promise.all(recordPromises);
+      return event.Records;
+    } catch {
+      Logger.debug(
+        'Promise.all(recordPromises) in handler threw error (at least one record did no resolve)'
+      );
+    }
+  } catch (error) {
+    Logger.error('Unhandled Error, UpdateRelationshipComplete_HdrSqs: ', error);
+    throw error;
+  }
+});

package/src/emit/relationship/templates/UpdateRelationshipComplete_Main.ejs

@@ -19,7 +19,7 @@ import { objectHash as hash } from '@izara_project/izara-shared-core';
 
 import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
 import snsSharedLib from '@izara_project/izara-core-library-sns';
-import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+
 import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow';
 
 import { sns } from '@izara_project/izara-core-library-external-request';
@@ -43,6 +43,7 @@ export default async function updateRelationshipComplete(
   try {
     const {
       returnValue,
+      parentFlowId,
       status,
       errorsFound,
       graphServiceTag
@@ -50,6 +51,7 @@ export default async function updateRelationshipComplete(
 
     _izContext.logger.debug('Function:updateRelationshipComplete', {
       returnValue: returnValue,
+      parentFlowId: parentFlowId,
       status: status,
       errorsFound: errorsFound,
       graphServiceTag: graphServiceTag,
@@ -57,94 +59,96 @@ export default async function updateRelationshipComplete(
       // callingFlowConfig: callingFlowConfig
     });
 
-    let awaitingStepId = asyncFlowSharedLib.createAwaitingStepId(
-      returnValue.parentFlowId, // hash id
+    const awaitingStepId = asyncFlowSharedLib.createAwaitingStepId(
+      parentFlowId || returnValue?.parentFlowId, // hash id
       PREFIX.updateRel // prefix, use constant further
     );
 
-    let updateRelPendingObjects = await dynamodbSharedLib.query(
-      _izContext,
-      await dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
+    const pending =
+      await asyncFlowSharedLib.findPendingStepAwaitingMultipleSteps(
+        _izContext,
+        awaitingStepId
+      );
+    _izContext.logger.debug('[UpdateRelationshipComplete] awaiting step', {
+      awaitingStepId,
+      pending
+    });
+
+    if (!pending) {
+      _izContext.logger.warn(
+        `No pending step found for awaitingStepId: ${awaitingStepId}`
+      );
+      return { returnValue, status, errorsFound };
+    }
+
+    const result =
+      await asyncFlowSharedLib.checkAllAwaitingStepsFinishedWithReturnParams(
+        _izContext,
+        pending.pendingStepId,
+        awaitingStepId,
+        errorsFound
+      );
+    _izContext.logger.debug(
+      '[UpdateRelationshipComplete] all awaiting steps result',
       {
-        awaitingStepId: awaitingStepId
+        isComplete: result.isComplete,
+        awaitingStepId,
+        pendingStepId: pending.pendingStepId
       }
     );
-    _izContext.logger.debug(
-      'record of updateRelPendingObjects ::',
-      updateRelPendingObjects
-    );
 
-    await Promise.all(
-      updateRelPendingObjects.Items.map(async ({ pendingStepId }) => {
-        if (
-          await asyncFlowSharedLib.checkAllAwaitingStepsFinished(
-            _izContext,
-            pendingStepId, // task waiting
-            awaitingStepId,
-            errorsFound
-          )
-        ) {
-          _izContext.logger.debug('finished all awaitingStep');
-
-          let updateCompleteMsg = {
-            relId: returnValue.requestParams.relId,
-            relType: returnValue.requestParams.relType,
-            status: status,
-            errorsFound: errorsFound
-            //(<inUpdateCompleteMsg>)
-            //(</inUpdateCompleteMsg>)
-          };
-
-          updateCompleteMsg =
-            callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(
-              passBackProperties,
-              updateCompleteMsg
-            );
-          _izContext.logger.debug(
-            'After addCallingFlowToSnsResponseMessageObject',
-            updateCompleteMsg
-          );
-
-          let messageAttributes =
-            callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(
-              passBackProperties,
-              {}
-            );
-          _izContext.logger.debug(
-            'After addCallingFlowToSnsResponseMessageAttributes',
-            updateCompleteMsg
-          );
-
-          let sendMessageToOutUpdateRelationshipComplete = {
-            Message: JSON.stringify(updateCompleteMsg),
-            MessageAttributes: sns.createStringMessageAttributes(
-              _izContext,
-              messageAttributes
-            ),
-            TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
-              _izContext,
-              TOPIC_NAME_GENERATE_CODE.outUpdateRelComplete
-            )
-          };
-          _izContext.logger.debug(
-            'Send message to OutUpdateRelationshipComplete :::>',
-            sendMessageToOutUpdateRelationshipComplete
-          );
-          await sns.publishAsync(
-            _izContext,
-            sendMessageToOutUpdateRelationshipComplete
-          );
-        } // check pendingStepId finished
-
-        // remove awaitingMultipleStep after finished
-        await asyncFlowSharedLib.removeAwaitingMultipleStep(
-          _izContext,
-          awaitingStepId,
-          pendingStepId,
-          errorsFound
+    if (result.isComplete) {
+      _izContext.logger.debug('finished all awaitingStep');
+
+      let updateCompleteMsg = {
+        relId: returnValue.requestParams.relId,
+        relType: returnValue.requestParams.relType,
+        status: status,
+        errorsFound: errorsFound
+        //(<inUpdateCompleteMsg>)
+        //(</inUpdateCompleteMsg>)
+      };
+
+      updateCompleteMsg =
+        callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(
+          passBackProperties,
+          updateCompleteMsg
         );
-      }) // end per pendingStep
-    );
+      _izContext.logger.debug(
+        'After addCallingFlowToSnsResponseMessageObject',
+        updateCompleteMsg
+      );
+
+      let messageAttributes =
+        callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(
+          passBackProperties,
+          {}
+        );
+      _izContext.logger.debug(
+        'After addCallingFlowToSnsResponseMessageAttributes',
+        updateCompleteMsg
+      );
+
+      let sendMessageToOutUpdateRelationshipComplete = {
+        Message: JSON.stringify(updateCompleteMsg),
+        MessageAttributes: sns.createStringMessageAttributes(
+          _izContext,
+          messageAttributes
+        ),
+        TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+          _izContext,
+          TOPIC_NAME_GENERATE_CODE.outUpdateRelComplete
+        )
+      };
+      _izContext.logger.debug(
+        'Send message to OutUpdateRelationshipComplete :::>',
+        sendMessageToOutUpdateRelationshipComplete
+      );
+      await sns.publishAsync(
+        _izContext,
+        sendMessageToOutUpdateRelationshipComplete
+      );
+    } // check isComplete finished
 
     return {
       returnValue,

package/src/emit/resource/emitResourceArtifacts.js

@@ -5,6 +5,7 @@ import {
   customFlowRoleName,
   flowDsqSteps,
   flowExtTopicSteps,
+  generatedDsqFlows,
   generatedOwnTopicFlows,
   supportedCustomFlows
 } from '../custom/customFlows.js';
@@ -74,6 +75,12 @@ const SQS_CONSUMER_ACTIONS = [
   'sqs:GetQueueAttributes',
   'sqs:ReceiveMessage'
 ];
+const SQS_DLQ_ACTIONS = [
+  'sqs:DeleteMessage',
+  'sqs:GetQueueAttributes',
+  'sqs:ReceiveMessage',
+  'sqs:SendMessage'
+];
 
 export async function emitResourceArtifacts({
   objects,
@@ -219,6 +226,9 @@ function createResourceState({ objects, relationships, flows }) {
       ...generatedOwnTopicFlows(flows).map((flow) =>
         customFlowRoleName(flow.flowTag)
       ),
+      ...generatedDsqFlows(flows).map((flow) =>
+        customFlowRoleName(flow.flowTag)
+      ),
       ...flowExtTopicSteps(flows).map(({ flow }) =>
         customFlowRoleName(flow.flowTag)
       ),
@@ -497,6 +507,11 @@ function roleStatements(state, roleName) {
     SQS_CONSUMER_ACTIONS,
     queueArns(roleQueueNames(state, roleName))
   );
+  addStatement(
+    statements,
+    SQS_DLQ_ACTIONS,
+    queueArns(roleDlqQueueNames(state, roleName))
+  );
   addStatement(
     statements,
     ['sns:Publish'],
@@ -649,6 +664,14 @@ function roleQueueNames(state, roleName) {
   return queueList;
 }
 
+function roleDlqQueueNames(state, roleName) {
+  const queues = roleQueueNames(state, roleName);
+  if (!Array.isArray(queues) || queues.length === 0) {
+    return [];
+  }
+  return queues.map((q) => (q.endsWith('DLQ') ? q : `${q}DLQ`));
+}
+
 function roleTopicNames(state, roleName) {
   if (roleName === 'ProcFindDataRole') return [];
   if (roleName === 'FlowObjectsRole')

package/src/emit/shared/templates/FindData_Main.ejs

@@ -94,7 +94,7 @@ export default async function findData(
       fieldName,
       objType,
       identifiers,
-      null,
+      "",
       overWriteCache,
       callingFlow,
       'error'

package/src/emit/system/emitSystemWebSocketArtifacts.js

@@ -3,6 +3,8 @@ import ejsLib from 'ejs';
 
 const TEMPLATE_URL = new URL('./templates/', import.meta.url);
 const SOURCE = 'app/src/generatedCode/SystemFlowSchemas/WebSocketMain/source';
+const REGISTER_SOURCE =
+  'app/src/generatedCode/SystemFlowSchemas/Register/source';
 
 async function _renderSystemTemplate(templateName, data = {}) {
   const templatePath = new URL(templateName, TEMPLATE_URL);
@@ -27,12 +29,32 @@ export async function emitSystemWebSocketArtifacts(
   const webSocketCompleteHdrSqsContent = await _renderSystemTemplate(
     'WebSocketComplete_HdrSqs.ejs'
   );
+  const registerMainContent = await _renderSystemTemplate('Register_Main.ejs');
+  const registerHdrWbsContent = await _renderSystemTemplate(
+    'Register_HdrWbs.ejs'
+  );
+  const registerCompleteMainContent = await _renderSystemTemplate(
+    'RegisterComplete_Main.ejs'
+  );
+  const registerCompleteHdrSqsContent = await _renderSystemTemplate(
+    'RegisterComplete_HdrSqs.ejs',
+    { queueName: 'RegisterComplete' }
+  );
+  const registerCompleteHdrDsqContent = await _renderSystemTemplate(
+    'RegisterComplete_HdrSqs.ejs',
+    { queueName: 'RegisterCompleteDLQ' }
+  );
+
   const webSocketConnectYaml = await _renderSystemTemplate(
     'WebSocketConnect_Yaml.ejs'
   );
   const webSocketCompleteYaml = await _renderSystemTemplate(
     'WebSocketComplete_Yaml.ejs'
   );
+  const registerWbsYaml = await _renderSystemTemplate('RegisterWbs_Yaml.ejs');
+  const registerCompleteYaml = await _renderSystemTemplate(
+    'RegisterComplete_Yaml.ejs'
+  );
 
   return {
     artifacts: [
@@ -47,9 +69,34 @@ export async function emitSystemWebSocketArtifacts(
       {
         path: `${SOURCE}/WebSocketComplete_HdrSqs.js`,
         content: webSocketCompleteHdrSqsContent
+      },
+      {
+        path: `${REGISTER_SOURCE}/Register_Main.js`,
+        content: registerMainContent
+      },
+      {
+        path: `${REGISTER_SOURCE}/Register_HdrWbs.js`,
+        content: registerHdrWbsContent
+      },
+      {
+        path: `${REGISTER_SOURCE}/RegisterComplete_Main.js`,
+        content: registerCompleteMainContent
+      },
+      {
+        path: `${REGISTER_SOURCE}/RegisterComplete_HdrSqs.js`,
+        content: registerCompleteHdrSqsContent
+      },
+      {
+        path: `${REGISTER_SOURCE}/RegisterComplete_HdrDsq.js`,
+        content: registerCompleteHdrDsqContent
       }
     ],
-    functions: [webSocketConnectYaml, webSocketCompleteYaml]
+    functions: [
+      webSocketConnectYaml,
+      webSocketCompleteYaml,
+      registerWbsYaml,
+      registerCompleteYaml
+    ]
   };
 }
 
@@ -57,7 +104,12 @@ export function systemWebSocketManagedPaths() {
   return [
     `${SOURCE}/WebSocketConnect.js`,
     `${SOURCE}/WebSocketComplete_Main.js`,
-    `${SOURCE}/WebSocketComplete_HdrSqs.js`
+    `${SOURCE}/WebSocketComplete_HdrSqs.js`,
+    `${REGISTER_SOURCE}/Register_Main.js`,
+    `${REGISTER_SOURCE}/Register_HdrWbs.js`,
+    `${REGISTER_SOURCE}/RegisterComplete_Main.js`,
+    `${REGISTER_SOURCE}/RegisterComplete_HdrSqs.js`,
+    `${REGISTER_SOURCE}/RegisterComplete_HdrDsq.js`
   ];
 }
 

package/src/emit/system/templates/RegisterComplete_HdrSqs.ejs

@@ -0,0 +1,64 @@
+import { middlewareHandler } from '@izara_project/izara-middleware';
+import Logger from '@izara_project/izara-core-library-logger';
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+import { recordHandlerSharedLib } from '@izara_project/izara-core-library-record-handler';
+import registerCompleteMain from './RegisterComplete_Main.js';
+
+middlewareHandler.setValidatorSchema(
+  recordHandlerSharedLib.baseValidatorSchema()
+);
+let perRecordsValidatorSchema = {};
+
+export const main = middlewareHandler.wrap(async (event, context) => {
+  try {
+    let recordPromises = [];
+
+    await Promise.all(
+      event.Records.map(async (record) => {
+        let passOnProperties = [];
+        record._izContext.logger.debug('record ReceiveMsgOutHdrSqs', record);
+
+        await recordHandlerSharedLib.validateRecord(
+          record,
+          '<%= queueName %>',
+          perRecordsValidatorSchema
+        );
+
+        passOnProperties.push(record.body.TopicArn);
+        passOnProperties.push(record.body.Message);
+        passOnProperties.push(
+          callingFlowSharedLib.addCallingFlowToPassOnProperties(
+            record.body.Message
+          )
+        );
+        record._izContext.logger.debug(
+          'passOnProperties in handler',
+          passOnProperties
+        );
+
+        let recordPromise = recordHandlerSharedLib.recordHandler(
+          record,
+          registerCompleteMain,
+          '<%= queueName %>',
+          passOnProperties
+        );
+        record._izContext.logger.debug('after recordPromise in handler');
+        recordPromises.push(recordPromise);
+      })
+    );
+
+    Logger.debug('before Promise.all(recordPromises) in handler');
+    try {
+      await Promise.all(recordPromises);
+      return event.Records;
+    } catch {
+      Logger.debug(
+        'Promise.all(recordPromises) in handler threw error (at least one record did not resolve)'
+      );
+    }
+    Logger.debug('after Promise.all(recordPromises) in handler');
+  } catch (err) {
+    Logger.error('Unhandled Error, RegisterComplete: ', err);
+    throw err;
+  }
+});

package/src/emit/system/templates/RegisterComplete_Main.ejs

@@ -0,0 +1,154 @@
+import { NoRetryError } from '@izara_project/izara-core-library-core';
+import { objectHash as hash } from '@izara_project/izara-shared-core';
+import { getObjectSchema, identifiersObject } from '@izara_project/izara-core-library-service-schemas';
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
+import { lambda, webSocket } from '@izara_project/izara-core-library-external-request';
+const { postToConnection } = webSocket;
+
+/**
+ * Register complete main handler
+ * @param {Object} _izContext
+ * @param {string} topicArn
+ * @param {Object} requestParams
+ * @param {Object} callingFlowConfig
+ */
+export default async function registerCompleteMain(
+  _izContext,
+  topicArn,
+  requestParams,
+  callingFlowConfig = {}
+) {
+  try {
+    _izContext.logger.debug('WebSocketInvoke _izContext', _izContext);
+    _izContext.logger.debug('WebSocketInvoke requestParams', requestParams);
+    _izContext.logger.debug('WebSocketInvoke callingFlowConfig', callingFlowConfig);
+
+    if (!topicArn) {
+      throw new NoRetryError('invalid not have topicArn to get flowSchema');
+    }
+
+    let topicName = topicArn.split(':')[5].split('_');
+    let flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(_izContext, {
+      flowTag: topicName[2],
+      serviceTag: topicName[0]
+    });
+
+    if (!flowSchema) {
+      throw new NoRetryError('not have flowSchema in S3');
+    }
+
+    let identifiersTask = '';
+
+    if (!requestParams.identifiersTask && flowSchema.objType) {
+      identifiersTask = await identifiersObject.identifiersConcatFromIdentifiers(
+        _izContext,
+        flowSchema.objType,
+        requestParams
+      );
+      _izContext.logger.debug('identifiersTask from request params', identifiersTask);
+
+      Object.assign(requestParams, {
+        identifiersTask: identifiersTask
+      });
+    }
+
+    if (!requestParams.identifiersTask) {
+      _izContext.logger.warn('invalid identifiersTask');
+      return 'invalid identifiersTask';
+    }
+
+    const getResult = async (objType) => {
+      const objectSchema = await getObjectSchema.getObjSchemaS3WithCache(
+        _izContext,
+        {
+          objectType: objType.objectType,
+          serviceTag: objType.serviceTag
+        }
+      );
+
+      _izContext.logger.debug('==> objectSchema', objectSchema);
+
+      let tasks = await dynamodbSharedLib.query(
+        _izContext,
+        await dynamodbSharedLib.tableName(_izContext, 'RegisterRecords'),
+        {
+          identifiersTask: identifiersTask
+        }
+      );
+
+      if (tasks.Items && tasks.Items.length > 0) {
+        const result = await lambda.invokeSync(
+          _izContext,
+          await lambdaSharedLib.lambdaFunctionName(_izContext, 'GetHdrInv'),
+          {
+            identifiers: await identifiersObject.identifiersFromIdentifiersConcat(
+              _izContext,
+              objType,
+              requestParams.identifiersTask
+            ),
+            objectType: objType.objectType
+          }
+        );
+        await Promise.all(
+          tasks.Items.map(async (task) => {
+            if (!result) {
+              await postToConnection({ message: 'not have record' }, task.connectionId);
+            } else {
+              await postToConnection({ message: result }, task.connectionId);
+            }
+          })
+        );
+      }
+    };
+
+    switch (flowSchema.statusType) {
+      case 'statusField':
+        await getResult(flowSchema.objType);
+        break;
+      case 'storedCache':
+        await getResult(flowSchema.objType);
+        break;
+      case 'triggerCache':
+        await getResult(flowSchema.objType);
+        break;
+      case 'none': {
+        let identifier = {};
+        if (
+          requestParams.hasOwnProperty('identifiersField') &&
+          Array.isArray(requestParams.identifiersField)
+        ) {
+          for (const fieldNames of requestParams.identifiersField) {
+            Object.assign(identifier, {
+              [fieldNames]: requestParams[fieldNames]
+            });
+          }
+        } else {
+          identifier = requestParams;
+        }
+
+        let tasks = await dynamodbSharedLib.query(
+          _izContext,
+          await dynamodbSharedLib.tableName(_izContext, 'RegisterRecords'),
+          {
+            identifiersTask: hash(identifier)
+          }
+        );
+
+        if (tasks.Items && tasks.Items.length > 0) {
+          await Promise.all(
+            tasks.Items.map(async (task) => {
+              await postToConnection({ message: task }, task.connectionId);
+            })
+          );
+        }
+        break;
+      }
+      default:
+        throw new NoRetryError(`statusType not found ${flowSchema.statusType}`);
+    }
+  } catch (err) {
+    _izContext.logger.error('error WebSocketInvoke: ', err);
+    throw err;
+  }
+}

package/src/emit/system/templates/RegisterComplete_Yaml.ejs

@@ -0,0 +1,17 @@
+RegisterCompleteHdrSqs:
+  handler: src/generatedCode/SystemFlowSchemas/Register/source/RegisterComplete_HdrSqs.main
+  name: ${self:custom.iz_resourcePrefix}RegisterCompleteHdrSqs
+  role: RegisterRole
+  events:
+    - sqs:
+        arn: arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}RegisterComplete
+        batchSize: 10
+
+RegisterCompleteDsq:
+  handler: src/generatedCode/SystemFlowSchemas/Register/source/RegisterComplete_HdrDsq.main
+  name: ${self:custom.iz_resourcePrefix}RegisterCompleteDsq
+  role: RegisterRole
+  events:
+    - sqs:
+        arn: arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}RegisterCompleteDLQ
+        batchSize: 10