@izara_project/izara-core-library-service-schemas 1.0.96 → 1.0.98

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-library-service-schemas",
-  "version": "1.0.96",
+  "version": "1.0.98",
   "description": "Schemas for the service and objects it controls",
   "main": "index.js",
   "scripts": {

package/src/ValidatorSchema.js

@@ -53,7 +53,8 @@ const {
   getAllLocalFlowSchemas,
   getAllLocalRefObjectRelationshipSchema,
   getAllLocalRelationshipSchema,
-  getLocalRelationshipSchemas
+  getLocalRelationshipSchemas,
+  getObjectSchemaCombineFieldNamesWithCache,
 } = require("./GetObjectSchema");
 
 const {
@@ -87,14 +88,21 @@ const { validateObjType } = require('@izara_project/izara-shared-service-schemas
 //   return prefix + 'FlowParams';
 // }
 
-function createSpecificFieldNameForCacheTable(prefix = 'cache') {
+function createSpecificFieldNameForCacheTable(prefix = 'cache', statusType) {
   return {
-    uniqueRequestId: prefix + "UniqueRequestId",
-    fieldNameStatus: prefix + "Status",
-    errorsFound: prefix + 'ErrorsFound',
-    cacheComplete: prefix + 'CacheComplete',
-    flowParams: prefix + 'FlowParams'
-  }
+    'cacheTable': {
+      uniqueRequestId: prefix + "UniqueRequestId",
+      fieldNameStatus: prefix + "Status",
+      errorsFound: prefix + 'ErrorsFound',
+      cacheComplete: prefix + 'CacheComplete',
+      flowParams: prefix + 'FlowParams'
+    },
+    'statusField': {
+      uniqueRequestId: prefix + "UniqueRequestId",
+      errorsFound: prefix + "ErrorsFound",
+      fieldNameStatus: prefix + "Status"
+    }
+  }[statusType]
 }
 
 /**
@@ -536,46 +544,22 @@ async function generateValidatorSchemaForUpdate(_izContext, objType, settings =
   // _izContext.logger.debug("objectSchema", objectSchema)
 
   const objectSchemas = await uploadUseCase.generateObjectSchemaForCombineFieldNames(_izContext, objectSchema)
-  _izContext.logger.debug("objectSchemas", objectSchemas)
+  // _izContext.logger.debug("objectSchemas", objectSchemas)
 
   let usedIdentifierTypes = getIdentifierTypeByPriority(_izContext, [], objectSchema);
   _izContext.logger.debug({ usedIdentifierTypes });
   // collect requiredFieldNames by fieldName that includes in identifiers
   let identifiersFieldNames = getUsedFieldNamesOfIdentifiers(_izContext, objectSchemas.identifiers, usedIdentifierTypes);
+  // _izContext.logger.debug("identifiersFieldNames", identifiersFieldNames)
+  let fieldNameCanUpdates = [];
+  let versionedDataFieldNameCanUpdates = [];
 
-  let canUpdateFieldNames = [];
-  let canUpdateProperties = {};
+  // let canUpdateFieldNames = [];
+  // let canUpdateProperties = {};
   let usedFieldNames = identifiersFieldNames;
-  let versionedDataFieldNames = [];
-
-  // collect canUpdate fieldName (all fieldName have CanUpdate setting = true)
-  for (let [fieldName, fieldNameSetting] of Object.entries(objectSchemas.fieldNames)) {
-    if (settings.handler === "ApiGateway") {
-      if (fieldNameSetting.userCanUpdate === true) {
-        canUpdateFieldNames.push(fieldName);
-        canUpdateProperties[fieldName] = {
-          type: fieldNameSetting.type
-        }
-        if (fieldNameSetting.hasOwnProperty("versionedDataLabel")) {
-          versionedDataFieldNames.push(fieldName)
-        }
-      }
-    } else {
-      if (fieldNameSetting.canUpdate === true || fieldNameSetting.canUpdate === undefined) {
-        canUpdateFieldNames.push(fieldName);
-        canUpdateProperties[fieldName] = {
-          type: fieldNameSetting.type,
-        }
-        if (fieldNameSetting.hasOwnProperty("versionedDataLabel")) {
-          versionedDataFieldNames.push(fieldName)
-        }
-      }
-    }
-  }
-
-  // _izContext.logger.debug("canUpdate::::", { canUpdateFieldNames, canUpdateProperties });
+  // let versionedDataFieldNames = [];
+  // collect fieldNames that canUpdate
 
-  // collect usedFieldNames
   if (settings?.specificFieldNames) {
     if (settings.specificFieldNames.length) {
       for (let specificFieldName of settings.specificFieldNames) {
@@ -586,17 +570,56 @@ async function generateValidatorSchemaForUpdate(_izContext, objType, settings =
         }
       }
     } else {
-      usedFieldNames = usedFieldNames.concat(canUpdateFieldNames);
+      usedFieldNames = usedFieldNames.concat(fieldNameCanUpdates);
+    }
+  }
+  let versionedDataLabels = [];
+  for (const [fieldName, fieldSetting] of Object.entries(objectSchemas.fieldNames)) {
+    if (fieldSetting.canUpdate === true) {
+      fieldNameCanUpdates.push(fieldName)
+      if (fieldSetting.hasOwnProperty("versionedDataLabel")) {
+        versionedDataFieldNameCanUpdates.push(fieldName)
+        versionedDataLabels.push(fieldSetting.versionedDataLabel)
+      }
     }
   }
 
+  versionedDataLabels = [...new Set(versionedDataLabels)]
+  // console.log("versionedDataLabelValidatorSchema", versionedDataLabel)
+  // // collect canUpdate fieldName (all fieldName have CanUpdate setting = true)
+  // for (let [fieldName, fieldNameSetting] of Object.entries(objectSchemas.fieldNames)) {
+  //   if (settings.handler === "ApiGateway") {
+  //     if (fieldNameSetting.userCanUpdate === true) {
+  //       canUpdateFieldNames.push(fieldName);
+  //       canUpdateProperties[fieldName] = {
+  //         type: fieldNameSetting.type
+  //       }
+  //       if (fieldNameSetting.hasOwnProperty("versionedDataLabel")) {
+  //         versionedDataFieldNames.push(fieldName)
+  //       }
+  //     }
+  //   } else {
+  //     if (fieldNameSetting.canUpdate === true || fieldNameSetting.canUpdate === undefined) {
+  //       canUpdateFieldNames.push(fieldName);
+  //       canUpdateProperties[fieldName] = {
+  //         type: fieldNameSetting.type,
+  //       }
+  //       if (fieldNameSetting.hasOwnProperty("versionedDataLabel")) {
+  //         versionedDataFieldNames.push(fieldName)
+  //       }
+  //     }
+  //   }
+  // }
+
+  // _izContext.logger.debug("canUpdate::::", { fieldNameCanUpdates, versionedDataFieldNameCanUpdates });
+
   usedFieldNames = [...new Set(usedFieldNames)];
 
-  let defaultFieldNames = usedFieldNames.filter(fieldName => !identifiersFieldNames.includes(fieldName));
+  // let defaultFieldNames = usedFieldNames.filter(fieldName => !identifiersFieldNames.includes(fieldName));
 
-  // _izContext.logger.debug('identifiersFieldNames : ', identifiersFieldNames);
-  // _izContext.logger.debug('usedFieldNames : ', usedFieldNames); // all fieldName
-  // _izContext.logger.debug("defaultFieldNames :", defaultFieldNames);
+  // // _izContext.logger.debug('identifiersFieldNames : ', identifiersFieldNames);
+  // // _izContext.logger.debug('usedFieldNames : ', usedFieldNames); // all fieldName
+  // // _izContext.logger.debug("defaultFieldNames :", defaultFieldNames);
   // _izContext.logger.debug("versionedDataFieldNames :", versionedDataFieldNames);
 
   let initialValidatorSchemaForUpdate = {
@@ -620,7 +643,7 @@ async function generateValidatorSchemaForUpdate(_izContext, objType, settings =
             additionalProperties: false,
             // required: [],
             // properties: {},
-            ...await filteredFieldNamesOfValidatorSchema(_izContext, objType, [], defaultFieldNames)
+            ...await filteredFieldNamesOfValidatorSchema(_izContext, objType, [], fieldNameCanUpdates),
 
           },
         }
@@ -628,47 +651,55 @@ async function generateValidatorSchemaForUpdate(_izContext, objType, settings =
       versionedDataIds: {
         type: "object",
         additionalProperties: false,
-        // required: [], // no need to required versionedDataLabel
-        // properties: {},
-        ...await filteredFieldNamesOfValidatorSchema(_izContext, objType, [], versionedDataFieldNames)
-
+        required: [], // no need to required versionedDataLabel
+        properties: {},
       },
       additionalParams: {
         type: "object"
       }
     }
   }
-  const versionedDataReturnInFieldsObjInstanceFull = {}
-  for (const [versionedDataFieldName, versionedDataFieldNameSetting] of Object.entries(objectSchemas.fieldNames)) {
-    let versionedDataLabel = versionedDataFieldNameSetting.versionedDataLabel
-    if (versionedDataFieldNameSetting.hasOwnProperty("versionedDataLabel") && defaultFieldNames.includes(versionedDataFieldName)) {
-      Object.assign(versionedDataReturnInFieldsObjInstanceFull, {
-        [versionedDataFieldName]: createValidationFieldNameForEachType(
-          versionedDataFieldNameSetting.type,
-          versionedDataFieldNameSetting.validation
-        )
-      })
 
-      Object.assign(initialValidatorSchemaForUpdate.properties.versionedDataIds.properties, {
-        [versionedDataLabel]: {
-          type: "string",
-          pattern: "^[a-zA-Z0-9_-]+$"
-        }
-      })
-    }
+  for (const versionedDataLabel of versionedDataLabels) {
+    Object.assign(initialValidatorSchemaForUpdate.properties.versionedDataIds.properties, {
+      [versionedDataLabel]: {
+        type: "string",
+        pattern: "^[a-zA-Z0-9_-]+$"
+      }
+    })
   }
-
-  // console.debug("versionedDataReturnInFieldsObjInstanceFull::::", versionedDataReturnInFieldsObjInstanceFull);
-  // console.debug("initialValidatorSchemaForUpdate:::::", initialValidatorSchemaForUpdate);
-  // Object.assign(
-  //   initialValidatorSchemaForUpdate.properties.objInstanceFull.properties.fields.properties,
-  //   {
-  //     ...versionedDataReturnInFieldsObjInstanceFull,
-  //     ...canUpdateProperties
+  // _izContext.logger.debug("initialValidatorSchemaForUpdate", initialValidatorSchemaForUpdate)
+  // const versionedDataReturnInFieldsObjInstanceFull = {}
+  // for (const [versionedDataFieldName, versionedDataFieldNameSetting] of Object.entries(objectSchemas.fieldNames)) {
+  //   let versionedDataLabel = versionedDataFieldNameSetting.versionedDataLabel
+  //   if (versionedDataFieldNameSetting.hasOwnProperty("versionedDataLabel") && defaultFieldNames.includes(versionedDataFieldName)) {
+  //     Object.assign(versionedDataReturnInFieldsObjInstanceFull, {
+  //       [versionedDataFieldName]: createValidationFieldNameForEachType(
+  //         versionedDataFieldNameSetting.type,
+  //         versionedDataFieldNameSetting.validation
+  //       )
+  //     })
+
+  //     Object.assign(initialValidatorSchemaForUpdate.properties.versionedDataIds.properties, {
+  //       [versionedDataLabel]: {
+  //         type: "string",
+  //         pattern: "^[a-zA-Z0-9_-]+$"
+  //       }
+  //     })
   //   }
-  // );
+  // }
 
-  // _izContext.logger.debug("validatorSchema-update::", initialValidatorSchemaForUpdate);
+  // // console.debug("versionedDataReturnInFieldsObjInstanceFull::::", versionedDataReturnInFieldsObjInstanceFull);
+  // // console.debug("initialValidatorSchemaForUpdate:::::", initialValidatorSchemaForUpdate);
+  // // Object.assign(
+  // //   initialValidatorSchemaForUpdate.properties.objInstanceFull.properties.fields.properties,
+  // //   {
+  // //     ...versionedDataReturnInFieldsObjInstanceFull,
+  // //     ...canUpdateProperties
+  // //   }
+  // // );
+
+  // // _izContext.logger.debug("validatorSchema-update::", initialValidatorSchemaForUpdate);
   return initialValidatorSchemaForUpdate;
 }
 
@@ -760,7 +791,7 @@ async function filteredFieldNamesOfValidatorSchema(_izContext, objType, required
 
     }
   }
-
+  console.log("returnValidatorSchema", returnValidatorSchema)
 
   return returnValidatorSchema;
 }
@@ -787,15 +818,16 @@ async function generateValidatorSchemaForExplodedData(_izContext, objType) {
     properties: {}
   };
 
-  let objectSchema = await getObjSchemaS3WithHierarchy(_izContext, objType);
+  let objectSchema = await getObjectSchemaCombineFieldNamesWithCache(_izContext, objType);
   // generate validatorSchema for each fieldName
   for (let [fieldName, fieldData] of Object.entries(objectSchema.fieldNames)) {
     let fieldNameValidator = await generateValidatorFieldNameWithCache(_izContext, fieldName, fieldData);
     Object.assign(validatorSchema.properties, fieldNameValidator);
   }
+  // console.log("validatorSchema.properties", validatorSchema.properties)
 
   _izContext.logger.debug('--------------------------------------------');
-  _izContext.logger.debug('validatorSchema fieldName :: ', JSON.stringify(validatorSchema.properties));
+  _izContext.logger.debug('validatorSchema fieldName :: ', JSON.stringify(validatorSchema.properties, null, 2));
   _izContext.logger.debug('--------------------------------------------');
 
   // generate validatorSchema for each identifier
@@ -1260,27 +1292,33 @@ async function validateLocalSchema(_izContext, schemasPath, serviceConfigPath) {
       for (const flowSchema of allFlowSchemas) {
         const [status, errors] = validateBasicFlowSchema(_izContext, flowSchema)
 
-        if (flowSchema.statusType === "storedCache" || flowSchema.statusType === "triggerCache") { // validate triggerCache
-          if (!flowSchema.hasOwnProperty("objType")) {
+        if (!flowSchema.hasOwnProperty("objType")) {
+          validateStatus.status = false;
+          validateStatus.validateErrors.push(`flowSchema ${flowSchema.flowTag} must have objType`)
+        } else {
+          let [objSchema] = await getLocalOrS3ObjectSchema(flowSchema.objType);
+
+          if (!objSchema) {
             validateStatus.status = false;
-            validateStatus.validateErrors.push(`flowSchema ${flowSchema.flowTag} must have objType`)
+            validateStatus.validateErrors.push(`${flowSchema.flowTag}.objType is invalid`)
           } else {
-
-            let [objSchema] = await getLocalOrS3ObjectSchema(flowSchema.objType);
-
-            console.log("objSchema: ", objSchema)
-
-            if (!objSchema) {
+            if (Object.keys(objSchema.storageResources).length > 1) { // check for objectSchema must have 1 storageResource
               validateStatus.status = false;
-              validateStatus.validateErrors.push(`${flowSchema.flowTag}.objType is invalid`)
-            } else {
-              if (Object.keys(objSchema.storageResources).length > 1) { // check for objectSchema must have 1 storageResource
-                validateStatus.status = false;
-                validateStatus.validateErrors.push(`storageResource of objectType:${objSchema.objectType} serviceTag:${flowSchema.objType.serviceTag} is not single storageResource`)
-              } else if (Object.keys(objSchema.storageResources).length = 1) {
-                for (const storageResource of Object.values(objSchema.storageResources)) {
-                  if (storageResource.storageType === STORAGE_TYPES.dynamoDB) { // check for dynamoDB storageResource
-                    let specificFieldNames = Object.values(createSpecificFieldNameForCacheTable(createFlowTypeConcat(_izContext, { flowTag: flowSchema.flowTag, serviceTag: iz_serviceTag })))
+              validateStatus.validateErrors.push(`storageResource of objectType:${objSchema.objectType} serviceTag:${flowSchema.objType.serviceTag} is not single storageResource`)
+            } else if (Object.keys(objSchema.storageResources).length = 1) {
+              for (const storageResource of Object.values(objSchema.storageResources)) {
+                if (storageResource.storageType === STORAGE_TYPES.dynamoDB) {
+                  if (flowSchema.statusType === "triggerCache" || flowSchema.statusType === "storedCache") {
+                    let specificFieldNames = Object.values(createSpecificFieldNameForCacheTable(createFlowTypeConcat(_izContext, { flowTag: flowSchema.flowTag, serviceTag: iz_serviceTag }), "cacheTable"))
+                    const fieldNames = Object.keys(objSchema.fieldNames)
+                    for (const specificFieldName of specificFieldNames) { // check for specific fieldName
+                      if (!fieldNames.includes(specificFieldName)) {
+                        validateStatus.status = false;
+                        validateStatus.validateErrors.push(`objectType: ${objSchema.objectType} not have fieldNames: ${specificFieldName} in objectSchema.fieldNames`)
+                      }
+                    }
+                  } else if (flowSchema.statusType === "statusField") {
+                    let specificFieldNames = Object.values(createSpecificFieldNameForCacheTable(createFlowTypeConcat(_izContext, { flowTag: flowSchema.flowTag, serviceTag: iz_serviceTag }), 'statusField'))
                     const fieldNames = Object.keys(objSchema.fieldNames)
                     for (const specificFieldName of specificFieldNames) { // check for specific fieldName
                       if (!fieldNames.includes(specificFieldName)) {
@@ -1288,39 +1326,27 @@ async function validateLocalSchema(_izContext, schemasPath, serviceConfigPath) {
                         validateStatus.validateErrors.push(`objectType: ${objSchema.objectType} not have fieldNames: ${specificFieldName} in objectSchema.fieldNames`)
                       }
                     }
-                  } else {
-                    validateStatus.status = false;
-                    validateStatus.validateErrors.push(`storageResource of objectType:${objSchema.objectType} serviceTag:${flowSchema.objType.serviceTag} must be dynamoDb`)
                   }
+                } else {
+                  validateStatus.status = false;
+                  validateStatus.validateErrors.push(`storageResource of ObjectType: $${flowSchema.objType.flowTag} from flowTag: ${flowSchema.flowTag} must be dynamoDB`);
                 }
               }
             }
-
-
-
-            if (!status) {
-              validateStatus.status = false;
-              validateStatus.validateErrors.push(errors);
-            }
           }
         }
 
-        if (flowSchema.statusType === "statusField") {
-          if (!flowSchema.hasOwnProperty("objType")) {
-            validateStatus.status = false;
-            validateStatus.validateErrors.push(`flowSchema ${flowSchema.flowTag} must have objType`)
-          } else {
-            let [objSchema] = await getLocalOrS3ObjectSchema(flowSchema.objType);
-
-            if (!objSchema) {
-              validateStatus.status = false;
-              validateStatus.validateErrors.push(`${flowSchema.flowTag}.objType is invalid`)
-            }
-          }
+        if (!status) {
+          validateStatus.status = false;
+          validateStatus.validateErrors.push(errors);
         }
       }
+
     }
 
+
+
+
     if (validateStatus.validateErrors.length) {
       validateStatus.status = false;
     } else {