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

package/src/validation/lockUpdateSchemaValidation.js

@@ -0,0 +1,607 @@
+/*
+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 errorHandlingLib from '@izara_project/izara-core-library-error-handling';
+import lockUpdateConstants from '../constants/lockUpdateConstants.js';
+
+function _getIdentifierByType(objectSchema, identifierType) {
+  if (!objectSchema || !Array.isArray(objectSchema.identifiers)) {
+    return null;
+  }
+
+  for (const identifier of objectSchema.identifiers) {
+    if (identifier && identifier.type === identifierType) {
+      return identifier;
+    }
+  }
+
+  return null;
+}
+
+function _getIdentifierFieldName(identifier) {
+  if (!identifier) {
+    return null;
+  }
+
+  if (identifier.name) {
+    return identifier.name;
+  }
+
+  if (identifier.fieldName) {
+    return identifier.fieldName;
+  }
+
+  if (Array.isArray(identifier.fieldNames) && identifier.fieldNames.length > 0) {
+    return identifier.fieldNames.join('_');
+  }
+
+  return null;
+}
+
+function _validateRequiredFields(_izContext, objectSchema, requiredFieldNames, validationErrors) {
+  if (!objectSchema) {
+    return;
+  }
+
+  if (!objectSchema.fieldNames) {
+    objectSchema.fieldNames = {};
+  }
+
+  for (const fieldName of requiredFieldNames) {
+    if (!Object.prototype.hasOwnProperty.call(objectSchema.fieldNames, fieldName)) {
+      errorHandlingLib.addThrowLibErrors(
+        _izContext,
+        `Missing required field '${fieldName}' in schema '${objectSchema.objectType}'`,
+        validationErrors
+      );
+    }
+  }
+}
+
+function _validateStorageResourceTags(_izContext, objectSchema, fieldName, validationErrors) {
+  if (!objectSchema || !objectSchema.fieldNames) {
+    return;
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(objectSchema.fieldNames, fieldName)) {
+    return;
+  }
+
+  const fieldConfig = objectSchema.fieldNames[fieldName];
+
+  if (!fieldConfig) {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      `Field config is missing for field '${fieldName}' in schema '${objectSchema.objectType}'`,
+      validationErrors
+    );
+
+    return;
+  }
+
+  if (!Array.isArray(fieldConfig.storageResourceTags)) {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      `storageResourceTags missing on field '${fieldName}' in schema '${objectSchema.objectType}'`,
+      validationErrors
+    );
+  }
+}
+
+/**
+ * Validates the main object's lock fields and storage resource based on addOnDataStructure
+ *
+ * @param {Object} _izContext - Execution context.
+ * @param {Object} mainObjectSchema - Main object schema.
+ * @returns {Array} Array of validation errors.
+ */
+function validateMainObjectSchema(_izContext, mainObjectSchema) {
+  const validationErrors = [];
+
+  if (!mainObjectSchema) {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      'Main object schema is required',
+      validationErrors
+    );
+
+    return validationErrors;
+  }
+
+  if (!Array.isArray(mainObjectSchema.addOnDataStructure)) {
+    return validationErrors;
+  }
+
+  if (!mainObjectSchema.fieldNames) {
+    mainObjectSchema.fieldNames = {};
+  }
+
+  if (!mainObjectSchema.storageResources) {
+    mainObjectSchema.storageResources = {};
+  }
+
+  for (const addOn of mainObjectSchema.addOnDataStructure) {
+    if (!addOn) {
+      continue;
+    }
+
+    const addOnType = addOn.type;
+
+    let lockTag = null;
+    let storageResourceTag = null;
+
+    if (addOnType === 'reserveQuantity') {
+      lockTag = addOn.reserveQuantityTag;
+      storageResourceTag = addOn.storageResourceTag;
+    } else if (addOnType === 'lockUpdate') {
+      lockTag = addOn.lockUpdateTag;
+      storageResourceTag = addOn.storageResourceTag;
+    } else {
+      continue;
+    }
+
+    if (!lockTag) {
+      errorHandlingLib.addThrowLibErrors(
+        _izContext,
+        `Missing lock tag for addOn type '${addOnType}' in schema '${mainObjectSchema.objectType}'`,
+        validationErrors
+      );
+
+      continue;
+    }
+
+    if (!storageResourceTag) {
+      errorHandlingLib.addThrowLibErrors(
+        _izContext,
+        `Missing storageResourceTag for addOn type '${addOnType}' in schema '${mainObjectSchema.objectType}'`,
+        validationErrors
+      );
+
+      continue;
+    }
+
+    const fieldNameLockStatus = lockUpdateConstants.createLockStatusFieldName(lockTag);
+    const fieldNameUniqueRequestId = lockUpdateConstants.createUniqueRequestIdFieldName(lockTag);
+
+    const requiredFieldNames = [
+      fieldNameLockStatus,
+      fieldNameUniqueRequestId
+    ];
+
+    _validateRequiredFields(
+      _izContext,
+      mainObjectSchema,
+      requiredFieldNames,
+      validationErrors
+    );
+
+    for (const fieldName of requiredFieldNames) {
+      _validateStorageResourceTags(
+        _izContext,
+        mainObjectSchema,
+        fieldName,
+        validationErrors
+      );
+
+      if (Object.prototype.hasOwnProperty.call(mainObjectSchema.fieldNames, fieldName)) {
+        const fieldConfig = mainObjectSchema.fieldNames[fieldName];
+
+        if (Array.isArray(fieldConfig.storageResourceTags) && !fieldConfig.storageResourceTags.includes(storageResourceTag)) {
+          errorHandlingLib.addThrowLibErrors(
+            _izContext,
+            `Field '${fieldName}' must include storageResourceTag '${storageResourceTag}'`,
+            validationErrors
+          );
+        }
+      }
+    }
+
+    if (!Object.prototype.hasOwnProperty.call(mainObjectSchema.storageResources, storageResourceTag)) {
+      errorHandlingLib.addThrowLibErrors(
+        _izContext,
+        `Storage resource '${storageResourceTag}' not found in schema '${mainObjectSchema.objectType}'`,
+        validationErrors
+      );
+    } else {
+      const storageResource = mainObjectSchema.storageResources[storageResourceTag];
+
+      if (!storageResource) {
+        errorHandlingLib.addThrowLibErrors(
+          _izContext,
+          `Storage resource config is missing for '${storageResourceTag}' in schema '${mainObjectSchema.objectType}'`,
+          validationErrors
+        );
+      } else if (!storageResource.tableName) {
+        errorHandlingLib.addThrowLibErrors(
+          _izContext,
+          `Missing tableName for storage resource '${storageResourceTag}' in schema '${mainObjectSchema.objectType}'`,
+          validationErrors
+        );
+      }
+    }
+  }
+
+  return validationErrors;
+}
+
+/**
+ * Validates the lock history schema
+ *
+ * @param {Object} _izContext - Execution context.
+ * @param {Object} historyObjectSchema - Lock history schema.
+ * @returns {Array} Array of validation errors.
+ */
+function validateHistorySchema(_izContext, historyObjectSchema) {
+  const validationErrors = [];
+
+  if (!historyObjectSchema) {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      'History object schema is required',
+      validationErrors
+    );
+
+    return validationErrors;
+  }
+
+  if (!historyObjectSchema.fieldNames) {
+    historyObjectSchema.fieldNames = {};
+  }
+
+  if (!historyObjectSchema.objectType || typeof historyObjectSchema.objectType !== 'string') {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      'History object schema must have objectType',
+      validationErrors
+    );
+
+    return validationErrors;
+  }
+
+  const historyObjectType = historyObjectSchema.objectType;
+
+  if (historyObjectType.indexOf('History') === -1) {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      `History object schema must end with 'History', found '${historyObjectType}'`,
+      validationErrors
+    );
+
+    return validationErrors;
+  }
+
+  const lockTag = historyObjectType.replace('History', '');
+
+  if (!lockTag) {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      `Invalid lock tag derived from history objectType '${historyObjectType}'`,
+      validationErrors
+    );
+
+    return validationErrors;
+  }
+
+  const fieldNameStatus = lockUpdateConstants.createStatusFieldName(lockTag);
+
+  const requiredFieldNames = [
+    'usedTimestamp',
+    'uniqueRequestId',
+    fieldNameStatus
+  ];
+
+  _validateRequiredFields(
+    _izContext,
+    historyObjectSchema,
+    requiredFieldNames,
+    validationErrors
+  );
+
+  for (const fieldName of requiredFieldNames) {
+    _validateStorageResourceTags(
+      _izContext,
+      historyObjectSchema,
+      fieldName,
+      validationErrors
+    );
+  }
+
+  const historyPartitionKey = _getIdentifierByType(historyObjectSchema, 'partitionKey');
+  const historySortKey = _getIdentifierByType(historyObjectSchema, 'sortKey');
+
+  if (!historyPartitionKey) {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      `History schema '${historyObjectSchema.objectType}' is missing partitionKey`,
+      validationErrors
+    );
+  }
+
+  if (!historySortKey) {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      `History schema '${historyObjectSchema.objectType}' is missing sortKey`,
+      validationErrors
+    );
+  } else {
+    const historySortKeyName = _getIdentifierFieldName(historySortKey);
+
+    if (historySortKeyName !== 'timestampUniqueId') {
+      errorHandlingLib.addThrowLibErrors(
+        _izContext,
+        `History sortKey must be 'timestampUniqueId', found '${historySortKeyName}'`,
+        validationErrors
+      );
+    }
+  }
+
+  return validationErrors;
+}
+
+/**
+ * Validates the lock queue schema
+ *
+ * @param {Object} _izContext - Execution context.
+ * @param {Object} queueObjectSchema - Lock queue schema.
+ * @returns {Array} Array of validation errors.
+ */
+function validateQueueSchema(_izContext, queueObjectSchema) {
+  const validationErrors = [];
+
+  if (!queueObjectSchema) {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      'Queue object schema is required',
+      validationErrors
+    );
+
+    return validationErrors;
+  }
+
+  if (!queueObjectSchema.fieldNames) {
+    queueObjectSchema.fieldNames = {};
+  }
+
+  if (!queueObjectSchema.objectType || typeof queueObjectSchema.objectType !== 'string') {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      'Queue object schema must have objectType',
+      validationErrors
+    );
+
+    return validationErrors;
+  }
+
+  const queueObjectType = queueObjectSchema.objectType;
+
+  if (queueObjectType.indexOf('Queue') === -1) {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      `Queue object schema must end with 'Queue', found '${queueObjectType}'`,
+      validationErrors
+    );
+
+    return validationErrors;
+  }
+
+  const requiredFieldNames = [
+    'usedTimestamp',
+    'uniqueRequestId',
+    'flowType',
+    'messageBody'
+  ];
+
+  _validateRequiredFields(
+    _izContext,
+    queueObjectSchema,
+    requiredFieldNames,
+    validationErrors
+  );
+
+  for (const fieldName of requiredFieldNames) {
+    _validateStorageResourceTags(
+      _izContext,
+      queueObjectSchema,
+      fieldName,
+      validationErrors
+    );
+  }
+
+  const queuePartitionKey = _getIdentifierByType(queueObjectSchema, 'partitionKey');
+  const queueSortKey = _getIdentifierByType(queueObjectSchema, 'sortKey');
+
+  if (!queuePartitionKey) {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      `Queue schema '${queueObjectSchema.objectType}' is missing partitionKey`,
+      validationErrors
+    );
+  }
+
+  if (!queueSortKey) {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      `Queue schema '${queueObjectSchema.objectType}' is missing sortKey`,
+      validationErrors
+    );
+  } else {
+    const queueSortKeyName = _getIdentifierFieldName(queueSortKey);
+
+    if (queueSortKeyName !== 'timestampUniqueId') {
+      errorHandlingLib.addThrowLibErrors(
+        _izContext,
+        `Queue sortKey must be 'timestampUniqueId', found '${queueSortKeyName}'`,
+        validationErrors
+      );
+    }
+  }
+
+  return validationErrors;
+}
+
+
+/**
+ * Validates the full lock schemas for main object schema
+ * - validates main object schema via validateMainObjectSchema
+ * - finds <tag>History and <tag>Queue from schemasMap
+ * - validates history and queue via validateHistorySchema/validateQueueSchema
+ * - validates cross-schema rules (partitionKey must match, sortKey consistency)
+ *
+ * @param {Object} _izContext - Execution context.
+ * @param {Object} mainObjectSchema - Main object schema.
+ * @param {Object} schemasMap - Map of objectType -> objectSchema
+ * @returns {Array} Array of validation errors.
+ */
+function validateLockSchemas(_izContext, mainObjectSchema, schemasMap) {
+  const validationErrors = [];
+
+  if (!mainObjectSchema) {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      'Main object schema is required',
+      validationErrors
+    );
+
+    return validationErrors;
+  }
+
+  if (!schemasMap || typeof schemasMap !== 'object') {
+    errorHandlingLib.addThrowLibErrors(
+      _izContext,
+      `schemasMap is required for full lock validation of schema '${mainObjectSchema.objectType}'`,
+      validationErrors
+    );
+
+    return validationErrors;
+  }
+
+  const mainErrors = validateMainObjectSchema(_izContext, mainObjectSchema);
+  for (let index = 0; index < mainErrors.length; index++) {
+    validationErrors.push(mainErrors[index]);
+  }
+
+  if (!Array.isArray(mainObjectSchema.addOnDataStructure)) {
+    return validationErrors;
+  }
+
+  for (const addOn of mainObjectSchema.addOnDataStructure) {
+    if (!addOn) {
+      continue;
+    }
+
+    const addOnType = addOn.type;
+
+    let lockTag = null;
+
+    if (addOnType === 'reserveQuantity') {
+      lockTag = addOn.reserveQuantityTag;
+    } else if (addOnType === 'lockUpdate') {
+      lockTag = addOn.lockUpdateTag;
+    } else {
+      continue;
+    }
+
+    if (!lockTag) {
+      continue;
+    }
+
+
+    const historySchemaKey = lockUpdateConstants.createHistoryObjectName(lockTag);
+    const queueSchemaKey = lockUpdateConstants.createQueueObjectName(lockTag);
+
+    const historyObjectSchema = schemasMap[historySchemaKey];
+    const queueObjectSchema = schemasMap[queueSchemaKey];
+
+    if (historyObjectSchema) {
+      const historyErrors = validateHistorySchema(_izContext, historyObjectSchema);
+      for (let index = 0; index < historyErrors.length; index++) {
+        validationErrors.push(historyErrors[index]);
+      }
+
+      const mainPartitionKey = _getIdentifierByType(mainObjectSchema, 'partitionKey');
+      const historyPartitionKey = _getIdentifierByType(historyObjectSchema, 'partitionKey');
+
+      if (mainPartitionKey && historyPartitionKey) {
+        const mainPartitionKeyName = _getIdentifierFieldName(mainPartitionKey);
+        const historyPartitionKeyName = _getIdentifierFieldName(historyPartitionKey);
+
+        if (mainPartitionKeyName && historyPartitionKeyName && mainPartitionKeyName !== historyPartitionKeyName) {
+          errorHandlingLib.addThrowLibErrors(
+            _izContext,
+            `History partitionKey '${historyPartitionKeyName}' must match Main Object partitionKey '${mainPartitionKeyName}' in schema '${mainObjectSchema.objectType}'`,
+            validationErrors
+          );
+        }
+      }
+    }
+
+    if (queueObjectSchema) {
+      const queueErrors = validateQueueSchema(_izContext, queueObjectSchema);
+      for (let index = 0; index < queueErrors.length; index++) {
+        validationErrors.push(queueErrors[index]);
+      }
+
+      if (historyObjectSchema) {
+        const historyPartitionKey = _getIdentifierByType(historyObjectSchema, 'partitionKey');
+        const queuePartitionKey = _getIdentifierByType(queueObjectSchema, 'partitionKey');
+
+        if (historyPartitionKey && queuePartitionKey) {
+          const historyPartitionKeyName = _getIdentifierFieldName(historyPartitionKey);
+          const queuePartitionKeyName = _getIdentifierFieldName(queuePartitionKey);
+
+          if (historyPartitionKeyName && queuePartitionKeyName && historyPartitionKeyName !== queuePartitionKeyName) {
+            errorHandlingLib.addThrowLibErrors(
+              _izContext,
+              `Queue partitionKey '${queuePartitionKeyName}' must match History partitionKey '${historyPartitionKeyName}' in schema '${mainObjectSchema.objectType}'`,
+              validationErrors
+            );
+          }
+        }
+
+        const historySortKey = _getIdentifierByType(historyObjectSchema, 'sortKey');
+        const queueSortKey = _getIdentifierByType(queueObjectSchema, 'sortKey');
+
+        if (historySortKey && queueSortKey) {
+          const historySortKeyName = _getIdentifierFieldName(historySortKey);
+          const queueSortKeyName = _getIdentifierFieldName(queueSortKey);
+
+          if (historySortKeyName && queueSortKeyName && historySortKeyName !== historySortKeyName) {
+            errorHandlingLib.addThrowLibErrors(
+              _izContext,
+              `Queue sortKey '${queueSortKeyName}' must match History sortKey '${historySortKeyName}' in schema '${mainObjectSchema.objectType}'`,
+              validationErrors
+            );
+          }
+        }
+      }
+    }
+  }
+
+  return validationErrors;
+}
+
+
+
+
+export default {
+  validateMainObjectSchema,
+  validateHistorySchema,
+  validateQueueSchema,
+  validateLockSchemas
+};