@izara_project/izara-core-generate-service-code 1.0.84 → 1.0.85

package/src/emit/rbac/templates/CancelUsage_Main.ejs

@@ -22,35 +22,68 @@ import { consts, NoRetryError } from '@izara_project/izara-core-library-core';
 
 export default async function CancelUsage(_izContext, requestParams) {
   try {
+    let runningTotalReservedId =
+      requestParams?.runningTotalReservedId ||
+      requestParams?.reservedId ||
+      requestParams?.runningTotalReservedUsageId;
+
+    const usedTimestampId =
+      requestParams?.usedTimestampId ||
+      requestParams?.uniqueIdentify;
+
     const submittedByUserId =
-      requestParams.submittedByUserId ||
+      requestParams?.submittedByUserId ||
       _izContext.correlationIds?.get(consts.SUBMITTED_BY_USER_ID);
-    const { limitTag, uniqueIdentify } = requestParams;
+    const flowTypeConcat =
+      requestParams?.flowTypeConcat ||
+      requestParams?.limitTag;
 
-    const targetIdentifiers = requestParams.targetIdentifiers;
-    let identifiersConcat = requestParams.identifiersConcat;
+    const targetIdentifiers = requestParams?.targetIdentifiers;
+    let identifiersConcat = requestParams?.identifiersConcat;
     if (!identifiersConcat && targetIdentifiers && typeof targetIdentifiers === 'object') {
-      identifiersConcat = Object.entries(targetIdentifiers)
-        .map(([k, v]) => `${k}#${v}`)
-        .join('_');
+      if (targetIdentifiers.identifierConcat) {
+        identifiersConcat = targetIdentifiers.identifierConcat;
+      } else {
+        const sortedKeys = Object.keys(targetIdentifiers).sort();
+        const parts = [];
+        for (const key of sortedKeys) {
+          const value = targetIdentifiers[key];
+          if (
+            key !== 'submittedByUserId' &&
+            key !== 'identifierConcat' &&
+            value !== undefined &&
+            value !== null
+          ) {
+            parts.push(`${key}#${value}`);
+          }
+        }
+        if (parts.length > 0) {
+          identifiersConcat = parts.join('|');
+        }
+      }
     }
     if (!identifiersConcat) {
       identifiersConcat = submittedByUserId;
     }
 
-    if (!identifiersConcat || !limitTag || !uniqueIdentify) {
+    if (!runningTotalReservedId) {
+      if (identifiersConcat && flowTypeConcat) {
+        runningTotalReservedId = `${identifiersConcat}_${flowTypeConcat}`;
+      }
+    }
+
+    if (!runningTotalReservedId || !usedTimestampId) {
       throw new NoRetryError(
-        'identifiersConcat, limitTag, and uniqueIdentify are required.'
+        'runningTotalReservedId (or identifiersConcat + flowTypeConcat) and usedTimestampId (or uniqueIdentify) are required.'
       );
     }
 
-    const runningTotalReservedId = `${identifiersConcat}_${limitTag}`;
     const reservedRecord = await dynamodbSharedLib.getItem(
       _izContext,
       dynamodbSharedLib.tableName(_izContext, 'RunningTotalReservedUsage'),
       {
         runningTotalReservedId,
-        usedTimestampId: uniqueIdentify
+        usedTimestampId
       }
     );
 
@@ -61,36 +94,63 @@ export default async function CancelUsage(_izContext, requestParams) {
       dynamodbSharedLib.tableName(_izContext, 'RunningTotalReservedUsage'),
       {
         runningTotalReservedId,
-        usedTimestampId: uniqueIdentify
+        usedTimestampId
       },
       {
         runningTotalUsageStatus: 'cancelled'
       }
     );
 
-    if (usageCount > 0) {
+    if (usageCount > 0 && identifiersConcat && flowTypeConcat) {
       const usageRecord = await dynamodbSharedLib.getItem(
         _izContext,
         dynamodbSharedLib.tableName(_izContext, 'RunningTotalUsage'),
-        { identifiersConcat, limitTag }
+        { identifiersConcat, flowTypeConcat }
       );
       if (usageRecord) {
-        const newTotal = Math.max(0, (usageRecord.totalCount || 0) - usageCount);
-        await dynamodbSharedLib.putItem(
+        const currentTotal = usageRecord.totalCount || 0;
+        const newTotal = Math.max(0, currentTotal - usageCount);
+        const queryElementsWhenUpdate = {
+          additionalAttributes: { currentUuid: usageRecord.updateUuid },
+          logicalElements: [
+            {
+              type: 'logical',
+              comparison: 'equals',
+              lhsAttribute: 'updateUuid',
+              rhsReference: 'currentUuid'
+            }
+          ],
+          returnValues: 'ALL_NEW'
+        };
+
+        const updateAttributes = [
+          { attributeName: 'totalCount', action: 'set', value: newTotal },
+          { attributeName: 'updateUuid', action: 'set', value: _izContext.uniqueRequestId || `${Date.now()}` }
+        ];
+
+        await dynamodbSharedLib.updateItem(
           _izContext,
           dynamodbSharedLib.tableName(_izContext, 'RunningTotalUsage'),
+          { identifiersConcat, flowTypeConcat },
+          updateAttributes,
+          queryElementsWhenUpdate,
           {
-            identifiersConcat,
-            limitTag,
-            totalCount: newTotal,
-            updateUuid: _izContext.uniqueRequestId || `${Date.now()}`
+            complexAttributes: true,
+            errorOnConditionalExpNotPass: false
           }
-        );
+        ).catch(() => null);
       }
     }
 
     await sns.publishMessage(_izContext, {
-      message: { returnResult: { status: true, uniqueIdentify } },
+      message: {
+        returnResult: {
+          status: true,
+          uniqueIdentify: usedTimestampId,
+          usedTimestampId,
+          runningTotalReservedId
+        }
+      },
       TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
         _izContext,
         'CancelUsage_Out'

package/src/emit/rbac/templates/ConfirmUsage_Main.ejs

@@ -22,43 +22,159 @@ import { consts, NoRetryError } from '@izara_project/izara-core-library-core';
 
 export default async function ConfirmUsage(_izContext, requestParams) {
   try {
+    let runningTotalReservedId =
+      requestParams?.runningTotalReservedId ||
+      requestParams?.reservedId ||
+      requestParams?.runningTotalReservedUsageId;
+
+    const usedTimestampId =
+      requestParams?.usedTimestampId ||
+      requestParams?.uniqueIdentify;
+
     const submittedByUserId =
-      requestParams.submittedByUserId ||
+      requestParams?.submittedByUserId ||
       _izContext.correlationIds?.get(consts.SUBMITTED_BY_USER_ID);
-    const { limitTag, uniqueIdentify } = requestParams;
+    const flowTypeConcat =
+      requestParams?.flowTypeConcat ||
+      requestParams?.limitTag;
 
-    const targetIdentifiers = requestParams.targetIdentifiers;
-    let identifiersConcat = requestParams.identifiersConcat;
+    const targetIdentifiers = requestParams?.targetIdentifiers;
+    let identifiersConcat = requestParams?.identifiersConcat;
     if (!identifiersConcat && targetIdentifiers && typeof targetIdentifiers === 'object') {
-      identifiersConcat = Object.entries(targetIdentifiers)
-        .map(([k, v]) => `${k}#${v}`)
-        .join('_');
+      if (targetIdentifiers.identifierConcat) {
+        identifiersConcat = targetIdentifiers.identifierConcat;
+      } else {
+        const sortedKeys = Object.keys(targetIdentifiers).sort();
+        const parts = [];
+        for (const key of sortedKeys) {
+          const value = targetIdentifiers[key];
+          if (
+            key !== 'submittedByUserId' &&
+            key !== 'identifierConcat' &&
+            value !== undefined &&
+            value !== null
+          ) {
+            parts.push(`${key}#${value}`);
+          }
+        }
+        if (parts.length > 0) {
+          identifiersConcat = parts.join('|');
+        }
+      }
     }
     if (!identifiersConcat) {
       identifiersConcat = submittedByUserId;
     }
 
-    if (!identifiersConcat || !limitTag || !uniqueIdentify) {
+    if (!runningTotalReservedId) {
+      if (identifiersConcat && flowTypeConcat) {
+        runningTotalReservedId = `${identifiersConcat}_${flowTypeConcat}`;
+      }
+    }
+
+    if (!runningTotalReservedId || !usedTimestampId) {
       throw new NoRetryError(
-        'identifiersConcat, limitTag, and uniqueIdentify are required.'
+        'runningTotalReservedId (or identifiersConcat + flowTypeConcat) and usedTimestampId (or uniqueIdentify) are required.'
       );
     }
 
-    const runningTotalReservedId = `${identifiersConcat}_${limitTag}`;
+    const reservedTable = dynamodbSharedLib.tableName(
+      _izContext,
+      'RunningTotalReservedUsage'
+    );
+
+    const reservedRecord = await dynamodbSharedLib
+      .getItem(_izContext, reservedTable, {
+        runningTotalReservedId,
+        usedTimestampId
+      })
+      .catch(() => null);
+
+    let usageCount = 1;
+    if (reservedRecord && typeof reservedRecord.usageCount === 'number') {
+      usageCount = reservedRecord.usageCount;
+    }
+
     await dynamodbSharedLib.updateItem(
       _izContext,
-      dynamodbSharedLib.tableName(_izContext, 'RunningTotalReservedUsage'),
+      reservedTable,
       {
         runningTotalReservedId,
-        usedTimestampId: uniqueIdentify
+        usedTimestampId
       },
       {
-        runningTotalUsageStatus: 'confirmed'
+        runningTotalUsageStatus: 'confirmed',
+        confirmedAt: new Date().toISOString()
       }
     );
 
+    if (identifiersConcat && flowTypeConcat) {
+      const usageTable = dynamodbSharedLib.tableName(
+        _izContext,
+        'RunningTotalUsage'
+      );
+
+      const usageRecord = await dynamodbSharedLib
+        .getItem(_izContext, usageTable, {
+          identifiersConcat,
+          flowTypeConcat
+        })
+        .catch(() => null);
+
+      let currentTotal = 0;
+      let queryElementsWhenUpdate = {};
+
+      if (usageRecord && typeof usageRecord.totalCount === 'number') {
+        currentTotal = usageRecord.totalCount;
+        queryElementsWhenUpdate = {
+          additionalAttributes: { currentUuid: usageRecord.updateUuid },
+          logicalElements: [
+            {
+              type: 'logical',
+              comparison: 'equals',
+              lhsAttribute: 'updateUuid',
+              rhsReference: 'currentUuid'
+            }
+          ],
+          returnValues: 'ALL_NEW'
+        };
+      } else {
+        queryElementsWhenUpdate = {
+          logicalElements: dynamodbSharedLib.generateNotExistLogicalElements({
+            identifiersConcat,
+            flowTypeConcat
+          }),
+          returnValues: 'ALL_NEW'
+        };
+      }
+
+      const updateAttributes = [
+        { attributeName: 'totalCount', action: 'set', value: currentTotal + usageCount },
+        { attributeName: 'updateUuid', action: 'set', value: _izContext.uniqueRequestId || `${Date.now()}` }
+      ];
+
+      await dynamodbSharedLib.updateItem(
+        _izContext,
+        usageTable,
+        { identifiersConcat, flowTypeConcat },
+        updateAttributes,
+        queryElementsWhenUpdate,
+        {
+          complexAttributes: true,
+          errorOnConditionalExpNotPass: false
+        }
+      ).catch(() => null);
+    }
+
     await sns.publishMessage(_izContext, {
-      message: { returnResult: { status: true, uniqueIdentify } },
+      message: {
+        returnResult: {
+          status: true,
+          uniqueIdentify: usedTimestampId,
+          usedTimestampId,
+          runningTotalReservedId
+        }
+      },
       TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
         _izContext,
         'ConfirmUsage_Out'

package/src/emit/rbac/templates/CreateTargetRole_Main.ejs

@@ -30,9 +30,26 @@ export default async function CreateTargetRole(_izContext, requestParams) {
     const targetIdentifiers = requestParams.targetIdentifiers;
     let identifiersConcat = requestParams.identifiersConcat;
     if (!identifiersConcat && targetIdentifiers && typeof targetIdentifiers === 'object') {
-      identifiersConcat = Object.entries(targetIdentifiers)
-        .map(([k, v]) => `${k}#${v}`)
-        .join('_');
+      if (targetIdentifiers.identifierConcat) {
+        identifiersConcat = targetIdentifiers.identifierConcat;
+      } else {
+        const sortedKeys = Object.keys(targetIdentifiers).sort();
+        const parts = [];
+        for (const key of sortedKeys) {
+          const value = targetIdentifiers[key];
+          if (
+            key !== 'submittedByUserId' &&
+            key !== 'identifierConcat' &&
+            value !== undefined &&
+            value !== null
+          ) {
+            parts.push(`${key}#${value}`);
+          }
+        }
+        if (parts.length > 0) {
+          identifiersConcat = parts.join('|');
+        }
+      }
     }
     if (!identifiersConcat) {
       identifiersConcat = submittedByUserId;
@@ -57,20 +74,22 @@ export default async function CreateTargetRole(_izContext, requestParams) {
       try {
         await dynamodbSharedLib.transactWriteItems(_izContext, [
           {
-            Put: {
-              TableName: dynamodbSharedLib.tableName(_izContext, 'RoleUsers'),
-              Item: { roleIdKey, submittedByUserId }
+            action: 'put',
+            params: {
+              tableName: dynamodbSharedLib.tableName(_izContext, 'RoleUsers'),
+              attributes: { roleIdKey, submittedByUserId }
             }
           },
           {
-            Put: {
-              TableName: dynamodbSharedLib.tableName(_izContext, 'UserRoles'),
-              Item: { submittedByUserId, roleIdKey }
+            action: 'put',
+            params: {
+              tableName: dynamodbSharedLib.tableName(_izContext, 'UserRoles'),
+              attributes: { submittedByUserId, roleIdKey }
             }
           }
         ]);
       } catch (assignError) {
-        _izContext.logger.debug(`[${process.env.iz_serviceTag}:CreateTargetRole] UserRoles transactWrite ignored:', assignError);
+        _izContext.logger.debug(`[${process.env.iz_serviceTag}:CreateTargetRole] UserRoles transactWrite ignored:`, assignError);
       }
     }
 

package/src/emit/rbac/templates/ReservedDynamicUsage_Main.ejs

@@ -25,8 +25,10 @@ export default async function ReservedDynamicUsage(_izContext, requestParams) {
     const submittedByUserId =
       requestParams.submittedByUserId ||
       _izContext.correlationIds?.get(consts.SUBMITTED_BY_USER_ID);
+    const flowTypeConcat =
+      requestParams.flowTypeConcat ||
+      requestParams.limitTag;
     const {
-      limitTag,
       value = 1,
       usedTimestamp = new Date().toISOString(),
       roleLimitId
@@ -35,9 +37,26 @@ export default async function ReservedDynamicUsage(_izContext, requestParams) {
     const targetIdentifiers = requestParams.targetIdentifiers;
     let identifiersConcat = requestParams.identifiersConcat;
     if (!identifiersConcat && targetIdentifiers && typeof targetIdentifiers === 'object') {
-      identifiersConcat = Object.entries(targetIdentifiers)
-        .map(([k, v]) => `${k}#${v}`)
-        .join('_');
+      if (targetIdentifiers.identifierConcat) {
+        identifiersConcat = targetIdentifiers.identifierConcat;
+      } else {
+        const sortedKeys = Object.keys(targetIdentifiers).sort();
+        const parts = [];
+        for (const key of sortedKeys) {
+          const value = targetIdentifiers[key];
+          if (
+            key !== 'submittedByUserId' &&
+            key !== 'identifierConcat' &&
+            value !== undefined &&
+            value !== null
+          ) {
+            parts.push(`${key}#${value}`);
+          }
+        }
+        if (parts.length > 0) {
+          identifiersConcat = parts.join('|');
+        }
+      }
     }
     if (!identifiersConcat) {
       identifiersConcat = submittedByUserId;
@@ -46,14 +65,14 @@ export default async function ReservedDynamicUsage(_izContext, requestParams) {
     if (!identifiersConcat) {
       throw new NoRetryError('Identifier not found.');
     }
-    if (!limitTag) {
-      throw new NoRetryError('limitTag is required.');
+    if (!flowTypeConcat) {
+      throw new NoRetryError('flowTypeConcat (or limitTag) is required.');
     }
 
     const uniqueIdentify = `${usedTimestamp}_${_izContext.uniqueRequestId || Date.now()}`;
     const roleLimitKeys = Array.isArray(requestParams.roleLimitIds)
       ? requestParams.roleLimitIds
-      : [roleLimitId || `${identifiersConcat}_${limitTag}`];
+      : [roleLimitId || `${identifiersConcat}_${flowTypeConcat}`];
 
     let maxLimit = Infinity;
     const limitRecords = [];
@@ -93,7 +112,7 @@ export default async function ReservedDynamicUsage(_izContext, requestParams) {
     const usageRecord = await dynamodbSharedLib.getItem(
       _izContext,
       dynamodbSharedLib.tableName(_izContext, 'RunningTotalUsage'),
-      { identifiersConcat, limitTag }
+      { identifiersConcat, flowTypeConcat }
     );
     const currentTotal = usageRecord?.totalCount || 0;
 
@@ -106,7 +125,7 @@ export default async function ReservedDynamicUsage(_izContext, requestParams) {
         _izContext,
         dynamodbSharedLib.tableName(_izContext, 'RunningTotalReservedUsage'),
         {
-          runningTotalReservedId: `${identifiersConcat}_${limitTag}`,
+          runningTotalReservedId: `${identifiersConcat}_${flowTypeConcat}`,
           usedTimestampId: uniqueIdentify,
           usageCount: value,
           runningTotalUsageStatus: 'reserved',
@@ -119,7 +138,7 @@ export default async function ReservedDynamicUsage(_izContext, requestParams) {
         dynamodbSharedLib.tableName(_izContext, 'RunningTotalUsage'),
         {
           identifiersConcat,
-          limitTag,
+          flowTypeConcat,
           totalCount: currentTotal + value,
           updateUuid: _izContext.uniqueRequestId || `${Date.now()}`
         }
@@ -129,7 +148,7 @@ export default async function ReservedDynamicUsage(_izContext, requestParams) {
     const returnResult = {
       passStatus,
       uniqueIdentify,
-      limitTag,
+      flowTypeConcat,
       identifiersConcat
     };
 

package/src/emit/rbac/templates/UserRbacFlow_Main.ejs

@@ -92,12 +92,37 @@ async function _setL2Cache(_izContext, submittedByUserId, cacheSubKey, value) {
 export default async function <%- flowTag %>(_izContext, requestParams = {}) {
   const submittedByUserId =
     requestParams.submittedByUserId ||
+    requestParams.targetIdentifiers?.submittedByUserId ||
     _izContext.correlationIds.get(consts.SUBMITTED_BY_USER_ID);
 
   const targetIdentifiers = requestParams.targetIdentifiers;
-  let targetId = targetIdentifiers && typeof targetIdentifiers === 'object'
-    ? Object.entries(targetIdentifiers).map(([k, v]) => `${k}#${v}`).join('_')
-    : undefined;
+  let targetId = '';
+  if (targetIdentifiers) {
+    if (typeof targetIdentifiers === 'string') {
+      targetId = targetIdentifiers;
+    } else if (typeof targetIdentifiers === 'object') {
+      if (targetIdentifiers.identifierConcat) {
+        targetId = targetIdentifiers.identifierConcat;
+      } else {
+        const sortedKeys = Object.keys(targetIdentifiers).sort();
+        const parts = [];
+        for (const key of sortedKeys) {
+          const value = targetIdentifiers[key];
+          if (
+            key !== 'submittedByUserId' &&
+            key !== 'identifierConcat' &&
+            value !== undefined &&
+            value !== null
+          ) {
+            parts.push(`${key}#${value}`);
+          }
+        }
+        if (parts.length > 0) {
+          targetId = parts.join('|');
+        }
+      }
+    }
+  }
 
   if (!submittedByUserId || !targetIdentifiers) {
     throw new Error('Missing required request parameters: submittedByUserId or targetIdentifiers');

package/src/emit/rbac/templates/UserRoleMutation_Main.ejs

@@ -16,7 +16,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 <%
-const itemType = operation === 'Put' ? 'Item' : 'Key';
+const action = operation === 'Put' ? 'put' : 'delete';
+const propName = operation === 'Put' ? 'attributes' : 'keyValues';
 const roleUsersKey = operation === 'Put' ? 'userId, roleIdKey' : 'roleIdKey, userId';
 -%> import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
 import snsSharedLib from '@izara_project/izara-core-library-sns';
@@ -27,15 +28,17 @@ export default async function <%- flowTag %>(_izContext, requestParams) {
     const { roleIdKey, userId } = requestParams;
     await dynamodbSharedLib.transactWriteItems(_izContext, [
       {
-        <%- operation %>: {
-          TableName: dynamodbSharedLib.tableName(_izContext, 'RoleUsers'),
-          <%- itemType %>: { <%- roleUsersKey %> }
+        action: '<%- action %>',
+        params: {
+          tableName: dynamodbSharedLib.tableName(_izContext, 'RoleUsers'),
+          <%- propName %>: { <%- roleUsersKey %> }
         }
       },
       {
-        <%- operation %>: {
-          TableName: dynamodbSharedLib.tableName(_izContext, 'UserRoles'),
-          <%- itemType %>: { userId, roleIdKey }
+        action: '<%- action %>',
+        params: {
+          tableName: dynamodbSharedLib.tableName(_izContext, 'UserRoles'),
+          <%- propName %>: { userId, roleIdKey }
         }
       }
     ]);

package/src/emit/resource/emitResourceArtifacts.js

@@ -215,6 +215,9 @@ function createResourceState({ objects, relationships, flows }) {
   if (crud) {
     for (const action of ['Create', 'Update', 'Delete']) {
       const plan = crudActionPlans[action];
+      if (plan.hasCreateNodeCallback) {
+        crudSqsQueues.push(`${action}NodeCallbackHdrSqs`);
+      }
       if (plan.hasComplete) {
         crudSqsQueues.push(`${action}CompleteHdrSqs`);
       }
@@ -474,6 +477,9 @@ function createResourceState({ objects, relationships, flows }) {
                         flow.initiateBy === 'systemWithUser'))) &&
                   upperFirst(flow.flowTag) === topic
               ) ||
+              (objects.length > 0 &&
+                topic !== 'Get' &&
+                CRUD_ACTIONS.includes(topic)) ||
               (relationships.length > 0 &&
                 topic !== 'GetRelationship' &&
                 RELATIONSHIP_ACTIONS.includes(topic))
@@ -832,6 +838,9 @@ function roleQueueNames(state, roleName) {
       if (!plan.outputTopic) return [];
       return [
         `${action}HdrSqs`,
+        ...(plan.hasCreateNodeCallback
+          ? [`${action}NodeCallbackHdrSqs`]
+          : []),
         ...(plan.hasRbacCallback
           ? [`${action}RbacCallbackHdrSqs`]
           : []),

package/src/emit/resource/templates/GeneratedLambdaRoleServiceConfig.ejs

@@ -56,7 +56,9 @@ export function generatedLambdaRole() {
           Effect: 'Allow',
           Action: ['sns:Publish'],
           Resource: [
-            `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'ValidatorRbac_In', 'Rbac')}`<% (rbacValidatorServiceTags || []).forEach(function(tag) { %>,
+            `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'ValidatorRbac_In', 'Rbac')}`,
+            `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'ConfirmUsage_In', 'Rbac')}`,
+            `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'CancelUsage_In', 'Rbac')}`<% (rbacValidatorServiceTags || []).forEach(function(tag) { %>,
             `arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, 'ValidatorRbac_In', '<%= tag %>')}`<% }); %>
           ]
         }<% } %>

package/src/emit/resource/templates/SystemDynamoDB_Yaml.ejs

@@ -271,6 +271,8 @@ Resources:
       TimeToLiveSpecification:
         AttributeName: ttlTimestamp
         Enabled: true
+      StreamSpecification:
+        StreamViewType: NEW_AND_OLD_IMAGES
   <% } %>
   <% if (hasS3) { %>
   ReservedDataMainTable:

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

@@ -88,7 +88,7 @@ export const main = middleware.wrap(async (event, context) => {
 
         // add argument (to invoke lambda) to passOnProperties[]
         passOnProperties.push(record.body.Message);
-        <% if (typeof usePassBack === 'undefined' ? functionName.endsWith('Complete') : usePassBack) { %>
+        <% if (typeof usePassBack === 'undefined' ? (functionName.endsWith('Complete') || functionName.endsWith('CompleteMain') || functionName.includes('Callback')) : usePassBack) { %>
         passOnProperties.push(
           callingFlowSharedLib.addPassBackPropertiesToPassOnProperties(
             record.body.Message

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

@@ -9,7 +9,6 @@ WebSocketConnect:
         authorizer:
           arn: arn:aws:lambda:${self:custom.iz_region}:${self:custom.iz_accountId}:function:UserAccount${self:custom.iz_stage}UserIdentityAuthorizer
           identitySource:
-            - 'route.request.header.Authorization'
             - 'route.request.querystring.access_token'
         #<#/WebSocketConnectAuthorizer#>
     - websocket:

package/test/dynamicCrudFlowSchemas.test.js

@@ -161,6 +161,7 @@ test('generates RbacCallback and Complete for Create when RBAC and Graph are pre
   assert.deepEqual(create.flowSteps.map((step) => step.stepName), [
     'Start',
     'RbacCallback',
+    'CreateNodeCallback',
     'Complete'
   ]);
 });
@@ -186,6 +187,7 @@ test('uses the renamed RBAC callback step when Graph storage is present', async
   assert.deepEqual(create.flowSteps.map((step) => step.stepName), [
     'Start',
     'RbacCallback',
+    'CreateNodeCallback',
     'Complete'
   ]);
   assert.deepEqual(create.flowSteps[2].properties, [
@@ -221,10 +223,22 @@ test('chains RbacCallback and Complete for Update with RBAC and Graph', async ()
     'Complete'
   ]);
   assert.deepEqual(update.flowSteps[0].nextSteps, [
-    { targetType: 'ownTopic', stepName: 'RbacCallback' }
+    { targetType: 'ownTopic', stepName: 'RbacCallback' },
+    {
+      targetType: 'extTopic',
+      serviceTag: 'Rbac',
+      topicName: 'ValidatorRbac_In',
+      toStepNames: ['RbacCallback']
+    }
   ]);
   assert.deepEqual(update.flowSteps[1].nextSteps, [
-    { targetType: 'ownTopic', stepName: 'Complete' }
+    { targetType: 'ownTopic', stepName: 'Complete' },
+    {
+      targetType: 'extTopic',
+      serviceTag: 'GraphHandler',
+      topicName: 'UpdateNode_In',
+      toStepNames: ['Complete']
+    }
   ]);
   assert.deepEqual(update.flowSteps[2].properties, [
     'returnValue',