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

package/src/emit/coreFunction/templates/InitialSetupConfig.ejs

@@ -70,6 +70,10 @@ const externalServices = {
     dynamoTableNames.add('RolePermissions');
     dynamoTableNames.add('RoleUsers');
     dynamoTableNames.add('UserRoles');
+    dynamoTableNames.add('RbacPermissionCaches');
+    dynamoTableNames.add('RoleLimit');
+    dynamoTableNames.add('RunningTotalUsage');
+    dynamoTableNames.add('RunningTotalReservedUsage');
   }
   if (typeof s3Flows !== 'undefined' && (s3Flows || []).length > 0) {
     dynamoTableNames.add('ReservedDataMain');
@@ -127,7 +131,10 @@ const tableConfigs = {
   const nodeSubs = [];
   (objectGraphServiceTags || []).forEach(function(tag) {
     nodeSubs.push({ serviceTag: tag, topicName: 'UpdateNode_Out', sqsEndpoint: 'UpdateCompleteHdrSqs' });
-    nodeSubs.push({ serviceTag: tag, topicName: 'CreateNode_Out', sqsEndpoint: 'CreateCompleteHdrSqs' });
+    const createNodeEndpoint = (typeof hasQuotaReservation !== 'undefined' && hasQuotaReservation)
+      ? 'CreateNodeCallbackHdrSqs'
+      : 'CreateCompleteHdrSqs';
+    nodeSubs.push({ serviceTag: tag, topicName: 'CreateNode_Out', sqsEndpoint: createNodeEndpoint });
   });
 
   const customSubs = [];
@@ -173,18 +180,31 @@ const tableConfigs = {
   });
 
   const rbacSubs = [];
-  if (crud && typeof rbacValidatorServiceTags !== 'undefined' && rbacValidatorServiceTags && rbacValidatorServiceTags.length > 0) {
-    const allRbacTags = Array.from(new Set(['Rbac', ...rbacValidatorServiceTags]));
+  if (crud && rbac) {
+    const allRbacTags = Array.from(new Set(['Rbac', ...(typeof rbacValidatorServiceTags !== 'undefined' && rbacValidatorServiceTags ? rbacValidatorServiceTags : [])]));
     const hasGraph = typeof objectGraphServiceTags !== 'undefined' && objectGraphServiceTags && objectGraphServiceTags.length > 0;
+    const createEndpoint = hasGraph ? 'CreateRbacCallbackHdrSqs' : 'CreateCompleteHdrSqs';
     const updateEndpoint = hasGraph ? 'UpdateRbacCallbackHdrSqs' : 'UpdateCompleteHdrSqs';
     const deleteEndpoint = hasGraph ? 'DeleteRbacCallbackHdrSqs' : 'DeleteCompleteHdrSqs';
     allRbacTags.forEach(function(tag) {
-      if (!hasGraph) {
-        rbacSubs.push({ serviceTag: tag, topicName: 'ValidatorRbac_Out', sqsEndpoint: 'CreateCompleteHdrSqs' });
-      }
+      rbacSubs.push({ serviceTag: tag, topicName: 'ValidatorRbac_Out', sqsEndpoint: createEndpoint });
       rbacSubs.push({ serviceTag: tag, topicName: 'ValidatorRbac_Out', sqsEndpoint: updateEndpoint });
       rbacSubs.push({ serviceTag: tag, topicName: 'ValidatorRbac_Out', sqsEndpoint: deleteEndpoint });
     });
+    if (typeof hasQuotaReservation !== 'undefined' && hasQuotaReservation) {
+      rbacSubs.push({ serviceTag: 'Rbac', topicName: 'ConfirmUsage_Out', sqsEndpoint: 'CreateCompleteHdrSqs' });
+      rbacSubs.push({ serviceTag: 'Rbac', topicName: 'CancelUsage_Out', sqsEndpoint: 'CreateCompleteHdrSqs' });
+    }
+  }
+
+  if (typeof customRbacFlowTags !== 'undefined' && customRbacFlowTags && customRbacFlowTags.length > 0) {
+    const allRbacTags = Array.from(new Set(['Rbac', ...(typeof rbacValidatorServiceTags !== 'undefined' ? rbacValidatorServiceTags : [])]));
+    customRbacFlowTags.forEach(function(flowTag) {
+      const tagUpper = flowTag[0].toUpperCase() + flowTag.slice(1);
+      allRbacTags.forEach(function(tag) {
+        rbacSubs.push({ serviceTag: tag, topicName: 'ValidatorRbac_Out', sqsEndpoint: `${tagUpper}RbacCallbackHdrSqs` });
+      });
+    });
   }
 -%>
 const snsTopicSubscriptions = [
@@ -294,7 +314,9 @@ function roleConfigs() {
           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/crud/crudActionPlan.js

@@ -5,36 +5,43 @@ export function createCrudActionPlans(objects = []) {
   const hasRbac = objects.some(
     (object) => isCrudObject(object) && hasRbacObject(object, objects)
   );
+  const isBillable = objects.some(
+    (object) => isCrudObject(object) && isBillableObject(object, objects)
+  );
 
   return Object.fromEntries(
     CRUD_ACTIONS.map((action) => [
       action,
-      createCrudActionPlan(action, { hasGraph, hasRbac })
+      createCrudActionPlan(action, { hasGraph, hasRbac, isBillable })
     ])
   );
 }
 
 export function createCrudActionPlan(
   action,
-  { hasGraph = false, hasRbac = false } = {}
+  { hasGraph = false, hasRbac = false, isBillable = true } = {}
 ) {
-  const actionHasRbac = action !== 'Create' && action !== 'Get' && hasRbac;
+  const actionHasRbac = action !== 'Get' && hasRbac;
   const outputTopic = action !== 'Get';
+  const hasQuotaReservation = action === 'Create' && hasRbac && isBillable;
 
   return {
     action,
     outputTopic,
     hasGraph: outputTopic && hasGraph,
     hasRbac: actionHasRbac,
+    hasQuotaReservation,
     hasComplete: outputTopic && (actionHasRbac || hasGraph),
-    hasRbacCallback: outputTopic && actionHasRbac && hasGraph
+    hasRbacCallback: outputTopic && actionHasRbac && hasGraph,
+    hasCreateNodeCallback:
+      outputTopic && action === 'Create' && actionHasRbac && hasGraph && hasQuotaReservation
   };
 }
 
-const VALID_CRUD_GENERATED_BY = new Set([
+export const VALID_CRUD_GENERATED_BY = new Set([
   'user',
   'systemWithUser',
-  'systemWithNoUser'
+  'systemNoUser'
 ]);
 
 export function isCrudObject(object) {
@@ -83,3 +90,31 @@ function normalizeBelongTo(object) {
   if (!object?.belongTo) return [];
   return Array.isArray(object.belongTo) ? object.belongTo : [object.belongTo];
 }
+
+export function isBillableObject(object, objects = []) {
+  if (!isCrudObject(object)) return false;
+
+  const targets = normalizeBelongTo(object);
+  if (targets.length > 0) {
+    for (const target of targets) {
+      if (typeof target?.billable === 'boolean') {
+        return target.billable;
+      }
+    }
+  }
+
+  if (Array.isArray(object?.addOnDataStructure)) {
+    const rbacAddOn = object.addOnDataStructure.find(
+      (addOn) => addOn?.type === 'rbac'
+    );
+    if (typeof rbacAddOn?.billable === 'boolean') {
+      return rbacAddOn.billable;
+    }
+  }
+
+  if (typeof object?.billable === 'boolean') {
+    return object.billable;
+  }
+
+  return true;
+}

package/src/emit/crud/emitCrudApplicationArtifacts.js

@@ -11,7 +11,8 @@ import {
 import {
   CRUD_ACTIONS,
   createCrudActionPlans,
-  isCrudObject
+  isCrudObject,
+  VALID_CRUD_GENERATED_BY
 } from './crudActionPlan.js';
 
 const ACTIONS = CRUD_ACTIONS;
@@ -22,12 +23,26 @@ const SHARED_TEMPLATE_URL = new URL('../shared/templates/', import.meta.url);
 export async function emitCrudApplicationArtifacts({
   objects,
   flows = [],
-  serviceTag
+  serviceTag,
+  logger
 }) {
   if (!Array.isArray(objects) || !Array.isArray(flows)) {
     throw new TypeError('objects and flows must be arrays');
   }
-  if (!objects.some(isCrudObject)) return [];
+  if (!objects.some(isCrudObject)) {
+    if (objects.length > 0) {
+      const summary = objects.map((obj) => ({
+        objectType: obj?.objectType ?? '(undefined)',
+        generatedBy: obj?.generatedBy ?? '(missing)'
+      }));
+      logger?.warn?.(
+        `[WARN] [CRUD Application] Skipped FlowObjects application artifacts generation: No valid CRUD ObjectSchema found. ` +
+        `Checked ${objects.length} object(s): ${JSON.stringify(summary)}. ` +
+        `Expected "generatedBy" to be one of: ${Array.from(VALID_CRUD_GENERATED_BY).join(', ')}`
+      );
+    }
+    return [];
+  }
 
   const handlers = await Promise.all(
     ACTIONS.map((action) => emitAction(action, objects, serviceTag))
@@ -65,6 +80,8 @@ export function crudApplicationManagedPaths() {
           `${source}/${action}_HdrWbs.js`,
           `${source}/${action}RbacCallback_Main.js`,
           `${source}/${action}RbacCallback_HdrSqs.js`,
+          `${source}/${action}NodeCallback_Main.js`,
+          `${source}/${action}NodeCallback_HdrSqs.js`,
           `${source}/${action}Complete_Main.js`,
           `${source}/${action}Complete_HdrSqs.js`
         );
@@ -87,7 +104,7 @@ async function emitAction(action, objects, serviceTag) {
     flow: null,
     flowStepName: '',
     startConfig: null,
-    objects: action === 'Create' ? [] : objects,
+    objects: objects,
     isCrudObject,
     hasRbacAddOn: (object) => hasRbacAddOn(object, objects),
     plan
@@ -275,12 +292,43 @@ async function emitAction(action, objects, serviceTag) {
     });
   }
 
+  if (plan.hasCreateNodeCallback) {
+    const nodeCallbackMain = `${action}NodeCallback_Main`;
+    artifacts.push(
+      {
+        path: `${source}/${nodeCallbackMain}.js`,
+        content: await render(`${action}NodeCallback_Main.ejs`, shared)
+      },
+      {
+        path: `${source}/${nodeCallbackMain.replace('_Main', '_HdrSqs')}.js`,
+        content: await renderShared('FlowHandler_HdrSqs.ejs', {
+          ...shared,
+          mainFileName: nodeCallbackMain,
+          functionName: `${action}NodeCallbackMain`,
+          queueName: `${action}NodeCallbackHdrSqs`
+        })
+      }
+    );
+    functions.push({
+      type: 'sqs',
+      functionName: `${action}NodeCallbackHdrSqs`,
+      handlerPath: `${handlerRoot}/${action}NodeCallback_HdrSqs.main`,
+      roleName: 'FlowObjectsRole',
+      queueName: `${action}NodeCallbackHdrSqs`,
+      flowTag: action,
+      flowStepName: 'CreateNodeCallback'
+    });
+  }
+
   if (plan.hasComplete) {
     const completeMain = `${action}Complete_Main`;
-    const templateName =
-      plan.hasRbac && !plan.hasGraph
-        ? 'FlowEndpointRbacCallback_Main.ejs'
-        : `${action}Complete_Main.ejs`;
+    let templateName = `${action}Complete_Main.ejs`;
+    if (plan.hasRbac && !plan.hasGraph) {
+      templateName = 'FlowEndpointRbacCallback_Main.ejs';
+    } else if (plan.hasCreateNodeCallback) {
+      templateName = 'CreateConfirmComplete_Main.ejs';
+    }
+
     const templateContext =
       plan.hasRbac && !plan.hasGraph
         ? shared

package/src/emit/crud/emitDynamicCrudFlowSchemas.js

@@ -3,7 +3,8 @@ import {
   CRUD_ACTIONS,
   createCrudActionPlans,
   hasGraphStorageResource,
-  isCrudObject
+  isCrudObject,
+  VALID_CRUD_GENERATED_BY
 } from './crudActionPlan.js';
 
 const MESSAGE_ATTRIBUTES = ['userId', 'correlationId'];
@@ -13,37 +14,77 @@ export const dynamicCrudFlowSchemaPaths = CRUD_ACTIONS.map(
     `app/src/schemas/FlowSchemas/generateCode/FlowObjects/${action}.js`
 );
 
-export function emitDynamicCrudFlowSchemas({ objects, flows = [], serviceTag }) {
+export function emitDynamicCrudFlowSchemas({
+  objects,
+  flows = [],
+  serviceTag,
+  logger
+}) {
   if (!Array.isArray(objects) || !Array.isArray(flows)) {
     throw new TypeError('objects and flows must be arrays');
   }
-  if (!objects.some(isCrudObject)) return [];
+  if (!objects.some(isCrudObject)) {
+    if (objects.length > 0) {
+      const summary = objects.map((obj) => ({
+        objectType: obj?.objectType ?? '(undefined)',
+        generatedBy: obj?.generatedBy ?? '(missing)'
+      }));
+      logger?.warn?.(
+        `[WARN] [CRUD FlowSchemas] Skipped FlowObjects FlowSchemas generation: No valid CRUD ObjectSchema found. ` +
+        `Checked ${objects.length} object(s): ${JSON.stringify(summary)}. ` +
+        `Expected "generatedBy" to be one of: ${Array.from(VALID_CRUD_GENERATED_BY).join(', ')}`
+      );
+    }
+    return [];
+  }
 
   const plans = createCrudActionPlans(objects);
+  const primaryObject = objects.find(isCrudObject);
+  const initiateBy = primaryObject?.generatedBy || 'user';
 
   return CRUD_ACTIONS.map((action, index) => ({
     path: dynamicCrudFlowSchemaPaths[index],
     content: renderDynamicCrudFlowSchema(
       action,
-      _createDynamicFlow(action, plans[action], serviceTag)
+      _createDynamicFlow(action, plans[action], serviceTag, initiateBy)
     )
   }));
 }
 
-function _createDynamicFlow(action, plan, serviceTag = '') {
+function _createDynamicFlow(action, plan, serviceTag = '', initiateBy = 'user') {
+  const startNextSteps = [];
+  if (plan.hasRbacCallback) {
+    startNextSteps.push(
+      {
+        targetType: 'ownTopic',
+        stepName: 'RbacCallback'
+      },
+      {
+        targetType: 'extTopic',
+        serviceTag: 'Rbac',
+        topicName: 'ValidatorRbac_In',
+        toStepNames: ['RbacCallback']
+      }
+    );
+  } else if (plan.hasComplete) {
+    startNextSteps.push({
+      targetType: 'ownTopic',
+      stepName: 'Complete'
+    });
+    if (plan.hasGraph) {
+      startNextSteps.push({
+        targetType: 'extTopic',
+        serviceTag: 'GraphHandler',
+        topicName: `${action}Node_In`,
+        toStepNames: ['Complete']
+      });
+    }
+  }
+
   const flowSteps = [
     {
       stepName: 'Start',
-      ...(plan.hasRbacCallback || plan.hasComplete
-        ? {
-            nextSteps: [
-              {
-                targetType: 'ownTopic',
-                stepName: plan.hasRbacCallback ? 'RbacCallback' : 'Complete'
-              }
-            ]
-          }
-        : {}),
+      ...(startNextSteps.length > 0 ? { nextSteps: startNextSteps } : {}),
       properties: [],
       messageAttributes: MESSAGE_ATTRIBUTES,
       ...(plan.outputTopic
@@ -58,6 +99,22 @@ function _createDynamicFlow(action, plan, serviceTag = '') {
   ];
 
   if (plan.hasRbacCallback) {
+    const nextStepName = plan.hasCreateNodeCallback ? 'CreateNodeCallback' : 'Complete';
+    const rbacNextSteps = [
+      {
+        targetType: 'ownTopic',
+        stepName: nextStepName
+      }
+    ];
+    if (plan.hasGraph) {
+      rbacNextSteps.push({
+        targetType: 'extTopic',
+        serviceTag: 'GraphHandler',
+        topicName: `${action}Node_In`,
+        toStepNames: [nextStepName]
+      });
+    }
+
     flowSteps.push({
       stepName: 'RbacCallback',
       event: ['extTopic'],
@@ -65,45 +122,114 @@ function _createDynamicFlow(action, plan, serviceTag = '') {
         {
           sourceType: 'ownTopic',
           stepName: 'Start'
+        },
+        {
+          sourceType: 'extTopic',
+          serviceTag: 'Rbac',
+          topicName: 'ValidatorRbac_Out',
+          fromStepNames: ['Start']
+        }
+      ],
+      nextSteps: rbacNextSteps,
+      properties: [],
+      messageAttributes: MESSAGE_ATTRIBUTES
+    });
+  }
+
+  if (plan.hasCreateNodeCallback) {
+    flowSteps.push({
+      stepName: 'CreateNodeCallback',
+      event: ['extTopic'],
+      previousSteps: [
+        {
+          sourceType: 'ownTopic',
+          stepName: 'RbacCallback'
+        },
+        {
+          sourceType: 'extTopic',
+          serviceTag: 'GraphHandler',
+          topicName: 'CreateNode_Out',
+          fromStepNames: ['RbacCallback']
         }
       ],
       nextSteps: [
         {
           targetType: 'ownTopic',
           stepName: 'Complete'
+        },
+        {
+          targetType: 'extTopic',
+          serviceTag: 'Rbac',
+          topicName: 'ConfirmUsage_In',
+          toStepNames: ['Complete']
         }
       ],
-      properties: [],
+      properties: [
+        'returnValue',
+        'parentFlowId',
+        'status',
+        'errorsFound',
+        'graphServiceTag'
+      ],
       messageAttributes: MESSAGE_ATTRIBUTES
     });
   }
 
   if (plan.hasComplete) {
+    const prevStepName = plan.hasCreateNodeCallback
+      ? 'CreateNodeCallback'
+      : (plan.hasRbacCallback ? 'RbacCallback' : 'Start');
+
+    const completePrevSteps = [
+      {
+        sourceType: 'ownTopic',
+        stepName: prevStepName
+      }
+    ];
+
+    if (plan.hasCreateNodeCallback) {
+      completePrevSteps.push({
+        sourceType: 'extTopic',
+        serviceTag: 'Rbac',
+        topicName: 'ConfirmUsage_Out',
+        fromStepNames: ['CreateNodeCallback']
+      });
+    } else if (plan.hasGraph) {
+      completePrevSteps.push({
+        sourceType: 'extTopic',
+        serviceTag: 'GraphHandler',
+        topicName: `${action}Node_Out`,
+        fromStepNames: [prevStepName]
+      });
+    }
+
     flowSteps.push({
       stepName: 'Complete',
       event: ['extTopic'],
-      previousSteps: [
-        {
-          sourceType: 'ownTopic',
-          stepName: plan.hasRbacCallback ? 'RbacCallback' : 'Start'
-        }
-      ],
-      properties: plan.hasGraph
+      previousSteps: completePrevSteps,
+      properties: plan.hasCreateNodeCallback
         ? [
             'returnValue',
             'parentFlowId',
             'status',
-            'errorsFound',
-            'graphServiceTag'
+            'errorsFound'
           ]
-        : [],
+        : (plan.hasGraph
+            ? [
+                'returnValue',
+                'parentFlowId',
+                'status',
+                'errorsFound',
+                'graphServiceTag'
+              ]
+            : []),
       messageAttributes: MESSAGE_ATTRIBUTES
     });
   }
 
   return {
     flowTag: action,
-    initiateBy: 'systemWithNoUser',
+    initiateBy,
     handleObj: 'one',
     statusType: 'none',
     event: plan.outputTopic ? ['ownTopic'] : ['lambdaSyncInv', 'lambdaSyncApi'],

package/src/emit/crud/generateCrudApplicationArtifacts.js

@@ -9,10 +9,11 @@ import {
 
 export async function generateCrudApplicationArtifacts(rootPath, options = {}) {
   const project = compileProject({ ...options, rootPath });
-  const schemas = await loadLocalSchemaArrays(project);
+  const schemas = await loadLocalSchemaArrays(project, options);
   const artifacts = await emitCrudApplicationArtifacts({
     ...schemas,
-    serviceTag: project.serviceTag
+    serviceTag: project.serviceTag,
+    logger: options.logger
   });
   const files = await commitArtifacts(
     buildGenerationPlan(project, artifacts, {

package/src/emit/crud/generateDynamicCrudFlowSchemas.js

@@ -9,12 +9,13 @@ import { loadLocalSchemaArrays } from './loadLocalSchemaArrays.js';
 
 export async function generateDynamicCrudFlowSchemas(rootPath, options = {}) {
   const project = compileProject({ ...options, rootPath });
-  const schemaInputs = await loadLocalSchemaArrays(project);
+  const schemaInputs = await loadLocalSchemaArrays(project, options);
   const plan = buildGenerationPlan(
     project,
     emitDynamicCrudFlowSchemas({
       ...schemaInputs,
-      serviceTag: project.serviceTag
+      serviceTag: project.serviceTag,
+      logger: options.logger
     }),
     {
       managedPaths: dynamicCrudFlowSchemaPaths,

package/src/emit/crud/loadLocalSchemaArrays.js

@@ -1,8 +1,8 @@
 import { loadLocalSchemaDirectory } from '../../compile/loadSchemas.js';
 
-export async function loadLocalSchemaArrays(project) {
+export async function loadLocalSchemaArrays(project, options = {}) {
   return {
-    objects: await loadLocalSchemaDirectory(project, 'ObjectSchemas'),
-    flows: await loadLocalSchemaDirectory(project, 'FlowSchemas')
+    objects: await loadLocalSchemaDirectory(project, 'ObjectSchemas', options),
+    flows: await loadLocalSchemaDirectory(project, 'FlowSchemas', options)
   };
 }

package/src/emit/crud/templates/CreateComplete_Main.ejs

@@ -52,7 +52,7 @@ export default async function CreateComplete(
   //(</additionalParams>)
 ) {
   try {
-    _izContext.logger.debug('[CreateComplete] started', {
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:CreateComplete] started`,  {
       requestParams
     });
     const {

package/src/emit/crud/templates/CreateConfirmComplete_Main.ejs

@@ -0,0 +1,54 @@
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import { sns } from '@izara_project/izara-core-library-external-request';
+import { consts } from '@izara_project/izara-core-library-service-schemas';
+
+import {
+  buildCompletionPayload,
+  publishCompletionMessage
+} from './CreateLogicalLib.js';
+
+const { TOPIC_NAME_GENERATE_CODE } = consts;
+
+/**
+ * Handles Create flow completion by publishing final response to Calling Flow
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} requestParams - Final response parameters
+ * @param {Object} passBackProperties - Pass-back properties
+ * @returns {Promise<Object>} Parent pass-back result
+ */
+export default async function CreateComplete(
+  _izContext,
+  requestParams,
+  passBackProperties
+) {
+  try {
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:CreateComplete] started`, {
+      requestParams
+    });
+
+    const callingFlowConfig =
+      requestParams?.callingFlowProperties ||
+      passBackProperties ||
+      {};
+
+    const parentPassBack =
+      requestParams?.parentPassBackProperties ||
+      requestParams?.returnValue ||
+      requestParams;
+
+    // 1. Build completion response payload and attributes
+    const { message, messageAttributes } = buildCompletionPayload(
+      callingFlowConfig,
+      parentPassBack
+    );
+
+    // 2. Publish completion notification to SNS
+    await publishCompletionMessage(_izContext, message, messageAttributes);
+
+    return parentPassBack;
+  } catch (error) {
+    _izContext.logger.error('[CreateComplete] error:', error);
+    throw error;
+  }
+}