@izara_project/izara-core-library-lock-update 1.0.1 → 1.0.2

package/src/lockUpdateSharedLib.js

@@ -0,0 +1,1078 @@
+/*
+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
+published by the Free Software Foundation, either version 3 of the
+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
+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/>.
+*/
+
+'use strict';
+
+import { NoRetryError, validator } from '@izara_project/izara-core-library-core';
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import errorHandlingSharedLib from '@izara_project/izara-core-library-error-handling';
+import { sns } from '@izara_project/izara-core-library-external-request';
+import { identifiersObject } from '@izara_project/izara-core-library-service-schemas';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+import graphSharedLib from '@izara_project/izara-core-library-graph-service';
+
+import lockUpdateConstants from './constants/lockUpdateConstants.js';
+
+
+
+function _createAjvValidationSchema(objectSchema) {
+  const properties = {};
+  const identifierFieldNames = new Set();
+
+  // Collect identifier field names
+  for (const identifier of objectSchema.identifiers) {
+    if (identifier.fieldName) {
+      identifierFieldNames.add(identifier.fieldName);
+    }
+
+    if (Array.isArray(identifier.fieldNames)) {
+      for (const fieldName of identifier.fieldNames) {
+        identifierFieldNames.add(fieldName);
+      }
+    }
+  }
+
+  // Create properties
+  for (const [fieldName, fieldSchema] of Object.entries(
+    objectSchema.fieldNames
+  )) {
+    if (identifierFieldNames.has(fieldName)) {
+      continue;
+    }
+
+    properties[fieldName] = {
+      type: fieldSchema.type
+    };
+  }
+
+  // Add identifier properties
+  for (const identifier of objectSchema.identifiers) {
+    if (identifier.name) {
+      properties[identifier.name] = {
+        type: 'string'
+      };
+    }
+
+    if (identifier.fieldName) {
+      properties[identifier.fieldName] = {
+        type: objectSchema.fieldNames[identifier.fieldName].type
+      };
+    }
+  }
+
+  return {
+    type: 'object',
+    properties,
+    additionalProperties: false
+  };
+}
+
+async function _handleConflictAndAddToQueue(
+  _izContext,
+  queueObjType,
+  queueIdentifiers,
+  flowType,
+  requestMessage,
+  lockTableName,
+  identifiersBase,
+  uniqueRequestId,
+  lockTag
+) {
+
+  _izContext.logger.debug(
+    'Function: _handleConflictAndAddToQueue',
+    {
+      queueObjType,
+      queueIdentifiers,
+      flowType,
+      requestMessage,
+      lockTableName,
+      identifiersBase,
+      uniqueRequestId,
+      lockTag
+    }
+  );
+
+  const queueSchemaResult =
+    await getObjectSchema.getObjSchemaS3WithCache(
+      _izContext,
+      queueObjType
+    );
+
+  if (
+    queueSchemaResult.errorsFound.length > 0 ||
+    !queueSchemaResult.result
+  ) {
+    throw new NoRetryError(
+      JSON.stringify(queueSchemaResult.errorsFound)
+    );
+  }
+
+  const queueObjectSchema = queueSchemaResult.result;
+
+  const queueStorageResource = getDynamoDbStorageResource(
+    _izContext,
+    queueObjectSchema
+  );
+
+  const queueTableName = dynamodbSharedLib.tableName(
+    _izContext,
+    queueStorageResource.tableName,
+    queueStorageResource.serviceTag
+  );
+
+  const queueDynamoDbIdentifiers =
+    await identifiersObject.dynamoDbIdentifiersByStorageResource(
+      _izContext,
+      queueObjectSchema,
+      queueStorageResource,
+      queueIdentifiers
+    );
+
+  // Save the queue record only when overwriteUniqueRequestId is not provided.
+  // If overwriteUniqueRequestId is provided, the request is already being processed
+  // through the existing record, so skip creating a new queue record.
+  if (
+    !requestMessage.hasOwnProperty('overwriteUniqueRequestId') ||
+    requestMessage.overwriteUniqueRequestId === ''
+  ) {
+
+    const queueRecordObjInstance = {
+      ...queueDynamoDbIdentifiers,
+      flowType,
+      messageBody: requestMessage
+    };
+
+    const queueValidationSchema = _createAjvValidationSchema(
+      queueObjectSchema
+    );
+
+    const queueValidationResult = validator.validateObject(
+      queueValidationSchema,
+      queueRecordObjInstance
+    );
+
+    if (queueValidationResult.pass !== true) {
+      throw new NoRetryError(queueValidationResult.error);
+    }
+
+    const conditionCheckElements = {
+      logicalElements: dynamodbSharedLib.generateNotExistLogicalElements(
+        queueDynamoDbIdentifiers,
+      ),
+      returnValues: 'ALL_NEW'
+    };
+
+    await dynamodbSharedLib.putItem(
+      _izContext,
+      queueTableName,
+      queueRecordObjInstance,
+      conditionCheckElements
+    );
+  }
+
+  const {
+    fieldNameUniqueRequestId,
+    fieldNameLockStatus
+  } = createLockFieldNames(lockTag)
+
+  const queryElementsWhenAcquireLock = {
+    logicalElements: [
+      {
+        type: 'function',
+        function: 'attribute_not_exists',
+        attribute: fieldNameUniqueRequestId
+      }
+    ],
+    returnValues: 'ALL_NEW'
+  };
+
+  try {
+    const reCheckLock = await dynamodbSharedLib.updateItem(
+      _izContext,
+      lockTableName,
+      identifiersBase,
+      {
+        [fieldNameUniqueRequestId]: uniqueRequestId,
+        [fieldNameLockStatus]: true
+      },
+      queryElementsWhenAcquireLock,
+      {
+        errorOnConditionalExpNotPass: true
+      }
+    );
+
+    return ['process', reCheckLock];
+  } catch (error) {
+    // Another request still owns the lock.
+    return ['stop', null];
+  }
+}
+
+
+function getDynamoDbStorageResource(
+  _izContext,
+  objectSchema,
+) {
+  for (const storageResource of Object.values(
+    objectSchema.storageResources
+  )) {
+    if (storageResource.storageType !== 'dynamoDB') {
+      continue;
+    }
+
+    if (!storageResource.tableName) {
+      continue;
+    }
+
+    return storageResource;
+  }
+
+  throw new NoRetryError(
+    `DynamoDB storage resource with tableName not found for objType: `
+    + `${JSON.stringify(objectSchema.objectType)}`
+  );
+}
+
+function createLockFieldNames(lockTag) {
+  const fieldNameUniqueRequestId =
+    lockUpdateConstants.createUniqueRequestIdFieldName(lockTag);
+
+  const fieldNameLockStatus =
+    lockUpdateConstants.createLockStatusFieldName(lockTag);
+
+  return {
+    fieldNameUniqueRequestId,
+    fieldNameLockStatus
+  };
+}
+
+
+function getAddOnConfig(
+  _izContext,
+  mainObjectSchema,
+) {
+  let lockTag = null;
+  let storageResourceTag = null;
+
+  if (Array.isArray(mainObjectSchema.addOnDataStructure)) {
+    for (const addOnData of mainObjectSchema.addOnDataStructure) {
+      if (
+        addOnData.type !== 'reserveQuantity' &&
+        addOnData.type !== 'lockUpdate'
+      ) {
+        continue;
+      }
+
+      let currentLockUpdateTag = null;
+
+      if (addOnData.type === 'reserveQuantity') {
+        currentLockUpdateTag = addOnData.reserveQuantityTag;
+      }
+
+      if (addOnData.type === 'lockUpdate') {
+        currentLockUpdateTag = addOnData.lockUpdateTag;
+      }
+
+      if (!currentLockUpdateTag) {
+        throw new NoRetryError(`Missing lock update tag for add-on type '${addOnData.type}'`,);
+      }
+
+      lockTag = currentLockUpdateTag;
+      storageResourceTag = addOnData.storageResourceTag;
+
+      break;
+    }
+  }
+
+  if (!lockTag) {
+    throw new NoRetryError(`
+      Add-on type 'reserveQuantity' or 'lockUpdate' not found for objType '${JSON.stringify(mainObjectSchema.objectType)}'`,
+    );
+  }
+
+  return {
+    lockTag,
+    storageResourceTag
+  };
+}
+
+
+
+
+
+/**
+ * Checks the main object's lock status and determines whether to process,
+ * finalize, or queue the request.
+ *
+ * @param {Object} _izContext - Execution context.
+ * @param {Object} mainObjType - Main object type used to resolve storage configuration.
+ * @param {Object} identifiers - Identifiers of the main object record.
+ * @param {Object} queueIdentifiers - Identifiers used to construct the queue record's keys.
+ * @param {Object} flowType - Flow type used to identify the request's processing flow.
+ * @param {string} uniqueRequestId - Unique identifier for the request.
+ * @param {Object} requestMessage - Request message to enqueue when the lock is unavailable.
+ * @param {Object} errorParam - Found errors and service-level error tags.
+ * @returns {Promise<Array|Object>} Processing result and associated record
+ * data, or an object containing errorParam as foundErrors.
+ */
+async function checkRequestWithLock(
+  _izContext,
+  mainObjType,
+  identifiers,
+  queueIdentifiers,
+  flowType,
+  uniqueRequestId,
+  requestMessage,
+  errorParams
+) {
+  try {
+    _izContext.logger.debug('Function: checkRequestWithLock', {
+      mainObjType,
+      identifiers,
+      queueIdentifiers,
+      flowType,
+      uniqueRequestId,
+      requestMessage
+    });
+
+    const schemaResult = await getObjectSchema.getObjSchemaS3WithCache(
+      _izContext,
+      mainObjType
+    );
+
+    if (schemaResult.errorsFound.length > 0 || !schemaResult.result) {
+      throw new NoRetryError(
+        JSON.stringify(schemaResult.errorsFound)
+      );
+    }
+
+    const mainObjectSchema = schemaResult.result;
+
+    const { lockTag, storageResourceTag } =
+      getAddOnConfig(
+        _izContext,
+        mainObjectSchema,
+      );
+
+    const mainObjectStorage = mainObjectSchema.storageResources[storageResourceTag];
+
+    const lockFieldNames = createLockFieldNames(lockTag);
+
+    const fieldNameUniqueRequestId = lockFieldNames.fieldNameUniqueRequestId;
+    const fieldNameLockStatus = lockFieldNames.fieldNameLockStatus;
+
+    const lockTableName = dynamodbSharedLib.tableName(
+      _izContext,
+      mainObjectStorage.tableName,
+      mainObjectStorage.serviceTag
+    );
+
+    const identifiersBase = await identifiersObject.identifiersBaseFromIdentifiers(
+      _izContext,
+      mainObjType,
+      identifiers
+    );
+
+    const lockRecord = await dynamodbSharedLib.getItem(
+      _izContext,
+      lockTableName,
+      identifiersBase
+    );
+
+    if (!lockRecord) {
+      throw new NoRetryError(
+        `Lock record not found. mainObjType: ${JSON.stringify(mainObjType)}, ` +
+        `identifiersBase: ${JSON.stringify(identifiersBase)}`
+      );
+    }
+
+    const lockUniqueRequestId = lockRecord[fieldNameUniqueRequestId];
+    const statusProcessing = lockRecord[fieldNameLockStatus];
+
+    _izContext.logger.debug('Lock status', {
+      lockRecord,
+      [fieldNameUniqueRequestId]: lockUniqueRequestId,
+      [fieldNameLockStatus]: statusProcessing,
+      uniqueRequestId
+    });
+
+    if (
+      lockUniqueRequestId === undefined &&
+      !statusProcessing
+    ) {
+
+      const validationErrors = graphSharedLib.checkPropertiesValidWithSchema(
+        _izContext,
+        mainObjectSchema,
+        {
+          [fieldNameUniqueRequestId]: uniqueRequestId,
+          [fieldNameLockStatus]: true
+        },
+        errorParams
+      );
+
+      if (validationErrors.length > 0) {
+        throw new NoRetryError(validationErrors.join('; '));
+      }
+
+      try {
+        const queryElementsWhenAcquireLock = {
+          additionalAttributes: {
+            currentLockStatus: false
+          },
+          logicalElements: [
+            {
+              type: 'function',
+              function: 'attribute_not_exists',
+              attribute: fieldNameUniqueRequestId
+            },
+            {
+              type: 'logicalOperator',
+              operator: 'and'
+            },
+            {
+              type: 'group',
+              elements: [
+                {
+                  type: 'function',
+                  function: 'attribute_not_exists',
+                  attribute: fieldNameLockStatus
+                },
+                {
+                  type: 'logicalOperator',
+                  operator: 'or'
+                },
+                {
+                  type: 'logical',
+                  comparison: 'equals',
+                  lhsAttribute: fieldNameLockStatus,
+                  rhsReference: 'currentLockStatus'
+                }
+              ]
+            }
+          ],
+          returnValues: 'ALL_NEW'
+        };
+
+        const updatedLock = await dynamodbSharedLib.updateItem(
+          _izContext,
+          lockTableName,
+          identifiersBase,
+          {
+            [fieldNameUniqueRequestId]: uniqueRequestId,
+            [fieldNameLockStatus]: true
+          },
+          queryElementsWhenAcquireLock,
+          {
+            errorOnConditionalExpNotPass: true
+          }
+        );
+
+        return ['process', updatedLock];
+      } catch (error) {
+
+        if (error.message !== 'ConditionalExpNotPass') {
+          throw new NoRetryError(
+            'updateItem failed: ' + error.message,
+            error
+          );
+        }
+
+        return await _handleConflictAndAddToQueue(
+          _izContext,
+          queueObjType,
+          queueIdentifiers,
+          flowType,
+          requestMessage,
+          lockTableName,
+          identifiersBase,
+          uniqueRequestId,
+          lockTag
+        );
+      }
+    } else if (lockUniqueRequestId === uniqueRequestId) {
+
+      if (statusProcessing === true) {
+        return ['process', lockRecord];
+      }
+
+      if (statusProcessing === false) {
+        return ['finalize', lockRecord];
+      }
+
+      throw new NoRetryError(
+        `Invalid processing status: ${statusProcessing}, identifiers: ${JSON.stringify(identifiers)}`,
+      );
+
+    } else {
+      return await _handleConflictAndAddToQueue(
+        _izContext,
+        queueTableName,
+        queueIdentifiers,
+        flowType,
+        requestMessage,
+        lockTableName,
+        identifiersBase,
+        uniqueRequestId,
+        fieldNameUniqueRequestId,
+        fieldNameLockStatus,
+        // errorParam
+      );
+    }
+  } catch (error) {
+    _izContext.logger.error('Error in checkRequestWithLock:', {
+      errorMessage: error.message
+    });
+
+    throw error;
+  }
+}
+
+/**
+ * Updates the main object record only when the lock belongs to the current
+ * request, then releases the lock.
+ *
+ * @param {Object} _izContext - Execution context.
+ * @param {string} mainObjType - Main object type used to resolve storage configuration.
+ * @param {Object} identifiers - Identifiers of the main object record.
+ * @param {string} checkUniqueRequestId - Unique request ID used to validate the lock.
+ * @param {Object} additionalAttributes - Additional attributes to update on the main object record.
+ * @param {Object} errorParam - Found errors and service-level error tags.
+ * @returns {Promise<Object>} Updated main object record.
+ */
+async function updateMainRecordWithLock(
+  _izContext,
+  mainObjType,
+  identifiers,
+  checkUniqueRequestId,
+  errorParam,
+  additionalAttributes = {},
+) {
+  const schemaResult = await getObjectSchema.getObjSchemaS3WithCache(
+    _izContext,
+    mainObjType
+  );
+
+  if (schemaResult.errorsFound.length > 0 || !schemaResult.result) {
+    throw new NoRetryError(
+      JSON.stringify(schemaResult.errorsFound)
+    );
+  }
+
+  const mainObjectSchema = schemaResult.result;
+
+  const {
+    lockTag,
+    storageResourceTag
+  } = getAddOnConfig(
+    _izContext,
+    mainObjectSchema
+  );
+
+  const mainObjectStorage =
+    mainObjectSchema.storageResources[storageResourceTag];
+
+  const mainTableName = dynamodbSharedLib.tableName(
+    _izContext,
+    mainObjectStorage.tableName,
+    mainObjectStorage.serviceTag
+  );
+
+  const {
+    fieldNameUniqueRequestId,
+    fieldNameLockStatus
+  } = createLockFieldNames(lockTag);
+
+  // Validate additional attributes and lock release together.
+  const propertiesToValidate = Object.assign(
+    {},
+    additionalAttributes,
+    {
+      [fieldNameLockStatus]: false
+    }
+  );
+
+  const validationErrors = graphSharedLib.checkPropertiesValidWithSchema(
+    _izContext,
+    mainObjectSchema,
+    propertiesToValidate,
+    errorParam
+  );
+
+  if (
+    Array.isArray(validationErrors) &&
+    validationErrors.length > 0
+  ) {
+    throw new NoRetryError(validationErrors.join('; '));
+  }
+
+  const updateAttributes = [];
+
+  for (const attributeName of Object.keys(propertiesToValidate)) {
+    updateAttributes.push({
+      attributeName: attributeName,
+      action: 'set',
+      value: propertiesToValidate[attributeName]
+    });
+  }
+
+  const queryElementsWhenUpdateMainRecord = {
+    additionalAttributes: {
+      currentUniqueRequestId: checkUniqueRequestId
+    },
+    logicalElements: [
+      {
+        type: 'logical',
+        comparison: 'equals',
+        lhsAttribute: fieldNameUniqueRequestId,
+        rhsReference: 'currentUniqueRequestId'
+      }
+    ],
+    returnValues: 'ALL_NEW'
+  };
+
+  try {
+    return await dynamodbSharedLib.updateItem(
+      _izContext,
+      mainTableName,
+      identifiers,
+      updateAttributes,
+      queryElementsWhenUpdateMainRecord,
+      {
+        complexAttributes: true,
+        errorOnConditionalExpNotPass: true
+      }
+    );
+  } catch (error) {
+    if (error.message === 'ConditionalExpNotPass') {
+      throw new NoRetryError(
+        'Cannot update main record because lock does not belong to current request.'
+      );
+    }
+
+    throw error;
+  }
+}
+
+
+function getLockTagFromObjectType(objectType) {
+  const suffixes = ['History', 'Queue'];
+
+  for (const suffix of suffixes) {
+    if (objectType.endsWith(suffix)) {
+      return objectType.slice(0, -suffix.length);
+    }
+  }
+
+  throw new NoRetryError(`Invalid lock objectType: ${objectType}`);
+}
+
+/**
+ * Ensures a lock history record exists for the supplied identifiers.
+ *
+ * Creates a history record if it does not exist.
+ * Returns the existing record if it already exists.
+ *
+ * @param {Object} _izContext - Execution context.
+ * @param {string} historyObjType - History object type.
+ * @param {Object} historyIdentifiers - Identifiers of the history record.
+ * @param {string} targetStatus - Status stored in the history record.
+ * @param {Object} errorParams - Error handling parameters.
+ * @param {Object} additionalAttributes - Additional attributes to store.
+ * @param {Object} queryElements - Additional query elements for the operation.
+ * @returns {Promise<Object>} The created or existing history record.
+ */
+async function ensureHistory(
+  _izContext,
+  historyObjType,
+  historyIdentifiers,
+  targetStatus,
+  errorParams,
+  additionalAttributes = {},
+  queryElements = {},
+) {
+
+  const schemaResult = await getObjectSchema.getObjSchemaS3WithCache(
+    _izContext,
+    historyObjType
+  );
+
+  if (schemaResult.errorsFound.length > 0 || !schemaResult.result) {
+    throw new NoRetryError(
+      JSON.stringify(schemaResult.errorsFound)
+    );
+  }
+
+  const historyObjectSchema = schemaResult.result;
+
+  const historyStorageResource = getDynamoDbStorageResource(
+    _izContext,
+    historyObjectSchema
+  );
+
+  const historyTableName = dynamodbSharedLib.tableName(
+    _izContext,
+    historyStorageResource.tableName,
+    historyStorageResource.serviceTag
+  );
+
+  const lockTag = getLockTagFromObjectType(historyObjectSchema.objectType);
+
+  const fieldNameStatus =
+    lockUpdateConstants.createStatusFieldName(lockTag);
+
+  const propertiesToValidate = {
+    [fieldNameStatus]: targetStatus
+  };
+
+  if (additionalAttributes && typeof additionalAttributes === 'object') {
+    for (const attributeName of Object.keys(additionalAttributes)) {
+      propertiesToValidate[attributeName] = additionalAttributes[attributeName];
+    }
+  }
+
+  const validationErrors = graphSharedLib.checkPropertiesValidWithSchema(
+    _izContext,
+    historyObjectSchema,
+    propertiesToValidate,
+    errorParams
+  );
+
+  if (Array.isArray(validationErrors) && validationErrors.length > 0) {
+    throw new NoRetryError(validationErrors.join('; '));
+  }
+
+  const updateAttributes = [
+    {
+      attributeName: fieldNameStatus,
+      action: 'set',
+      value: targetStatus
+    }
+  ];
+
+  if (additionalAttributes && typeof additionalAttributes === 'object') {
+    for (const [attributeName, value] of Object.entries(additionalAttributes)) {
+      updateAttributes.push({
+        attributeName,
+        action: 'set',
+        value
+      });
+    }
+  }
+
+  const identifiersBase = await identifiersObject.dynamoDbIdentifiersByStorageResource(
+    _izContext,
+    historyObjectSchema,
+    historyStorageResource,
+    historyIdentifiers,
+  );
+
+  try {
+    return await dynamodbSharedLib.updateItem(
+      _izContext,
+      historyTableName,
+      identifiersBase,
+      updateAttributes,
+      queryElements,
+      {
+        complexAttributes: true,
+      }
+    );
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Removes the current request from the lock queue and publishes the next
+ * waiting request to its original flow, if one exists.
+ *
+ * @param {Object} _izContext - Execution context.
+ * @param {string} queueObjType - Queue object type.
+ * @param {Object} identifiers - Identifiers of the current queue record.
+ * @returns {Promise<Object|null>} SNS publish result, or null if the queue is empty.
+ */
+async function publishNextWaitingRequest(
+  _izContext,
+  queueObjType,
+  identifiers
+) {
+  // Get Queue ObjectSchema
+  const queueSchemaResult = await getObjectSchema.getObjSchemaS3WithCache(
+    _izContext,
+    queueObjType
+  );
+
+  if (
+    queueSchemaResult.errorsFound.length > 0 ||
+    !queueSchemaResult.result
+  ) {
+    throw new NoRetryError(
+      `Unable to get Queue ObjectSchema '${queueObjType}': ` +
+      JSON.stringify(queueSchemaResult.errorsFound)
+    );
+  }
+
+  const queueObjectSchema = queueSchemaResult.result;
+
+  // Get Queue DynamoDB Table
+  const queueStorageResource = getDynamoDbStorageResource(
+    _izContext,
+    queueObjectSchema
+  );
+
+  const queueTableName = dynamodbSharedLib.tableName(
+    _izContext,
+    queueStorageResource.tableName,
+    queueStorageResource.serviceTag
+  );
+
+  // Convert identifiers to ObjInstanceBase
+  const identifiersBase = await identifiersObject.identifiersBaseFromIdentifiers(
+    _izContext,
+    queueObjType,
+    identifiers
+  );
+
+  // Get Partition Key
+  const partitionKeyValue = {};
+  let hasSortKey = false;
+
+  for (const identifier of queueObjectSchema.identifiers) {
+    if (identifier.type === 'partitionKey') {
+      let partitionKeyFieldName = identifier.fieldName;
+
+      if (
+        !Object.prototype.hasOwnProperty.call(
+          identifiersBase,
+          partitionKeyFieldName
+        )
+      ) {
+        partitionKeyFieldName = identifier.name;
+      }
+
+      if (
+        !partitionKeyFieldName ||
+        !Object.prototype.hasOwnProperty.call(
+          identifiersBase,
+          partitionKeyFieldName
+        )
+      ) {
+        throw new NoRetryError(
+          `Missing partition key in identifiersBase for Queue '${queueObjType}'`
+        );
+      }
+
+      partitionKeyValue[partitionKeyFieldName] = identifiersBase[partitionKeyFieldName];
+
+    } else if (identifier.type === 'sortKey') {
+      if (!identifier.name) {
+        throw new NoRetryError(
+          `Queue schema '${queueObjType}' has an invalid sortKey identifier`
+        );
+      }
+
+      hasSortKey = true;
+    }
+  }
+
+  if (!hasSortKey) {
+    throw new NoRetryError(
+      `Queue schema '${queueObjType}' is missing sortKey`
+    );
+  }
+
+  // Delete Current Queue Record
+  await dynamodbSharedLib.deleteItem(
+    _izContext,
+    queueTableName,
+    identifiersBase
+  );
+
+  // Get Next Waiting Request
+  const queryResult = await dynamodbSharedLib.query(
+    _izContext,
+    queueTableName,
+    partitionKeyValue,
+    { limit: 1 }
+  );
+
+  if (queryResult.Items.length === 0) {
+    _izContext.logger.debug('Lock queue is empty, there is no next message');
+
+    return null;
+  }
+
+  const nextQueueRecord = queryResult.Items[0];
+
+  // Convert Queue ObjInstanceBase to ObjInstance
+  const nextQueueObjInstance =
+    await identifiersObject.objInstanceFromObjInstanceBase(
+      _izContext,
+      queueObjType,
+      nextQueueRecord
+    );
+
+  const flowType = nextQueueObjInstance.flowType;
+  const messageBody = nextQueueObjInstance.messageBody;
+  const nextUniqueRequestId = nextQueueObjInstance.uniqueRequestId;
+
+  // Prepare Next Request Message
+  const message = {
+    ...messageBody,
+    overwriteUniqueRequestId: nextUniqueRequestId
+  };
+
+  // Publish Next Request to Original Flow
+  const topicName = `${flowType.flowTag}_In`;
+
+  const topicArn = snsSharedLib.snsTopicArnByFlowSchema(
+    _izContext,
+    topicName,
+    flowType.serviceTag
+  );
+
+  const snsPublishParams = {
+    Message: JSON.stringify(message),
+    TopicArn: topicArn
+  };
+
+  return sns.publishAsync(_izContext, snsPublishParams);
+}
+
+
+/**
+ * Safely removes the uniqueRequestId lock only if its current value matches
+ * the expected uniqueRequestId.
+ *
+ * @param {Object} _izContext - Execution context containing the logger.
+ * @param {string} mainObjType - Main object type.
+ * @param {Object} identifiersBase - Identifiers of the main record.
+ * @param {string} uniqueRequestId - Expected uniqueRequestId value for the lock.
+ * @returns {Promise<Object>} Updated main record.
+ */
+async function removeUniqueRequestIdSafe(
+  _izContext,
+  mainObjType,
+  identifiersBase,
+  uniqueRequestId,
+) {
+
+  const schemaResult = await getObjectSchema.getObjSchemaS3WithCache(
+    _izContext,
+    mainObjType
+  );
+
+  if (schemaResult.errorsFound.length > 0 || !schemaResult.result) {
+    throw new NoRetryError(
+      JSON.stringify(schemaResult.errorsFound)
+    );
+  }
+
+  const mainObjectSchema = schemaResult.result;
+
+
+  const { lockTag, storageResourceTag } = getAddOnConfig(
+    _izContext,
+    mainObjectSchema,
+  );
+
+  const { fieldNameUniqueRequestId } = createLockFieldNames(lockTag);
+
+  if (!mainObjectSchema.fieldNames || !Object.prototype.hasOwnProperty.call(mainObjectSchema.fieldNames, fieldNameUniqueRequestId)) {
+    throw new NoRetryError(
+      `Field '${fieldNameUniqueRequestId}' not found in schema '${mainObjectSchema.objectType}'`
+    );
+  }
+
+  const mainObjectStorage = mainObjectSchema.storageResources[storageResourceTag];
+
+
+  const lockTableName = dynamodbSharedLib.tableName(
+    _izContext,
+    mainObjectStorage.tableName,
+    mainObjectStorage.serviceTag
+  );
+
+  const queryElements = {
+    additionalAttributes: {
+      currentUniqueRequestId: uniqueRequestId
+    },
+    logicalElements: [
+      {
+        type: 'logical',
+        comparison: 'equals',
+        lhsAttribute: fieldNameUniqueRequestId,
+        rhsReference: 'currentUniqueRequestId'
+      }
+    ],
+    returnValues: 'ALL_NEW'
+  };
+
+  try {
+    await dynamodbSharedLib.updateItem(
+      _izContext,
+      lockTableName,
+      identifiersBase,
+      [
+        {
+          attributeName: fieldNameUniqueRequestId,
+          action: 'remove'
+        }
+      ],
+      queryElements,
+      {
+        complexAttributes: true,
+        errorOnConditionalExpNotPass: true
+      }
+    );
+  } catch (error) {
+    if (error.message === 'ConditionalExpNotPass') {
+      _izContext.logger.error(
+        'Failed to remove uniqueRequestId because it did not match',
+        {
+          tableName: lockTableName,
+          identifiers: identifiersBase,
+          uniqueRequestId
+        }
+      );
+
+      throw new NoRetryError(
+        'Cannot remove uniqueRequestId because it does not match the current request.'
+      );
+    }
+    throw error;
+  }
+}
+
+export {
+  // 1. Configuration and utilities
+  getAddOnConfig,
+  getDynamoDbStorageResource,
+  createLockFieldNames,
+
+  // 2. Lock management
+  checkRequestWithLock,
+  updateMainRecordWithLock,
+  ensureHistory,
+  removeUniqueRequestIdSafe,
+
+  // 3. Queue management
+  publishNextWaitingRequest
+};