@izara_project/izara-core-library-service-schemas 1.0.97 → 1.0.99

package/package.json

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

package/src/ValidatorSchema.js

@@ -88,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]
 }
 
 /**
@@ -1285,67 +1292,76 @@ 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);
+            let dynamoDBStorageTags = [];
 
-            console.log("objSchema: ", objSchema)
+            for (const [storageTag, storageResource] of Object.entries(objSchema.storageResources)) {
+              if (storageResource.storageType === STORAGE_TYPES.dynamoDB) {
+                dynamoDBStorageTags.push(storageTag)
+              }
+            }
 
-            if (!objSchema) {
+            if (dynamoDBStorageTags.length > 1) {
               validateStatus.status = false;
-              validateStatus.validateErrors.push(`${flowSchema.flowTag}.objType is invalid`)
+              validateStatus.validateErrors.push(`objectType:${objSchema.objectType} should not shave more than 1 dynamoDB storageResource`)
             } 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 })))
-                    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`)
-                      }
+
+              if (flowSchema.statusType === "statusField") {
+                let specificFieldNames = Object.values(createSpecificFieldNameForCacheTable(createFlowTypeConcat(_izContext, { flowTag: flowSchema.flowTag, serviceTag: iz_serviceTag }), 'statusField'))
+
+                for (const specificFieldName of specificFieldNames) { // check for specific fieldName
+                  if (objSchema.fieldNames.hasOwnProperty(specificFieldName)) {
+                    if (!objSchema.fieldNames[specificFieldName].storageResourceTags.includes(dynamoDBStorageTags[0])) {
+                      validateStatus.status = false;
+                      validateStatus.validateErrors.push(`objectType: ${objSchema.objectType} fieldNames: ${specificFieldName} not have storageResourceTag: ${dynamoDBStorageTags[0]}`);
                     }
                   } else {
                     validateStatus.status = false;
-                    validateStatus.validateErrors.push(`storageResource of objectType:${objSchema.objectType} serviceTag:${flowSchema.objType.serviceTag} must be dynamoDb`)
+                    validateStatus.validateErrors.push(`objectType: ${objSchema.objectType} not have fieldNames: ${specificFieldName} in objectSchema.fieldNames`)
                   }
                 }
-              }
-            }
 
 
+              } else if (flowSchema.statusType === "storedCache" || flowSchema.statusType === "triggerCache") {
+                let specificFieldNames = Object.values(createSpecificFieldNameForCacheTable(createFlowTypeConcat(_izContext, { flowTag: flowSchema.flowTag, serviceTag: iz_serviceTag }), "cacheTable"))
 
-            if (!status) {
-              validateStatus.status = false;
-              validateStatus.validateErrors.push(errors);
+                for (const specificFieldName of specificFieldNames) { // check for specific fieldName
+                  if (objSchema.fieldNames.hasOwnProperty(specificFieldName)) {
+                    if (!objSchema.fieldNames[specificFieldName].storageResourceTags.includes(dynamoDBStorageTags[0])) {
+                      validateStatus.status = false;
+                      validateStatus.validateErrors.push(`objectType: ${objSchema.objectType} fieldNames: ${specificFieldName} not have storageResourceTag: ${dynamoDBStorageTags[0]}`);
+                    }
+                  } else {
+                    validateStatus.status = false;
+                    validateStatus.validateErrors.push(`objectType: ${objSchema.objectType} not have fieldNames: ${specificFieldName} in objectSchema.fieldNames`)
+                  }
+                }
+              }
             }
           }
         }
 
-        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 {