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

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

@@ -1,5 +1,5 @@
 /*
-Copyright (C) 2020 Sven Mason <http: //izara.io>
+Copyright (C) 2021 Sven Mason <http://izara.io>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as
@@ -8,12 +8,11 @@ License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Affero General Public License for more details.
 
 You should have received a copy of the GNU Affero General Public License
-along with this program. If not, see
-<http: //www.gnu.org/licenses />.
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 // ==================== Shared Core Utilities ====================
@@ -35,10 +34,6 @@ import {
   dataDetailsLib,
   uploadUseCase
 } from '@izara_project/izara-core-library-service-schemas';
-const { createObjType } = utils;
-const { dynamoDbIdentifiersByStorageResource } = identifiersObject;
-const { createUpdateDataDetail } = dataDetailsLib;
-const { PREFIX, TOPIC_NAME_GENERATE_CODE, TOPIC_NAME_GRAPH_HANDLER } = consts;
 
 // ==================== Shared Libraries ====================
 import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
@@ -56,13 +51,632 @@ import {
 //(<optionalRequire>)
 //(</optionalRequire>)
 
+const { createObjType } = utils;
+const { dynamoDbIdentifiersByStorageResource } = identifiersObject;
+const { createUpdateDataDetail } = dataDetailsLib;
+const { PREFIX: _constPrefix, TOPIC_NAME_GENERATE_CODE, TOPIC_NAME_GRAPH_HANDLER } = consts;
+
+const PREFIX = {
+  ASYNC: _constPrefix.updateNode,
+  UPDATE_OBJECT_ASYNC_COMPLETE: 'UpdateAsyncEndpointComplete'
+};
+
+// ── 1. Update_Main Helpers ───────────────────────────────────────────────────
+
+/**
+ * Loads ObjectSchema and resolves submittedByUserId and targetIdentifiers
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} requestParams - Incoming request parameters
+ * @param {Array<string>} errorsFound - Array to collect validation errors
+ * @returns {Promise<{ objType: string, objectSchema: Object }>}
+ */
+export async function resolveSchemaAndIdentity(_izContext, requestParams, errorsFound) {
+  const objType = createObjType(requestParams.objectType);
+  const objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(
+    _izContext,
+    objType
+  );
+  _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] objectSchema:`, objectSchema);
+
+  let submittedByUserId;
+  let targetIdentifiers;
+  if (
+    objectSchema.generatedBy === 'user' ||
+    objectSchema.generatedBy === 'systemWithUser'
+  ) {
+    if (requestParams.submittedByUserId) {
+      submittedByUserId = requestParams.submittedByUserId;
+    } else if (_izContext.correlationIds) {
+      submittedByUserId = _izContext.correlationIds.get(coreConsts.SUBMITTED_BY_USER_ID);
+    }
+
+    targetIdentifiers = requestParams.targetIdentifiers;
+
+    if (!targetIdentifiers && objectSchema.belongTo?.objectType === 'user' && submittedByUserId) {
+      targetIdentifiers = { submittedByUserId };
+    }
+
+    if (!submittedByUserId) {
+      errorsFound.push('Not have submittedByUserId');
+    }
+    if (objectSchema.hasOwnProperty('belongTo') && !targetIdentifiers) {
+      errorsFound.push('not have targetIdentifiers');
+    }
+
+    requestParams.submittedByUserId = submittedByUserId;
+    if (targetIdentifiers) {
+      if (!targetIdentifiers.submittedByUserId && submittedByUserId) {
+        targetIdentifiers.submittedByUserId = submittedByUserId;
+      }
+      requestParams.targetIdentifiers = targetIdentifiers;
+    }
+
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] Identity & Target Context Resolved:`, {
+      submittedByUserId: requestParams.submittedByUserId,
+      targetIdentifiers: requestParams.targetIdentifiers,
+      belongTo: objectSchema.belongTo,
+      generatedBy: objectSchema.generatedBy
+    });
+  } else if (objectSchema.generatedBy === 'searchResultGenerated') {
+    throw new NoRetryError(
+      'error searchResultGenerated should not happen here'
+    );
+  }
+
+  requestParams.submittedByUserId = submittedByUserId;
+  return { objType, objectSchema };
+}
+
+// ── 2. UpdateRbacCallback_Main Helpers ────────────────────────────────────────
+
+/**
+ * Checks awaiting steps status and collects returned results from App and Target RBAC
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} requestParams - Request parameters with parentFlowId
+ * @returns {Promise<{ isComplete: boolean, rbacResults?: Object, originalRequestParams?: Object, collectedErrors?: Array<string> }>}
+ */
+export async function collectRbacAwaitingResults(_izContext, requestParams) {
+  const parts = requestParams.parentFlowId.split('_');
+  const rbacType = parts.pop();
+  const rbacPendingStepId = '<%- flowTag %>RbacCallback_' + parts.join('_');
+  const currentAwaitingStepId = requestParams.parentFlowId;
+
+  _izContext.logger.debug(
+    '[<%- flowTag %>RbacCallbackMain] Parsed RBAC pending details:',
+    {
+      rbacType,
+      rbacPendingStepId,
+      currentAwaitingStepId,
+      parentFlowId: requestParams.parentFlowId
+    }
+  );
+
+  const rbacAwaitingStepsResult =
+    await asyncFlowSharedLib.checkAllAwaitingStepsFinishedWithReturnParams(
+      _izContext,
+      rbacPendingStepId,
+      currentAwaitingStepId,
+      requestParams.errorsFound,
+      {
+        returnValue: requestParams.returnValue,
+        rbacType
+      }
+    );
+
+  _izContext.logger.debug(
+    '[<%- flowTag %>RbacCallbackMain] checkAllAwaitingStepsFinishedWithReturnParams result:',
+    {
+      rbacAwaitingStepsResult
+    }
+  );
+
+  const {
+    isComplete,
+    collectedReturnValueByAwaitingStepId,
+    collectedErrors: errorsFound = [],
+    additionalAttributes
+  } = rbacAwaitingStepsResult;
+
+  if (isComplete === false) {
+    _izContext.logger.debug(
+      '[<%- flowTag %>RbacCallbackMain] Awaiting steps still pending completion:',
+      {
+        rbacPendingStepId,
+        isComplete
+      }
+    );
+    return { isComplete: false };
+  }
+
+  _izContext.logger.debug(
+    '[<%- flowTag %>RbacCallbackMain] All awaiting steps completed — clearing awaiting steps:',
+    {
+      rbacPendingStepId
+    }
+  );
+
+  await asyncFlowSharedLib.clearAllAwaitingSteps(
+    _izContext,
+    rbacPendingStepId
+  );
+
+  let originalRequestParams = {};
+  if (additionalAttributes?.requestParams) {
+    originalRequestParams = additionalAttributes.requestParams;
+  }
+
+  const rbacResults = {};
+  if (collectedReturnValueByAwaitingStepId) {
+    for (const [stepId, attrs] of Object.entries(collectedReturnValueByAwaitingStepId)) {
+      const type = stepId.split('_').pop();
+      rbacResults[type] = attrs;
+    }
+  }
+
+  return {
+    isComplete: true,
+    rbacResults,
+    originalRequestParams,
+    collectedErrors: errorsFound
+  };
+}
+
 /**
- * Core logical processing library
+ * Asserts RBAC permission and publishes rejected response if unauthorized
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} options - Validation options
+ * @returns {Promise<{ hasError: boolean, errorResult?: Object, rbacCallbackResults: Object }>}
+ */
+export async function assertRbacPermission(_izContext, { rbacResults, originalRequestParams, errorsFound }) {
+  const rbacCallbackResults = {};
+  let hasError = false;
+
+  for (const [type, result] of Object.entries(rbacResults || {})) {
+    if (result && result.error) {
+      errorsFound.push(result.error);
+      hasError = true;
+    } else {
+      rbacCallbackResults[type] = result;
+    }
+  }
+
+  let isAllowed = false;
+  for (const item of Object.values(rbacCallbackResults)) {
+    if (item?.returnValue?.permission === true) {
+      isAllowed = true;
+      break;
+    }
+  }
+
+  if (!isAllowed) {
+    errorsFound.push('Permission denied');
+  }
+
+  _izContext.logger.debug(
+    '[<%- flowTag %>RbacCallbackMain] Final rbacCallbackResults before calling <%- flowTag %>MainLogical:',
+    {
+      rbacCallbackResults,
+      isAllowed,
+      errorsFound
+    }
+  );
+
+  if (hasError || errorsFound.length > 0) {
+    const errorResult = {
+      errorsFound,
+      status: 'rejected',
+      requestParams: originalRequestParams
+    };
+
+    _izContext.logger.debug(
+      '[<%- flowTag %>RbacCallbackMain] RBAC check failed, publishing rejected status:',
+      errorResult
+    );
+
+    await sns.publishAsync(_izContext, {
+      TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+        _izContext,
+        '<%- upperCaseFlowTag %>_Out',
+        process.env.iz_serviceTag
+      ),
+      Message: JSON.stringify(errorResult)
+    });
+
+    return { hasError: true, errorResult, rbacCallbackResults };
+  }
+
+  return { hasError: false, rbacCallbackResults };
+}
+
+// ── 3. UpdateLogicalLib Internal Helpers ──────────────────────────────────────
+
+/**
+ * Resolves and combines object schemas and updateDataDetails
+ * @param {Object} _izContext - Izara context object
+ * @param {string} objectType - Object type identifier
+ * @returns {Promise<{ objType: string, objectSchema: Object, objectSchemas: Object, updateDataDetails: Object }>}
+ */
+export async function resolveObjectSchemas(_izContext, objectType) {
+  const objType = createObjType(objectType);
+  const objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(
+    _izContext,
+    objType
+  );
+  _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] objectSchema:`, objectSchema);
+
+  const objectSchemas =
+    await uploadUseCase.generateObjectSchemaForCombineFieldNames(
+      _izContext,
+      objectSchema
+    );
+  _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] objectSchemas:`, objectSchemas);
+
+  const updateDataDetails = await createUpdateDataDetail(
+    _izContext,
+    objectSchemas
+  );
+  _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] updateDataDetails:`, updateDataDetails);
+
+  return { objType, objectSchema, objectSchemas, updateDataDetails };
+}
+
+/**
+ * Validates versionedDataIds against object schema and request fields
+ * @param {Object} requestParams - Request parameters
+ * @param {Object} objectSchema - Object schema
+ * @param {Object} versionedDataIds - Versioned data IDs map
+ * @param {Array<string>} errorsFound - Array to collect validation errors
+ */
+export function validateVersionedDataIds(
+  requestParams,
+  objectSchema,
+  versionedDataIds,
+  errorsFound
+) {
+  const versionedDataIdsKeys = Object.keys(versionedDataIds || {});
+  if (versionedDataIdsKeys.length === 0) {
+    return;
+  }
+
+  const updateMainNodeData = {};
+  const updateVersionedData = {};
+
+  for (const [fieldProp, fieldVal] of Object.entries(
+    requestParams.objInstanceFull?.fields || {}
+  )) {
+    const fieldSetting = objectSchema.fieldNames[fieldProp];
+    if (fieldSetting?.hasOwnProperty('versionedDataLabel')) {
+      const label = fieldSetting.versionedDataLabel;
+      if (!updateVersionedData[label]) {
+        updateVersionedData[label] = {};
+      }
+      Object.assign(updateVersionedData[label], { [fieldProp]: fieldVal });
+    } else {
+      Object.assign(updateMainNodeData, { [fieldProp]: fieldVal });
+    }
+  }
+
+  const versionedDataIdLabelKeys = Object.keys(versionedDataIds);
+  const updateVersionedDataLabelKeys = Object.keys(updateVersionedData);
+
+  const missingVersionedDataIdLabels = updateVersionedDataLabelKeys.filter(
+    (l) => !versionedDataIdLabelKeys.includes(l)
+  );
+  const missingDataVersionedDataLabels = versionedDataIdLabelKeys.filter(
+    (l) => !updateVersionedDataLabelKeys.includes(l)
+  );
+
+  if (missingVersionedDataIdLabels.length > 0) {
+    errorsFound.push(
+      `missing versionedDataIds of versionedDataLabel '${missingVersionedDataIdLabels.join(', ')}'`
+    );
+  }
+  if (missingDataVersionedDataLabels.length > 0) {
+    errorsFound.push(
+      `missing data of versionedDataLabels '${missingDataVersionedDataLabels.join(', ')}'`
+    );
+  }
+  if (Object.keys(updateMainNodeData).length > 0) {
+    errorsFound.push('cannot update mainNode if have versionedDataIds');
+  }
+}
+
+/**
+ * Extracts fields matching storage resource specifications
+ * @param {Object} _izContext - Izara context object
+ * @param {string} storageTag - Storage resource tag
+ * @param {Object} updateDataDetails - Complete update data details map
+ * @param {Object} updateDataDetail - Current storage update data detail
+ * @param {Object} requestParams - Request parameters
+ * @param {Object} identifiers - Identifiers map
+ * @returns {Object} Extracted fields object
+ */
+export function extractFieldsByStorageTag(
+  _izContext,
+  storageTag,
+  updateDataDetails,
+  updateDataDetail,
+  requestParams,
+  identifiers
+) {
+  const result = {};
+  for (const fieldName of Object.keys(
+    requestParams.objInstanceFull?.fields || {}
+  )) {
+    if (
+      updateDataDetails[storageTag].fieldNames.includes(fieldName) &&
+      updateDataDetail.fieldNames.includes(fieldName) &&
+      !identifiers.hasOwnProperty(fieldName) &&
+      !result.hasOwnProperty(fieldName)
+    ) {
+      Object.assign(result, {
+        [fieldName]: requestParams.objInstanceFull.fields[fieldName]
+      });
+    }
+  }
+  return result;
+}
+
+/**
+ * Builds objInstanceFull matching updated object fields
+ * @param {Object} object - Source data object
+ * @param {Object} requestParams - Request parameters
+ * @returns {Object} Full object instance with identifiers and fields
+ */
+export function createObjInstanceFullFromParams(object, requestParams) {
+  const objInstanceFull = { identifiers: {}, fields: {} };
+  for (const field of Object.keys(object || {})) {
+    if (requestParams.objInstanceFull?.identifiers?.hasOwnProperty(field)) {
+      Object.assign(objInstanceFull.identifiers, {
+        [field]: requestParams.objInstanceFull.identifiers[field]
+      });
+    }
+    if (requestParams.objInstanceFull?.fields?.hasOwnProperty(field)) {
+      Object.assign(objInstanceFull.fields, {
+        [field]: requestParams.objInstanceFull.fields[field]
+      });
+    }
+  }
+  return objInstanceFull;
+}
+
+/**
+ * Dispatches node update request to Graph Service
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} options - Graph dispatch configuration
+ * @returns {Promise<void>}
+ */
+export async function dispatchToGraphEngine(
+  _izContext,
+  {
+    objType,
+    identifiers,
+    graphFields,
+    versionedDataIds,
+    originTimestamp,
+    settings,
+    parentFlowId,
+    callingFlowConfig,
+    storageTag,
+    records = []
+  }
+) {
+  const awaitingStepIds = [{
+    awaitingStepId: asyncFlowSharedLib.createAwaitingStepId(
+      parentFlowId,
+      PREFIX.ASYNC
+    ),
+    additionalAttributes: {
+      listOfRecords: records,
+      additionalAttributes: {}
+    }
+  }];
+
+  await asyncFlowSharedLib.createAwaitingMultipleSteps(
+    _izContext,
+    asyncFlowSharedLib.createPendingStepId(_izContext.uniqueRequestId),
+    awaitingStepIds,
+    {
+      additionalAttributes: {
+        callingFlowConfig
+      }
+    }
+  );
+
+  let updateNodeParams = {
+    objType,
+    objInstanceFull: { identifiers, fields: graphFields },
+    versionedDataIds,
+    originTimestamp,
+    settings,
+    parentFlowId
+  };
+
+  updateNodeParams =
+    callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+      updateNodeParams,
+      callingFlowSharedLib.addParentCallingFlowConfig(
+        callingFlowConfig,
+        callingFlowSharedLib.createCallingFlowConfig(
+          //(<callingFlowProperties>)
+          await lambdaSharedLib.lambdaFunctionName(
+            _izContext,
+            TOPIC_NAME_GENERATE_CODE.updateNodeComplete
+          ),
+          {}
+          //(</callingFlowProperties>)
+        )
+      )
+    );
+
+  _izContext.logger.debug(
+    'messageObject before send message:',
+    updateNodeParams
+  );
+
+  await sns.publishAsync(_izContext, {
+    Message: JSON.stringify(updateNodeParams),
+    MessageAttributes: sns.createStringMessageAttributes(
+      _izContext,
+      callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(
+        callingFlowConfig,
+        {}
+      )
+    ),
+    TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+      _izContext,
+      TOPIC_NAME_GRAPH_HANDLER.inUpdateNode,
+      storageTag
+    )
+  });
+}
+
+/**
+ * Handles DynamoDB-only complete notification when no Graph callback is required
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} options - Completion parameters
+ * @returns {Promise<void>}
+ */
+export async function handleDynamoDbOnlyComplete(
+  _izContext,
+  {
+    objType,
+    updateItem,
+    requestParams,
+    callingFlowConfig
+  }
+) {
+  let messageObject = {
+    objType,
+    objInstanceFull: createObjInstanceFullFromParams(
+      updateItem,
+      requestParams
+    )
+  };
+
+  //(<additionalProperties>)
+  //(</additionalProperties>)
+
+  if (
+    callingFlowConfig[
+      callingFlowSharedLib.consts.CALLINGFLOWPROPERTIES_PROPERTYNAME
+    ]
+  ) {
+    _izContext.logger.debug('HAVE CALLING FLOW');
+    messageObject =
+      callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(
+        callingFlowConfig,
+        messageObject
+      );
+
+    _izContext.logger.debug('after create callingFlow', messageObject);
+    await sns.publishAsync(_izContext, {
+      Message: JSON.stringify(messageObject),
+      MessageAttributes: sns.createStringMessageAttributes(
+        _izContext,
+        callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(
+          callingFlowConfig,
+          {}
+        )
+      ),
+      TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+        _izContext,
+        TOPIC_NAME_GENERATE_CODE.outUpdateNodeComplete
+      )
+    });
+  }
+}
+
+/**
+ * Handles update errors and publishes error response
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} options - Error context details
+ * @returns {Promise<Object>} Error status result
+ */
+export async function handleUpdateError(
+  _izContext,
+  {
+    objType,
+    identifiers,
+    fields,
+    versionedDataIds,
+    callingFlowConfig,
+    errorsFound
+  }
+) {
+  const updateNodeCompleteMessage =
+    callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(
+      callingFlowConfig,
+      {
+        objType,
+        objInstanceFull: { identifiers, fields },
+        versionedDataIds,
+        status: 'error',
+        errorsFound
+      }
+    );
+
+  _izContext.logger.debug(
+    'messageParams OutUpdateNodeComplete:::',
+    updateNodeCompleteMessage
+  );
+
+  await sns.publishAsync(_izContext, {
+    Message: JSON.stringify(updateNodeCompleteMessage),
+    MessageAttributes: sns.createStringMessageAttributes(
+      _izContext,
+      callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(
+        callingFlowConfig,
+        {}
+      )
+    ),
+    TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+      _izContext,
+      TOPIC_NAME_GENERATE_CODE.outUpdateNodeComplete
+    )
+  });
+
+  return updateNodeCompleteMessage;
+}
+
+/**
+ * Publishes completion message to SNS
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} message - Response message object
+ * @param {Object} messageAttributes - Message attributes
+ * @returns {Promise<void>}
+ */
+export async function publishCompletionMessage(_izContext, message, messageAttributes) {
+  const topicArn = snsSharedLib.snsTopicArnByFlowSchema(
+    _izContext,
+    TOPIC_NAME_GENERATE_CODE.outUpdateNodeComplete
+  );
+
+  _izContext.logger.debug('[UpdateComplete] publishing to SNS', {
+    TopicArn: topicArn,
+    message
+  });
+
+  await sns.publishAsync(_izContext, {
+    Message: JSON.stringify(message),
+    MessageAttributes: sns.createStringMessageAttributes(
+      _izContext,
+      messageAttributes
+    ),
+    TopicArn: topicArn
+  });
+}
+
+// ── 4. Main Logical Function ──────────────────────────────────────────────────
+
+/**
+ * Core logical processing library for <%- flowTag %> flow
  * @param {Object} _izContext - Context object with logger
  * @param {Object} requestParams - { objectType, objInstanceFull, versionedDataIds, additionalParams }
  * @param {Object} callingFlowConfig - Calling flow configuration
+ * @param {Array<string>} errorsFound - Array of preceding errors
  * @param {Object} phaseResults - Results from preceding phases
- * @returns {Promise<Object>}
+ * @returns {Promise<Object>} Result with objType, objInstanceFull, versionedDataIds, status, errorsFound
  */
 export async function <%- flowTag %>LogicalLib(
   _izContext,
@@ -72,7 +686,7 @@ export async function <%- flowTag %>LogicalLib(
   phaseResults = {}
 ) {
   try {
-    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] started`,  {
+    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] started`, {
       requestParams,
       callingFlowConfig,
       phaseResults
@@ -81,381 +695,169 @@ export async function <%- flowTag %>LogicalLib(
     //(<beforeUpdateMainLogical>)
     //(</beforeUpdateMainLogical>)
 
-    // ── Settings ──────────────────────────────────────────────────────────────
-    const settings = requestParams.additionalParams?.settings ?? {};
+    const settings = {};
+    if (requestParams.additionalParams?.settings) {
+      Object.assign(settings, requestParams.additionalParams.settings);
+    }
     const returnSystemFieldsName = settings.returnSystemFieldsName === true;
     const returnOldData = settings.returnOldData === true;
 
-    const objType = createObjType(requestParams.objectType);
-    const identifiers = requestParams.objInstanceFull.identifiers;
-    const fields = requestParams.objInstanceFull.fields;
-    const versionedDataIds = requestParams.versionedDataIds ?? {};
-    const parentFlowId = identifierUuid();
-    // ── Load schema ───────────────────────────────────────────────────────────
-    const objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(
-      _izContext,
-      objType
-    );
-    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] objectSchema:`, objectSchema);
-
-    const objectSchemas =
-      await uploadUseCase.generateObjectSchemaForCombineFieldNames(
-        _izContext,
-        objectSchema
-      );
-    _izContext.logger.debug('objectSchemas', objectSchemas);
+    let identifiers = {};
+    if (requestParams.objInstanceFull?.identifiers) {
+      identifiers = requestParams.objInstanceFull.identifiers;
+    }
+    let fields = {};
+    if (requestParams.objInstanceFull?.fields) {
+      fields = requestParams.objInstanceFull.fields;
+    }
 
-    // ── Build updateDataDetails ───────────────────────────────────────────────
-    const updateDataDetails = await createUpdateDataDetail(
-      _izContext,
-      objectSchemas
-    );
-    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] updateDataDetails:`, updateDataDetails);
+    let versionedDataIds = {};
+    if (requestParams.versionedDataIds) {
+      versionedDataIds = requestParams.versionedDataIds;
+    }
 
+    const parentFlowId = identifierUuid();
     const originTimestamp = Date.now();
 
-    // ── Validate versionedDataIds ─────────────────────────────────────────────
-    const haveVersionedDataIdsToUpdate =
-      Object.keys(versionedDataIds).length > 0;
-    if (haveVersionedDataIdsToUpdate) {
-      const updateMainNodeData = {};
-      const updateVersionedData = {};
-
-      for (const [fieldProp, fieldVal] of Object.entries(
-        requestParams.objInstanceFull.fields
-      )) {
-        const fieldSetting = objectSchema.fieldNames[fieldProp];
-        if (fieldSetting.hasOwnProperty('versionedDataLabel')) {
-          updateVersionedData[fieldSetting.versionedDataLabel] ??= {};
-          Object.assign(updateVersionedData[fieldSetting.versionedDataLabel], {
-            [fieldProp]: fieldVal
-          });
-        } else {
-          Object.assign(updateMainNodeData, { [fieldProp]: fieldVal });
-        }
-      }
-
-      _izContext.logger.debug('updateMainNodeData::', updateMainNodeData);
-      _izContext.logger.debug('updateVersionedData::', updateVersionedData);
-
-      const versionedDataIdLabelKeys = Object.keys(versionedDataIds);
-      const updateVersionedDataLabelKeys = Object.keys(updateVersionedData);
+    // 1. Resolve schemas & data details
+    const { objType, objectSchema, updateDataDetails } =
+      await resolveObjectSchemas(_izContext, requestParams.objectType);
 
-      const missingVersionedDataIdLabels = updateVersionedDataLabelKeys.filter(
-        (l) => !versionedDataIdLabelKeys.includes(l)
-      );
-      const missingDataVersionedDataLabels = versionedDataIdLabelKeys.filter(
-        (l) => !updateVersionedDataLabelKeys.includes(l)
-      );
-
-      if (missingVersionedDataIdLabels.length)
-        errorsFound.push(
-          `missing versionedDataIds of versionedDataLabel '${missingVersionedDataIdLabels.join(', ')}'`
-        );
-      if (missingDataVersionedDataLabels.length)
-        errorsFound.push(
-          `missing data of versionedDataLabels '${missingDataVersionedDataLabels.join(', ')}'`
-        );
-      if (Object.keys(updateMainNodeData).length)
-        errorsFound.push('cannot update mainNode if have versionedDataIds');
-    }
+    // 2. Validate versioned data IDs
+    validateVersionedDataIds(
+      requestParams,
+      objectSchema,
+      versionedDataIds,
+      errorsFound
+    );
 
     //(<validateBeforeUpdate>)
     //(</validateBeforeUpdate>)
 
-    // ── Early exit on errors ──────────────────────────────────────────────────
-    if (errorsFound.length) {
-      const updateNodeCompleteMessage =
-        callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(
-          callingFlowConfig,
-          {
-            objType,
-            objInstanceFull: { identifiers, fields },
-            versionedDataIds,
-            status: 'error',
-            errorsFound
-          }
-        );
-
-      _izContext.logger.debug(
-        'messageParams OutUpdateNodeComplete:::',
-        updateNodeCompleteMessage
-      );
-      await sns.publishAsync(_izContext, {
-        Message: JSON.stringify(updateNodeCompleteMessage),
-        MessageAttributes: sns.createStringMessageAttributes(
-          _izContext,
-          callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(
-            callingFlowConfig,
-            {}
-          )
-        ),
-        TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
-          _izContext,
-          TOPIC_NAME_GENERATE_CODE.outUpdateNodeComplete
-        )
+    // 3. Early exit on errors
+    if (errorsFound.length > 0) {
+      return await handleUpdateError(_izContext, {
+        objType,
+        identifiers,
+        fields,
+        versionedDataIds,
+        callingFlowConfig,
+        errorsFound
       });
-
-      return updateNodeCompleteMessage;
-    }
-
-    // ── Helper: extract fields per storageTag ─────────────────────────────────
-    function createObjInstanceFullFieldsByStorageTag(
-      _izContext,
-      storageTag,
-      updateDataDetail
-    ) {
-      const result = {};
-      for (const fieldName of Object.keys(
-        requestParams.objInstanceFull.fields
-      )) {
-        if (
-          updateDataDetails[storageTag].fieldNames.includes(fieldName) &&
-          updateDataDetail.fieldNames.includes(fieldName) &&
-          !identifiers.hasOwnProperty(fieldName) &&
-          !result.hasOwnProperty(fieldName)
-        ) {
-          Object.assign(result, {
-            [fieldName]: requestParams.objInstanceFull.fields[fieldName]
-          });
-        }
-      }
-      return result;
-    }
-
-    // ── Helper: build objInstanceFull from updateItem ─────────────────────────
-    function createObjInstanceFullFromParams(object, requestParams) {
-      const objInstanceFull = { identifiers: {}, fields: {} };
-      for (const field of Object.keys(object)) {
-        if (requestParams.objInstanceFull.identifiers.hasOwnProperty(field)) {
-          Object.assign(objInstanceFull.identifiers, {
-            [field]: requestParams.objInstanceFull.identifiers[field]
-          });
-        }
-        if (requestParams.objInstanceFull.fields.hasOwnProperty(field)) {
-          Object.assign(objInstanceFull.fields, {
-            [field]: requestParams.objInstanceFull.fields[field]
-          });
-        }
-      }
-      return objInstanceFull;
     }
 
-    // ── Process storage resources ─────────────────────────────────────────────
-    const awaitingStepIds = [];
+    // 4. Process storage resources
+    let hasGraphStorage = false;
     const listOfRecords = [];
     let updateItem;
 
-    await Promise.all(
-      Object.entries(updateDataDetails).map(
-        async ([storageTag, updateDataDetail]) => {
-          // ── Graph ─────────────────────────────────────────────────────────────
-          if (updateDataDetail.storageType === consts.STORAGE_TYPES.graph) {
-            //(<beforeUpdateGraph>)
-            //(</beforeUpdateGraph>)
+    for (const [storageTag, updateDataDetail] of Object.entries(updateDataDetails)) {
+      if (updateDataDetail.storageType === consts.STORAGE_TYPES.graph) {
+        const graphFields = extractFieldsByStorageTag(
+          _izContext,
+          storageTag,
+          updateDataDetails,
+          updateDataDetail,
+          requestParams,
+          identifiers
+        );
+        if (Object.keys(graphFields).length > 0) {
+          hasGraphStorage = true;
+          //(<beforeUpdateGraph>)
+          //(</beforeUpdateGraph>)
 
-            const graphFields = createObjInstanceFullFieldsByStorageTag(
-              _izContext,
-              storageTag,
-              updateDataDetail
-            );
-            if (!Object.keys(graphFields).length) return;
+          //(<beforeUpdateNode>)
+          //(</beforeUpdateNode>)
 
-            //(<beforeUpdateNode>)
-            //(</beforeUpdateNode>)
+          //(<additionalAttributes>)
+          //(</additionalAttributes>)
 
-            //(<additionalAttributes>)
-            const additionalAttributes = {};
-            //(</additionalAttributes>)
+          await dispatchToGraphEngine(_izContext, {
+            objType,
+            identifiers,
+            graphFields,
+            versionedDataIds,
+            originTimestamp,
+            settings: { returnSystemFieldsName, returnOldData },
+            parentFlowId,
+            callingFlowConfig,
+            storageTag,
+            records: listOfRecords
+          });
+        }
+      } else if (updateDataDetail.storageType === consts.STORAGE_TYPES.dynamoDB) {
+        const dynamoFields = extractFieldsByStorageTag(
+          _izContext,
+          storageTag,
+          updateDataDetails,
+          updateDataDetail,
+          requestParams,
+          identifiers
+        );
+        if (Object.keys(dynamoFields).length > 0) {
+          //(<beforeUpdateDynamoDb>)
+          //(</beforeUpdateDynamoDb>)
 
-            const records = awaitingStepIds.length === 0 ? listOfRecords : [];
-            awaitingStepIds.push({
-              awaitingStepId: asyncFlowSharedLib.createAwaitingStepId(
-                parentFlowId,
-                PREFIX.updateNode
-              ),
-              additionalAttributes: {
-                listOfRecords: records,
-                additionalAttributes: additionalAttributes
-              }
-            });
+          const identifiersForUpdateData =
+            await dynamoDbIdentifiersByStorageResource(
+              _izContext,
+              objectSchema,
+              updateDataDetail,
+              identifiers
+            );
+          _izContext.logger.debug(
+            'identifiersForUpdateData',
+            identifiersForUpdateData
+          );
 
-            if (awaitingStepIds.length) {
-              const awaitingMultipleStep =
-                await asyncFlowSharedLib.createAwaitingMultipleSteps(
-                  _izContext,
-                  asyncFlowSharedLib.createPendingStepId(
-                    _izContext.uniqueRequestId
-                  ),
-                  awaitingStepIds,
-                  {
-                    additionalAttributes: {
-                      callingFlowConfig
-                    }
-                  }
-                );
-              _izContext.logger.debug(
-                'awaitingMultipleStep',
-                awaitingMultipleStep
-              );
+          let hasGraphInSchema = false;
+          for (const d of Object.values(updateDataDetails)) {
+            if (d.storageType === consts.STORAGE_TYPES.graph) {
+              hasGraphInSchema = true;
+              break;
             }
+          }
 
-            let updateNodeParams = {
-              objType,
-              objInstanceFull: { identifiers, fields: graphFields },
-              versionedDataIds,
-              originTimestamp,
-              settings: { returnSystemFieldsName, returnOldData },
-              parentFlowId
-            };
-
-            updateNodeParams =
-              callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-                updateNodeParams,
-                callingFlowSharedLib.addParentCallingFlowConfig(
-                  callingFlowConfig,
-                  callingFlowSharedLib.createCallingFlowConfig(
-                    //(<callingFlowProperties>)
-                    await lambdaSharedLib.lambdaFunctionName(
-                      _izContext,
-                      TOPIC_NAME_GENERATE_CODE.updateNodeComplete
-                    ),
-                    {}
-                    //(</callingFlowProperties>)
-                  )
-                )
-              );
-
-            _izContext.logger.debug(
-              'messageObject before send message:',
-              updateNodeParams
-            );
-
-            const resSNS = await sns.publishAsync(_izContext, {
-              Message: JSON.stringify(updateNodeParams),
-              MessageAttributes: sns.createStringMessageAttributes(
-                _izContext,
-                callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(
-                  callingFlowConfig,
-                  {}
-                )
-              ),
-              TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
-                _izContext,
-                TOPIC_NAME_GRAPH_HANDLER.inUpdateNode,
-                storageTag
-              )
+          if (hasGraphInSchema) {
+            _izContext.logger.debug('must process graph first');
+            listOfRecords.push({
+              [storageTag]: {
+                serviceTag: updateDataDetail.serviceTag,
+                tableName: updateDataDetail.tableName,
+                objInstanceFull: {
+                  identifiers: identifiersForUpdateData,
+                  fields: dynamoFields
+                }
+              }
             });
-            _izContext.logger.debug(
-              'resSNS send to topic InUpdateNode finish!',
-              resSNS
-            );
-
-            // ── DynamoDB ──────────────────────────────────────────────────────────
-          } else if (
-            updateDataDetail.storageType === consts.STORAGE_TYPES.dynamoDB
-          ) {
-            const dynamoFields = createObjInstanceFullFieldsByStorageTag(
+          } else {
+            _izContext.logger.debug('can process record dynamo');
+            updateItem = await dynamodbSharedLib.updateItem(
               _izContext,
-              storageTag,
-              updateDataDetail
-            );
-            if (!Object.keys(dynamoFields).length) return;
-
-            //(<beforeUpdateDynamoDb>)
-            //(</beforeUpdateDynamoDb>)
-
-            const identifiersForUpdateData =
-              await dynamoDbIdentifiersByStorageResource(
+              await dynamodbSharedLib.tableName(
                 _izContext,
-                objectSchema,
-                updateDataDetail,
-                identifiers
-              );
-            _izContext.logger.debug(
-              'identifiersForUpdateData',
-              identifiersForUpdateData
+                updateDataDetail.tableName,
+                updateDataDetail.serviceTag
+              ),
+              identifiersForUpdateData,
+              dynamoFields,
+              { returnValues: 'ALL_NEW' }
             );
 
-            if (
-              Object.values(updateDataDetails).some(
-                (updateDataDetail) =>
-                  updateDataDetail.storageType === consts.STORAGE_TYPES.graph
-              )
-            ) {
-              _izContext.logger.debug('must process graph first');
-              listOfRecords.push({
-                [storageTag]: {
-                  serviceTag: updateDataDetail.serviceTag,
-                  tableName: updateDataDetail.tableName,
-                  objInstanceFull: {
-                    identifiers: identifiersForUpdateData,
-                    fields: dynamoFields
-                  }
-                }
-              });
-            } else {
-              _izContext.logger.debug('can process record dynamo');
-              updateItem = await dynamodbSharedLib.updateItem(
-                _izContext,
-                await dynamodbSharedLib.tableName(
-                  _izContext,
-                  updateDataDetail.tableName,
-                  updateDataDetail.serviceTag
-                ),
-                identifiersForUpdateData,
-                dynamoFields,
-                { returnValues: 'ALL_NEW' }
-              );
-
-              _izContext.logger.debug('updateItem:', updateItem);
-            }
+            _izContext.logger.debug('updateItem:', updateItem);
           }
         }
-      )
-    );
+      }
+    }
 
-    // ── DynamoDB-only complete path ───────────────────────────────────────────
-    if (awaitingStepIds.length === 0) {
-      let messageObject = {
+    // 5. If no graph storage, complete immediately
+    if (!hasGraphStorage) {
+      await handleDynamoDbOnlyComplete(_izContext, {
         objType,
-        objInstanceFull: createObjInstanceFullFromParams(
-          updateItem,
-          requestParams
-        )
-      };
-
-      //(<additionalProperties>)
-      //(</additionalProperties>)
-
-      if (
-        callingFlowConfig[
-          callingFlowSharedLib.consts.CALLINGFLOWPROPERTIES_PROPERTYNAME
-        ]
-      ) {
-        _izContext.logger.debug('HAVE CALLING FLOW');
-        messageObject =
-          callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(
-            callingFlowConfig,
-            messageObject
-          );
-
-        _izContext.logger.debug('after create callingFlow', messageObject);
-        await sns.publishAsync(_izContext, {
-          Message: JSON.stringify(messageObject),
-          MessageAttributes: sns.createStringMessageAttributes(
-            _izContext,
-            callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(
-              callingFlowConfig,
-              {}
-            )
-          ),
-          TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
-            _izContext,
-            TOPIC_NAME_GENERATE_CODE.outUpdateNodeComplete
-          )
-        });
-      }
+        updateItem,
+        requestParams,
+        callingFlowConfig
+      });
     }
 
     return {
@@ -469,7 +871,6 @@ export async function <%- flowTag %>LogicalLib(
     };
   } catch (err) {
     _izContext.logger.error(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] error:`, err);
-    _izContext.logger.error('[<%- flowTag %>LogicalLib] error:', err);
     throw err;
   }
 }