@xuda.io/runtime-bundle 1.0.1183 → 1.0.1185

package/js/modules/xuda-studio-checker.mjs

@@ -28,872 +28,563 @@ export const init = function (app_obj_in, progs_obj_in = {}, _in, _hide_not_in_u
 
 export const check = function (doc) {
   var ret = [];
+  var dependency_progs = [];
 
-  // try {
+  // Helper function to add validation errors and continue
+  const addValidationError = (code, data, type = 'E', category = 'document', ref = null, id = null, not_in_use = false) => {
+    const error = {
+      code,
+      data,
+      type,
+      category,
+    };
 
-  // } catch (error) {
-  //   debugger;
-  // }
+    if (ref) error.ref = ref;
+    if (id) error.id = id;
+    if (not_in_use) error.not_in_use = not_in_use;
 
-  var dependency_progs = [];
-  try {
-    if (_.isEmpty(doc)) {
-      throw new Error('', {
-        cause: {
-          code: 'CHK_MSG_OBJ_GEN_110',
-          data: `doc in empty`,
-        },
-      });
-    }
+    ret.push(error);
+  };
 
-    // if (!doc.studio_meta || !_.isObject(doc.studio_meta)) {
-    //   throw new Error('', {
-    //     cause: {
-    //       code: 'CHK_MSG_OBJ_GEN_112',
-    //       data: `doc in empty`,
-    //     },
-    //   });
-    // }
+  // Early validation checks
+  if (_.isEmpty(doc)) {
+    addValidationError('CHK_MSG_OBJ_GEN_110', 'doc in empty');
+    return {
+      check_errors: ret,
+      check_warnings: [],
+      doc,
+      dependency_progs: [],
+    };
+  }
 
-    ret = check_structure(doc);
-    if (!ret?.length) {
-      doc.studio_meta.not_in_use = false;
-      // if (!doc.properties.menuType) {
-      //   throw new Error("", {
-      //     cause: {
-      //       code: "CHK_MSG_OBJ_GEN_010",
-      //       data: `invalid properties.menuType`,
-      //     },
-      //   });
-      // } else {
-      if (doc.properties.menuType !== 'folder') {
-        if (doc.properties.menuType !== 'table') {
-          // if (doc._id === "1630415111085_1630391769418") debugger;
-
-          if (is_server) {
-            for (let val of deployments) {
-              if (val.deploy_data?.prog_id === doc._id) {
-                if (!doc.studio_meta.used_by_deployment_ids) {
-                  doc.studio_meta.used_by_deployment_ids = [];
-                }
-                doc.studio_meta.used_by_deployment_ids.push(val._id);
+  // Run structure validation first
+  ret = check_structure(doc);
+
+  // Only continue if structure validation passed
+  if (!ret?.length) {
+    doc.studio_meta.not_in_use = false;
+
+    // Process non-folder items
+    if (doc.properties.menuType !== 'folder') {
+      if (doc.properties.menuType !== 'table') {
+        // Handle deployment dependencies for server environment
+        if (is_server) {
+          for (let val of deployments) {
+            if (val.deploy_data?.prog_id === doc._id) {
+              if (!doc.studio_meta.used_by_deployment_ids) {
+                doc.studio_meta.used_by_deployment_ids = [];
               }
+              doc.studio_meta.used_by_deployment_ids.push(val._id);
             }
           }
-          if (!doc.studio_meta.used_by_deployment_id) {
-            const check_programs_are_active = function (arr) {
-              if (!arr.length) return false;
-              var count = 0;
-              for (let val of arr) {
-                if (progs_obj?.[val.prog_id]?.studio_meta?.not_in_use) {
-                  count++;
-                  break;
-                }
-              }
-              return count !== arr.length;
-            };
-            if (!hide_not_in_use_check) {
-              const ret_prog_in_use = find_trigger_property_value_in_progs(doc, program_ref_triggers_arr, 'prog', doc._id);
-
-              if (!ret_prog_in_use || !check_programs_are_active(ret_prog_in_use)) {
-                const ret_panel_prog_in_use = find_panel_prog_in_progs(doc, doc._id);
-
-                if (!ret_panel_prog_in_use || !check_programs_are_active(ret_panel_prog_in_use)) {
-                  const ret_fieldValue_in_use = find_prog_in_fieldset_fieldValue_progs(doc, doc._id);
-
-                  if (!ret_fieldValue_in_use || !check_programs_are_active(ret_fieldValue_in_use)) {
-                    doc.studio_meta.not_in_use = true;
-
-                    // search in implementations
-                    // if (is_server) {
-                    //   for (let val of deployments) {
-                    //     if (val.deploy_data?.prog_id === doc._id) {
-                    //       debugger;
-                    //       doc.studio_meta.used_by_deployment_id = val._id;
-                    //       break;
-                    //     }
-                    //   }
-                    // }
-                    // if (!doc.studio_meta.used_by_deployment_id) {
-                    //   // ret.push({
-                    //   //   code: "CHK_MSG_GEN_022",
-                    //   //   data: `program not in use`,
-                    //   //   type: "W",
-                    //   //   category: `prog`,
-                    //   //   ref: doc._id,
-                    //   //   not_in_use: true,
-                    //   // });
-
-                    //   doc.studio_meta.not_in_use = true;
-                    // }
-                  }
-                }
+        }
+
+        // Check if program is in use
+        if (!doc.studio_meta.used_by_deployment_id) {
+          const check_programs_are_active = function (arr) {
+            if (!arr.length) return false;
+            var count = 0;
+            for (let val of arr) {
+              if (progs_obj?.[val.prog_id]?.studio_meta?.not_in_use) {
+                count++;
+                break;
               }
             }
-          }
+            return count !== arr.length;
+          };
 
-          // if (doc.studio_meta.not_in_use)
-          //   return { errors: ret, warnings: [], doc, dependency_progs };
+          if (!hide_not_in_use_check) {
+            const ret_prog_in_use = find_trigger_property_value_in_progs(doc, program_ref_triggers_arr, 'prog', doc._id);
 
-          ret = [...ret, ...check_prog_events(doc)];
-          // find program dependencies
+            if (!ret_prog_in_use || !check_programs_are_active(ret_prog_in_use)) {
+              const ret_panel_prog_in_use = find_panel_prog_in_progs(doc, doc._id);
 
-          dependency_progs = find_trigger_property_value_in_progs(doc, program_ref_triggers_arr, 'prog', null, true) || [];
+              if (!ret_panel_prog_in_use || !check_programs_are_active(ret_panel_prog_in_use)) {
+                const ret_fieldValue_in_use = find_prog_in_fieldset_fieldValue_progs(doc, doc._id);
 
-          dependency_progs = [...dependency_progs, ...(find_panel_prog_in_progs(doc, null, true) || [])];
-        } else {
-          if (!hide_not_in_use_check) {
-            // check use for table
-            if (!find_table_in_progs(doc, doc._id)) {
-              doc.studio_meta.not_in_use = true;
-              // ret.push({
-              //   code: "CHK_MSG_GEN_024",
-              //   data: `table not in use`,
-              //   type: "W",
-              //   category: `table`,
-              //   ref: doc._id,
-              //   not_in_use: true,
-              // });
+                if (!ret_fieldValue_in_use || !check_programs_are_active(ret_fieldValue_in_use)) {
+                  doc.studio_meta.not_in_use = true;
+                }
+              }
             }
           }
         }
-      }
-      // }
 
-      // if (!doc.properties.menuName) {
-      //   throw new Error("", {
-      //     cause: {
-      //       code: "CHK_MSG_OBJ_GEN_040",
-      //       data: `properties.menuName is empty`,
-      //     },
-      //   });
-      // }
+        // Add program event validation results
+        ret = [...ret, ...check_prog_events(doc)];
 
-      switch (doc.properties.menuType) {
-        case 'globals':
-          ret = [...ret, ...check_globals(doc)];
-          break;
+        // Find program dependencies
+        dependency_progs = find_trigger_property_value_in_progs(doc, program_ref_triggers_arr, 'prog', null, true) || [];
+        dependency_progs = [...dependency_progs, ...(find_panel_prog_in_progs(doc, null, true) || [])];
+      } else {
+        // Handle table usage checking
+        if (!hide_not_in_use_check) {
+          if (!find_table_in_progs(doc, doc._id)) {
+            doc.studio_meta.not_in_use = true;
+          }
+        }
+      }
+    }
 
-        case 'table':
-          ret = [...ret, ...check_table(doc)];
-          break;
+    // Run menu type specific validation
+    switch (doc.properties.menuType) {
+      case 'globals':
+        ret = [...ret, ...check_globals(doc)];
+        break;
 
-        case 'component':
-          ret = [...ret, ...check_component(doc)];
-          break;
+      case 'table':
+        ret = [...ret, ...check_table(doc)];
+        break;
 
-        case 'javascript':
-          ret = [...ret, ...check_javascript(doc)];
-          break;
+      case 'component':
+        ret = [...ret, ...check_component(doc)];
+        break;
 
-        case 'get_data':
-          ret = [...ret, ...check_get_data(doc)];
-          break;
+      case 'javascript':
+        ret = [...ret, ...check_javascript(doc)];
+        break;
 
-        case 'set_data':
-          ret = [...ret, ...check_set_data(doc)];
-          break;
+      case 'get_data':
+        ret = [...ret, ...check_get_data(doc)];
+        break;
 
-        case 'batch':
-          ret = [...ret, ...check_batch(doc)];
-          break;
+      case 'set_data':
+        ret = [...ret, ...check_set_data(doc)];
+        break;
 
-        case 'api':
-          ret = [...ret, ...check_api(doc)];
-          break;
+      case 'batch':
+        ret = [...ret, ...check_batch(doc)];
+        break;
 
-        case 'alert':
-          ret = [...ret, ...check_alert(doc)];
-          break;
+      case 'api':
+        ret = [...ret, ...check_api(doc)];
+        break;
 
-        case 'route':
-          ret = [...ret, ...check_route(doc)];
-          break;
+      case 'alert':
+        ret = [...ret, ...check_alert(doc)];
+        break;
 
-        // case "call_project_api":
-        //   ret = [...ret, ...call_project_api(doc)];
-        //   break;
+      case 'route':
+        ret = [...ret, ...check_route(doc)];
+        break;
 
-        case 'folder':
-          break;
+      case 'folder':
+        // No additional validation for folders
+        break;
 
-        default:
-          ret.push({
-            code: 'CHK_MSG_GEN_050',
-            data: `invalid ${doc.properties.menuType} properties.menuType`,
-            type: 'E',
-            category: `prog`,
-            ref: doc._id,
-            id: `${doc._id}`,
-          });
-          break;
-      }
-    }
-    var final_ret = {
-      check_errors: [],
-      check_warnings: [],
-      doc,
-      dependency_progs,
-    };
-    for (let [key, val] of Object.entries(ret)) {
-      if (val.type === 'E') {
-        final_ret.check_errors.push(val);
-      }
-      if (val.type === 'W') {
-        final_ret.check_warnings.push(val);
-      }
+      default:
+        addValidationError('CHK_MSG_GEN_050', `invalid ${doc.properties.menuType} properties.menuType`, 'E', 'prog', doc._id, doc._id);
+        break;
     }
+  }
 
-    return final_ret;
-  } catch (err) {
-    if (err.cause) {
-      const { code, data } = err.cause;
-      ret.push({
-        code,
-        data,
-        type: 'E',
-      });
-    } else {
-      console.error(err);
-      debugger;
-    }
+  // Separate errors and warnings
+  var final_ret = {
+    check_errors: [],
+    check_warnings: [],
+    doc,
+    dependency_progs,
+  };
 
-    return { check_errors: ret, check_warnings: [], doc, dependency_progs };
+  for (let [key, val] of Object.entries(ret)) {
+    if (val.type === 'E') {
+      final_ret.check_errors.push(val);
+    }
+    if (val.type === 'W') {
+      final_ret.check_warnings.push(val);
+    }
   }
+
+  return final_ret;
 };
 
 export const check_structure = function (doc) {
   var ret = [];
 
-  try {
-    if (!app_obj || !_.isObject(app_obj) || _.isEmpty(app_obj)) {
-      throw new Error('', {
-        cause: {
-          code: 'CHK_MSG_OBJ_GEN_002',
-          data: `invalid app_obj`,
-        },
-      });
-    }
+  // Helper function to add validation errors and continue
+  const addValidationError = (code, data) => {
+    ret.push({
+      code,
+      data,
+      type: 'E',
+      category: 'document',
+      structure_error: true,
+    });
+  };
 
-    if (!doc || !_.isObject(doc) || _.isEmpty(doc)) {
-      throw new Error('', {
-        cause: {
-          code: 'CHK_MSG_OBJ_GEN_004',
-          data: `doc is not a object`,
-        },
-      });
-    }
+  // Early exit conditions that prevent further validation
+  if (!app_obj || !_.isObject(app_obj) || _.isEmpty(app_obj)) {
+    addValidationError('CHK_MSG_OBJ_GEN_002', 'invalid app_obj');
+    return ret;
+  }
 
-    try {
-      JSON5.parse(JSON.stringify(doc));
-    } catch (err) {
-      throw new Error('', {
-        cause: {
-          code: 'CHK_MSG_OBJ_GEN_005',
-          data: `error parsing JSON doc`,
-        },
-      });
-    }
+  if (!doc || !_.isObject(doc) || _.isEmpty(doc)) {
+    addValidationError('CHK_MSG_OBJ_GEN_004', 'doc is not a object');
+    return ret;
+  }
 
-    if (!doc._id) {
-      throw new Error('', {
-        cause: {
-          code: 'CHK_MSG_OBJ_GEN_050',
-          data: `missing _id value`,
-        },
-      });
-    }
+  try {
+    JSON5.parse(JSON.stringify(doc));
+  } catch (err) {
+    addValidationError('CHK_MSG_OBJ_GEN_005', 'error parsing JSON doc');
+    return ret;
+  }
 
-    if (doc?.studio_meta?.source === 'studio ai' && doc?.properties?.menuType && doc._id.substr(0, 7) !== new_node_id(doc.properties.menuType, doc.app_id).substr(0, 7)) {
-      throw new Error('', {
-        cause: {
-          code: 'CHK_MSG_OBJ_GEN_051',
-          data: `invalid _id value (e.g: 5b1_tbl_a953848a71c5)`,
-        },
-      });
-    }
+  // Continue validation even with errors
+  if (!doc._id) {
+    addValidationError('CHK_MSG_OBJ_GEN_050', 'missing _id value');
+  }
 
-    if (!doc._rev) {
-      if (progs_obj?.[doc._id]) {
-        throw new Error('', {
-          cause: {
-            code: 'CHK_MSG_OBJ_GEN_052',
-            data: `duplicate doc _id`,
-          },
-        });
-      }
-    }
-    ////////// properties ////////////////
+  if (doc?.studio_meta?.source === 'studio ai' && doc?.properties?.menuType && doc._id && doc._id.substr(0, 7) !== new_node_id(doc.properties.menuType, doc.app_id).substr(0, 7)) {
+    addValidationError('CHK_MSG_OBJ_GEN_051', 'invalid _id value (e.g: 5b1_tbl_a953848a71c5)');
+  }
 
-    if (!doc.properties) {
-      throw new Error('', {
-        cause: {
-          code: 'CHK_MSG_OBJ_GEN_100',
-          data: `missing properties object`,
-        },
-      });
+  if (!doc._rev) {
+    if (progs_obj?.[doc._id]) {
+      addValidationError('CHK_MSG_OBJ_GEN_052', 'duplicate doc _id');
     }
+  }
+
+  ////////// properties ////////////////
+
+  if (!doc.properties) {
+    addValidationError('CHK_MSG_OBJ_GEN_100', 'missing properties object');
+  } else {
     if (!_.isObject(doc.properties)) {
-      throw new Error('', {
-        cause: {
-          code: 'CHK_MSG_OBJ_GEN_102',
-          data: `invalid properties object`,
-        },
-      });
-    }
+      addValidationError('CHK_MSG_OBJ_GEN_102', 'invalid properties object');
+    } else {
+      if (!doc.properties.menuType) {
+        addValidationError('CHK_MSG_OBJ_GEN_104', 'missing properties.menuType');
+      } else if (!ALL_MENU_TYPE.includes(doc.properties.menuType)) {
+        addValidationError('CHK_MSG_OBJ_GEN_105', `invalid properties.menuType (valid values: ${ALL_MENU_TYPE.join(',')})`);
+      }
 
-    if (!doc.properties.menuType) {
-      throw new Error('', {
-        cause: {
-          code: 'CHK_MSG_OBJ_GEN_104',
-          data: `missing properties.menuType`,
-        },
-      });
+      if (!doc.properties.menuName) {
+        addValidationError('CHK_MSG_OBJ_GEN_106', 'missing properties.menuName');
+      }
     }
+  }
 
-    if (!ALL_MENU_TYPE.includes(doc.properties.menuType)) {
-      throw new Error('', {
-        cause: {
-          code: 'CHK_MSG_OBJ_GEN_105',
-          data: `invalid properties.menuType (valid values: ${ALL_MENU_TYPE.join(',')})`,
-        },
-      });
-    }
+  ////////// studio_meta ////////////////
 
-    if (!doc.properties.menuName) {
-      throw new Error('', {
-        cause: {
-          code: 'CHK_MSG_OBJ_GEN_106',
-          data: `missing properties.menuName`,
-        },
-      });
-    }
-    ////////// studio_meta ////////////////
-    if (!doc.studio_meta) {
-      throw new Error('', {
-        cause: {
-          code: 'CHK_MSG_OBJ_GEN_112',
-          data: `missing studio_meta property`,
-        },
-      });
-    }
+  if (!doc.studio_meta) {
+    addValidationError('CHK_MSG_OBJ_GEN_112', 'missing studio_meta property');
+  } else {
     if (!_.isObject(doc.studio_meta)) {
-      throw new Error('', {
-        cause: {
-          code: 'CHK_MSG_OBJ_GEN_112',
-          data: `invalid studio_meta object`,
-        },
-      });
-    }
-    if (!doc.studio_meta.parentId) {
-      throw new Error('', {
-        cause: {
-          code: 'CHK_MSG_OBJ_GEN_114',
-          data: `missing studio_meta.parentId value`,
-        },
-      });
+      addValidationError('CHK_MSG_OBJ_GEN_112', 'invalid studio_meta object');
     } else {
-      let menuType = doc?.properties?.menuType === 'globals' ? 'globals' : doc?.properties?.menuType === 'table' ? 'database' : doc?.properties?.menuType === 'route' ? 'routes' : 'programs';
-      if (doc.studio_meta.parentId !== menuType && !progs_obj[doc.studio_meta.parentId]) {
-        throw new Error('', {
-          cause: {
-            code: 'CHK_MSG_OBJ_GEN_116',
-            data: `invalid studio_meta.parentId value`,
-          },
-        });
+      if (!doc.studio_meta.parentId) {
+        addValidationError('CHK_MSG_OBJ_GEN_114', 'missing studio_meta.parentId value');
+      } else {
+        let menuType = doc?.properties?.menuType === 'globals' ? 'globals' : doc?.properties?.menuType === 'table' ? 'database' : doc?.properties?.menuType === 'route' ? 'routes' : 'programs';
+        if (doc.studio_meta.parentId !== menuType && !progs_obj[doc.studio_meta.parentId]) {
+          addValidationError('CHK_MSG_OBJ_GEN_116', 'invalid studio_meta.parentId value');
+        }
       }
     }
+  }
 
-    const check_progFields = function () {
-      ///////////// progFields
-      var ids = [];
-      if (!_.isArray(doc.progFields)) {
-        throw new Error('', {
-          cause: {
-            code: 'CHK_MSG_OBJ_GEN_402',
-            data: `invalid progFields Array property`,
-          },
-        });
+  const check_progFields = function () {
+    if (!doc.progFields) return;
+
+    var ids = [];
+    if (!_.isArray(doc.progFields)) {
+      addValidationError('CHK_MSG_OBJ_GEN_402', 'invalid progFields Array property');
+      return;
+    }
+
+    for (let val of doc.progFields) {
+      if (!_.isObject(val)) {
+        addValidationError('CHK_MSG_OBJ_GEN_404', 'invalid progFields object property');
+        continue;
       }
 
-      for (let val of doc.progFields) {
-        if (!_.isObject(val)) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_404',
-              data: `invalid progFields object property`,
-            },
-          });
-        }
-        if (!val.id) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_406',
-              data: `missing progFields.id property`,
-            },
-          });
-        }
-        if (ids.includes(val.id)) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_408',
-              data: `${val.id} id must be unique in progFields property`,
-            },
-          });
-        }
-        ids.push(val.id);
-        if (!_.isObject(val.data)) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_410',
-              data: `invalid progFields.data object property`,
-            },
-          });
-        }
+      if (!val.id) {
+        addValidationError('CHK_MSG_OBJ_GEN_406', 'missing progFields.id property');
+        continue;
+      }
 
-        if (!val.data.field_id) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_412',
-              data: `invalid progFields.data.field_id property`,
-            },
-          });
-        }
-        if (!val.data.type) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_414',
-              data: `invalid progFields.data.type property`,
-            },
-          });
-        }
-        if (!_.isObject(val.props)) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_416',
-              data: `invalid progFields.props Object property`,
-            },
-          });
-        }
-        if (!val.props.fieldType) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_418',
-              data: `invalid progFields.props.fieldType property`,
-            },
-          });
-        }
-        if (!_.isObject(val.props.propExpressions)) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_4120',
-              data: `invalid val.props.propExpressions Object property`,
-            },
-          });
-        }
+      if (ids.includes(val.id)) {
+        addValidationError('CHK_MSG_OBJ_GEN_408', `${val.id} id must be unique in progFields property`);
+        continue;
+      }
+      ids.push(val.id);
 
-        check_triggers(val.workflow);
+      if (!_.isObject(val.data)) {
+        addValidationError('CHK_MSG_OBJ_GEN_410', 'invalid progFields.data object property');
+        continue;
       }
-    };
-    const check_progEvents = function () {
-      ///////////// progEvents
-      var ids = [];
-      if (!_.isArray(doc.progEvents)) {
-        throw new Error('', {
-          cause: {
-            code: 'CHK_MSG_OBJ_GEN_502',
-            data: `invalid progEvents Array property`,
-          },
-        });
+
+      if (!val.data.field_id) {
+        addValidationError('CHK_MSG_OBJ_GEN_412', 'invalid progFields.data.field_id property');
       }
 
-      for (let val of doc.progEvents) {
-        if (!_.isObject(val)) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_504',
-              data: `invalid progEvents object property`,
-            },
-          });
-        }
-        if (!val.id) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_506',
-              data: `missing progEvents.id property`,
-            },
-          });
-        }
-        if (ids.includes(val.id)) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_508',
-              data: `${val.id} id must be unique in progEvents property`,
-            },
-          });
-        }
-        ids.push(val.id);
-        if (!_.isObject(val.data)) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_510',
-              data: `invalid progEvents.data object property`,
-            },
-          });
-        }
+      if (!val.data.type) {
+        addValidationError('CHK_MSG_OBJ_GEN_414', 'invalid progFields.data.type property');
+      }
 
-        if (typeof val.data.condition === 'undefined') {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_512',
-              data: `undefined progEvents.data.condition string property`,
-            },
-          });
-        }
-        if (typeof val.data.event_name === 'undefined') {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_514',
-              data: `undefined progEvents.data.event_name string property`,
-            },
-          });
-        }
-        if (typeof val.data.properties === 'undefined') {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_516',
-              data: `undefined progEvents.data.properties string property`,
-            },
-          });
-        }
-        if (typeof val.data.type === 'undefined') {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_518',
-              data: `undefined progEvents.data.type string property`,
-            },
-          });
-        }
+      if (!_.isObject(val.props)) {
+        addValidationError('CHK_MSG_OBJ_GEN_416', 'invalid progFields.props Object property');
+        continue;
+      }
 
-        if (!_.isArray(val.data.parameters)) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_522',
-              data: `invalid progEvents.data.parameters Array property`,
-            },
-          });
-        }
+      if (!val.props.fieldType) {
+        addValidationError('CHK_MSG_OBJ_GEN_418', 'invalid progFields.props.fieldType property');
+      }
 
-        if (!_.isObject(val.props)) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_522',
-              data: `invalid progEvents.props Object property`,
-            },
-          });
-        }
+      if (!_.isObject(val.props.propExpressions)) {
+        addValidationError('CHK_MSG_OBJ_GEN_4120', 'invalid val.props.propExpressions Object property');
+      }
 
-        check_triggers(val.workflow);
+      check_triggers(val.workflow);
+    }
+  };
+
+  const check_progEvents = function () {
+    if (!doc.progEvents) return;
+
+    var ids = [];
+    if (!_.isArray(doc.progEvents)) {
+      addValidationError('CHK_MSG_OBJ_GEN_502', 'invalid progEvents Array property');
+      return;
+    }
+
+    for (let val of doc.progEvents) {
+      if (!_.isObject(val)) {
+        addValidationError('CHK_MSG_OBJ_GEN_504', 'invalid progEvents object property');
+        continue;
       }
-    };
-    const check_triggers = function (workflow) {
-      if (!workflow) return;
-      var ids = [];
-      if (!_.isArray(workflow)) {
-        throw new Error('', {
-          cause: {
-            code: 'CHK_MSG_OBJ_GEN_850',
-            data: `invalid workflow Array property`,
-          },
-        });
+
+      if (!val.id) {
+        addValidationError('CHK_MSG_OBJ_GEN_506', 'missing progEvents.id property');
+        continue;
       }
 
-      for (let val of workflow) {
-        if (!_.isObject(val)) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_852',
-              data: `invalid workflow item object property`,
-            },
-          });
-        }
+      if (ids.includes(val.id)) {
+        addValidationError('CHK_MSG_OBJ_GEN_508', `${val.id} id must be unique in progEvents property`);
+        continue;
+      }
+      ids.push(val.id);
 
-        if (!val.id) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_854',
-              data: `missing workflow.id property`,
-            },
-          });
-        }
-        if (ids.includes(val.id)) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_856',
-              data: `${val.id} id must be unique in workflow property`,
-            },
-          });
-        }
-        ids.push(val.id);
+      if (!_.isObject(val.data)) {
+        addValidationError('CHK_MSG_OBJ_GEN_510', 'invalid progEvents.data object property');
+        continue;
+      }
 
-        if (!_.isObject(val.data)) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_858',
-              data: `invalid workflow.data Object property`,
-            },
-          });
-        }
+      if (typeof val.data.condition === 'undefined') {
+        addValidationError('CHK_MSG_OBJ_GEN_512', 'undefined progEvents.data.condition string property');
+      }
 
-        if (!_.isObject(val.props)) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_860',
-              data: `invalid workflow.props item object property`,
-            },
-          });
-        }
+      if (typeof val.data.event_name === 'undefined') {
+        addValidationError('CHK_MSG_OBJ_GEN_514', 'undefined progEvents.data.event_name string property');
       }
-    };
-    const check_progDataSource = function () {
-      ///////////// progDataSource
-      if (!_.isObject(doc.progDataSource)) {
-        throw new Error('', {
-          cause: {
-            code: 'CHK_MSG_OBJ_GEN_602',
-            data: `invalid progDataSource Object property`,
-          },
-        });
+
+      if (typeof val.data.properties === 'undefined') {
+        addValidationError('CHK_MSG_OBJ_GEN_516', 'undefined progEvents.data.properties string property');
       }
 
-      if (typeof doc.progDataSource.dataSourceType === 'undefined') {
-        throw new Error('', {
-          cause: {
-            code: 'CHK_MSG_OBJ_GEN_604',
-            data: `undefined progDataSource.dataSourceType string property`,
-          },
-        });
+      if (typeof val.data.type === 'undefined') {
+        addValidationError('CHK_MSG_OBJ_GEN_518', 'undefined progEvents.data.type string property');
       }
-    };
-    const check_progUi = function () {
-      ///////////// progUi
-      if (!_.isArray(doc.progUi)) {
-        throw new Error('', {
-          cause: {
-            code: 'CHK_MSG_OBJ_GEN_702',
-            data: `invalid progUi Array property`,
-          },
-        });
+
+      if (!_.isArray(val.data.parameters)) {
+        addValidationError('CHK_MSG_OBJ_GEN_522', 'invalid progEvents.data.parameters Array property');
       }
 
-      var ids = [];
-      const run_tree = function (node) {
-        for (let item of node) {
-          if (!_.isObject(item)) {
-            throw new Error('', {
-              cause: {
-                code: 'CHK_MSG_OBJ_GEN_704',
-                data: `invalid progUi item Object property`,
-              },
-            });
-          }
+      if (!_.isObject(val.props)) {
+        addValidationError('CHK_MSG_OBJ_GEN_522', 'invalid progEvents.props Object property');
+      }
 
-          if (!_.isObject(item.attributes)) {
-            throw new Error('', {
-              cause: {
-                code: 'CHK_MSG_OBJ_GEN_706',
-                data: `invalid progUi attributes item Object property`,
-              },
-            });
-          }
+      check_triggers(val.workflow);
+    }
+  };
 
-          if (typeof item.type === 'undefined') {
-            throw new Error('', {
-              cause: {
-                code: 'CHK_MSG_OBJ_GEN_708',
-                data: `undefined progUi type item string property`,
-              },
-            });
-          }
-          if (typeof item.tagName === 'undefined') {
-            throw new Error('', {
-              cause: {
-                code: 'CHK_MSG_OBJ_GEN_710',
-                data: `undefined progUi tagName item string property`,
-              },
-            });
-          }
+  const check_triggers = function (workflow) {
+    if (!workflow) return;
 
-          if (!item.id) {
-            throw new Error('', {
-              cause: {
-                code: 'CHK_MSG_OBJ_GEN_712',
-                data: `missing progUi id item property`,
-              },
-            });
-          }
-          if (ids.includes(item.id)) {
-            throw new Error('', {
-              cause: {
-                code: 'CHK_MSG_OBJ_GEN_714',
-                data: `${item.id} id must be unique in progUi property`,
-              },
-            });
-          }
-          ids.push(item.id);
+    var ids = [];
+    if (!_.isArray(workflow)) {
+      addValidationError('CHK_MSG_OBJ_GEN_850', 'invalid workflow Array property');
+      return;
+    }
 
-          check_triggers(item.workflow);
+    for (let val of workflow) {
+      if (!_.isObject(val)) {
+        addValidationError('CHK_MSG_OBJ_GEN_852', 'invalid workflow item object property');
+        continue;
+      }
 
-          if (item.children) {
-            run_tree(item.children);
-          }
+      if (!val.id) {
+        addValidationError('CHK_MSG_OBJ_GEN_854', 'missing workflow.id property');
+        continue;
+      }
+
+      if (ids.includes(val.id)) {
+        addValidationError('CHK_MSG_OBJ_GEN_856', `${val.id} id must be unique in workflow property`);
+        continue;
+      }
+      ids.push(val.id);
+
+      if (!_.isObject(val.data)) {
+        addValidationError('CHK_MSG_OBJ_GEN_858', 'invalid workflow.data Object property');
+      }
+
+      if (!_.isObject(val.props)) {
+        addValidationError('CHK_MSG_OBJ_GEN_860', 'invalid workflow.props item object property');
+      }
+    }
+  };
+
+  const check_progDataSource = function () {
+    if (!doc.progDataSource) return;
+
+    if (!_.isObject(doc.progDataSource)) {
+      addValidationError('CHK_MSG_OBJ_GEN_602', 'invalid progDataSource Object property');
+      return;
+    }
+
+    if (typeof doc.progDataSource.dataSourceType === 'undefined') {
+      addValidationError('CHK_MSG_OBJ_GEN_604', 'undefined progDataSource.dataSourceType string property');
+    }
+  };
+
+  const check_progUi = function () {
+    if (!doc.progUi) return;
+
+    if (!_.isArray(doc.progUi)) {
+      addValidationError('CHK_MSG_OBJ_GEN_702', 'invalid progUi Array property');
+      return;
+    }
+
+    var ids = [];
+    const run_tree = function (node) {
+      for (let item of node) {
+        if (!_.isObject(item)) {
+          addValidationError('CHK_MSG_OBJ_GEN_704', 'invalid progUi item Object property');
+          continue;
         }
-      };
-      run_tree(doc.progUi);
+
+        if (!_.isObject(item.attributes)) {
+          addValidationError('CHK_MSG_OBJ_GEN_706', 'invalid progUi attributes item Object property');
+        }
+
+        if (typeof item.type === 'undefined') {
+          addValidationError('CHK_MSG_OBJ_GEN_708', 'undefined progUi type item string property');
+        }
+
+        if (typeof item.tagName === 'undefined') {
+          addValidationError('CHK_MSG_OBJ_GEN_710', 'undefined progUi tagName item string property');
+        }
+
+        if (!item.id) {
+          addValidationError('CHK_MSG_OBJ_GEN_712', 'missing progUi id item property');
+          continue;
+        }
+
+        if (ids.includes(item.id)) {
+          addValidationError('CHK_MSG_OBJ_GEN_714', `${item.id} id must be unique in progUi property`);
+          continue;
+        }
+        ids.push(item.id);
+
+        check_triggers(item.workflow);
+
+        if (item.children) {
+          run_tree(item.children);
+        }
+      }
     };
+    run_tree(doc.progUi);
+  };
 
+  // Only proceed with menu type validation if we have the required properties
+  if (doc.properties && doc.properties.menuType) {
     switch (doc.properties.menuType) {
       case 'table':
         if (!doc.tableFields) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_200',
-              data: `missing tableFields property`,
-            },
-          });
-        }
-        ///////////// tableFields
-        if (!_.isArray(doc.tableFields)) {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_202',
-              data: `invalid tableFields Array property`,
-            },
-          });
-        }
-        var ids = [];
+          addValidationError('CHK_MSG_OBJ_GEN_200', 'missing tableFields property');
+        } else {
+          if (!_.isArray(doc.tableFields)) {
+            addValidationError('CHK_MSG_OBJ_GEN_202', 'invalid tableFields Array property');
+          } else {
+            var ids = [];
 
-        for (let val of doc.tableFields) {
-          if (!_.isObject(val)) {
-            throw new Error('', {
-              cause: {
-                code: 'CHK_MSG_OBJ_GEN_204',
-                data: `invalid tableFields object property`,
-              },
-            });
-          }
-          if (!val.id) {
-            throw new Error('', {
-              cause: {
-                code: 'CHK_MSG_OBJ_GEN_206',
-                data: `missing tableFields.id property`,
-              },
-            });
-          }
-          if (ids.includes(val.id)) {
-            throw new Error('', {
-              cause: {
-                code: 'CHK_MSG_OBJ_GEN_208',
-                data: `${val.id} id must be unique in tableFields property`,
-              },
-            });
-          }
-          ids.push(val.id);
-          if (!_.isObject(val.data)) {
-            throw new Error('', {
-              cause: {
-                code: 'CHK_MSG_OBJ_GEN_210',
-                data: `invalid tableFields.data object property`,
-              },
-            });
-          }
-          if (!val.data.field_id) {
-            throw new Error('', {
-              cause: {
-                code: 'CHK_MSG_OBJ_GEN_212',
-                data: `invalid tableFields.data.field_id property`,
-              },
-            });
-          }
-          if (!_.isObject(val.props)) {
-            throw new Error('', {
-              cause: {
-                code: 'CHK_MSG_OBJ_GEN_214',
-                data: `invalid tableFields.props object property`,
-              },
-            });
-          }
-          if (!val.props.fieldType) {
-            throw new Error('', {
-              cause: {
-                code: 'CHK_MSG_OBJ_GEN_216',
-                data: `invalid tableFields.props.fieldType property`,
-              },
-            });
-          }
-          ///////////// tableIndexes
-          if (!_.isArray(doc.tableIndexes)) {
-            throw new Error('', {
-              cause: {
-                code: 'CHK_MSG_OBJ_GEN_302',
-                data: `invalid tableIndexes Array property`,
-              },
-            });
+            for (let val of doc.tableFields) {
+              if (!_.isObject(val)) {
+                addValidationError('CHK_MSG_OBJ_GEN_204', 'invalid tableFields object property');
+                continue;
+              }
+
+              if (!val.id) {
+                addValidationError('CHK_MSG_OBJ_GEN_206', 'missing tableFields.id property');
+                continue;
+              }
+
+              if (ids.includes(val.id)) {
+                addValidationError('CHK_MSG_OBJ_GEN_208', `${val.id} id must be unique in tableFields property`);
+                continue;
+              }
+              ids.push(val.id);
+
+              if (!_.isObject(val.data)) {
+                addValidationError('CHK_MSG_OBJ_GEN_210', 'invalid tableFields.data object property');
+                continue;
+              }
+
+              if (!val.data.field_id) {
+                addValidationError('CHK_MSG_OBJ_GEN_212', 'invalid tableFields.data.field_id property');
+              }
+
+              if (!_.isObject(val.props)) {
+                addValidationError('CHK_MSG_OBJ_GEN_214', 'invalid tableFields.props object property');
+                continue;
+              }
+
+              if (!val.props.fieldType) {
+                addValidationError('CHK_MSG_OBJ_GEN_216', 'invalid tableFields.props.fieldType property');
+              }
+            }
           }
+        }
+
+        // tableIndexes validation
+        if (!doc.tableIndexes) {
+          addValidationError('CHK_MSG_OBJ_GEN_302', 'missing tableIndexes property');
+        } else if (!_.isArray(doc.tableIndexes)) {
+          addValidationError('CHK_MSG_OBJ_GEN_302', 'invalid tableIndexes Array property');
+        } else {
           var index_ids = [];
           for (let val of doc.tableIndexes) {
             if (!_.isObject(val)) {
-              throw new Error('', {
-                cause: {
-                  code: 'CHK_MSG_OBJ_GEN_304',
-                  data: `invalid tableIndexes object property`,
-                },
-              });
+              addValidationError('CHK_MSG_OBJ_GEN_304', 'invalid tableIndexes object property');
+              continue;
             }
+
             if (!val.id) {
-              throw new Error('', {
-                cause: {
-                  code: 'CHK_MSG_OBJ_GEN_306',
-                  data: `missing tableIndexes.id property`,
-                },
-              });
+              addValidationError('CHK_MSG_OBJ_GEN_306', 'missing tableIndexes.id property');
+              continue;
             }
+
             if (index_ids.includes(val.id)) {
-              throw new Error('', {
-                cause: {
-                  code: 'CHK_MSG_OBJ_GEN_308',
-                  data: `${val.id} id must be unique in tableIndexes property`,
-                },
-              });
+              addValidationError('CHK_MSG_OBJ_GEN_308', `${val.id} id must be unique in tableIndexes property`);
+              continue;
             }
             index_ids.push(val.id);
+
             if (!_.isObject(val.data)) {
-              throw new Error('', {
-                cause: {
-                  code: 'CHK_MSG_OBJ_GEN_310',
-                  data: `invalid tableIndexes.data object property`,
-                },
-              });
+              addValidationError('CHK_MSG_OBJ_GEN_310', 'invalid tableIndexes.data object property');
+              continue;
             }
+
             if (!val.data.name) {
-              throw new Error('', {
-                cause: {
-                  code: 'CHK_MSG_OBJ_GEN_312',
-                  data: `invalid tableIndexes.data.name property`,
-                },
-              });
+              addValidationError('CHK_MSG_OBJ_GEN_312', 'invalid tableIndexes.data.name property');
             }
+
             if (!_.isArray(val.data.keys)) {
-              throw new Error('', {
-                cause: {
-                  code: 'CHK_MSG_OBJ_GEN_312',
-                  data: `invalid tableIndexes.data.keys Array property`,
-                },
-              });
+              addValidationError('CHK_MSG_OBJ_GEN_312', 'invalid tableIndexes.data.keys Array property');
             }
           }
         }
-
         break;
 
       case 'globals':
@@ -916,21 +607,12 @@ export const check_structure = function (doc) {
         check_progDataSource();
         check_progUi();
 
-        if (typeof doc.properties.uiFramework === 'undefined') {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_120',
-              data: `undefined properties.uiFramework string property`,
-            },
-          });
+        if (doc.properties && typeof doc.properties.uiFramework === 'undefined') {
+          addValidationError('CHK_MSG_OBJ_GEN_120', 'undefined properties.uiFramework string property');
         }
-        if (typeof doc.properties.renderType === 'undefined') {
-          throw new Error('', {
-            cause: {
-              code: 'CHK_MSG_OBJ_GEN_122',
-              data: `undefined properties.renderType string property`,
-            },
-          });
+
+        if (doc.properties && typeof doc.properties.renderType === 'undefined') {
+          addValidationError('CHK_MSG_OBJ_GEN_122', 'undefined properties.renderType string property');
         }
         break;
 
@@ -946,21 +628,8 @@ export const check_structure = function (doc) {
       default:
         break;
     }
-  } catch (err) {
-    if (err.cause) {
-      const { code, data } = err.cause;
-      ret.push({
-        code,
-        data,
-        type: 'E',
-        category: 'document',
-        structure_error: true,
-      });
-    } else {
-      console.error(err);
-      debugger;
-    }
   }
+
   return ret;
 };