@izara_frontend/service-schemas 1.0.4 → 1.0.5

package/index.js

@@ -6,6 +6,7 @@ export {
   getRequiredOnCreateLinks,
   getRelationshipSchema,
   getObjSchemaWithOutHierarchy,
+  collectObjectSchemaWithHierarchy,
   getObjSchemaWithHierarchy,
   getObjSchemaCombineFieldNames,
   getLinkConfig,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_frontend/service-schemas",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "",
   "main": "index.js",
   "scripts": {

package/src/getObjectSchema.js

@@ -198,6 +198,108 @@ export function getObjectSchemaWithAllHierarchy() {
   return [result, run, { errorsFound }];
 }
 
+export function collectObjectSchemaWithHierarchy() {
+  const [, getObjectSchemaWithAllHierarchyFn] = getObjectSchemaWithAllHierarchy();
+
+  const [result, setResult] = useState(null);
+  const [errorsFound, setErrorsFound] = useState([]);
+
+
+
+  // ref to always read latest result inside async functions (avoids stale closures)
+  const resultRef = useRef(result);
+  useEffect(() => { resultRef.current = result; }, [result]);
+
+  // core executor that does the actual work and optionally updates hook state
+  const execute = useCallback(async (objType, { updateState = true } = {}) => {
+
+    async function collectObjectSchemaWithHierarchyMain(objType) {
+
+      // validate objType (some validators throw, some return errors)
+      try {
+        validateObjType(objType);
+      } catch (err) {
+        return [null, [err.message]];
+      }
+
+      // compute mainObjTypeConcat and validate
+      const [mainObjTypeConcat, mainObjTypeErrors] = createObjTypeConcat(objType);
+      if (mainObjTypeErrors && mainObjTypeErrors.length) {
+        return [null, mainObjTypeErrors];
+      }
+
+      // short-circuit: if updateState and we already have this objType in result, return cached value
+      if (updateState && resultRef.current && resultRef.current.hasOwnProperty(mainObjTypeConcat)) {
+        return [{ [mainObjTypeConcat]: resultRef.current[mainObjTypeConcat] }, []];
+      }
+
+
+
+      const [objSchema, getObjSchemaErrors] = await getObjectSchemaWithAllHierarchyFn().initiate(objType);
+
+
+      return [objSchema, getObjSchemaErrors];
+    }
+
+    try {
+
+
+      const [schema, errorsFound] = await collectObjectSchemaWithHierarchyMain(objType);
+
+      if (updateState) {
+        if (errorsFound && errorsFound.length) {
+          setErrorsFound(errorsFound);
+          setResult(null);
+        } else {
+          const [currentObjTypeConcat] = createObjTypeConcat(objType);
+
+          setResult(prev => {
+            // nothing to add
+            if (!schema || !Object.keys(schema).length) return prev;
+
+            // first-time fill
+            if (!prev) return schema;
+
+            // already have this objType => no update
+            if (prev.hasOwnProperty(currentObjTypeConcat)) return prev;
+
+            // merge but return a NEW object to trigger React update (do not mutate prev)
+            return { ...prev, ...schema };
+          });
+
+          setErrorsFound([]);
+        }
+      }
+
+      return [schema, errorsFound];
+    } catch (err) {
+      const msg = err?.message || String(err);
+      if (updateState) {
+        setErrorsFound([msg]);
+        setResult(null);
+      }
+      return [null, [msg]];
+    }
+  }, [getObjectSchemaWithAllHierarchyFn]);
+
+
+  // run can be used two ways:
+  // 1) run(objType) -> updates hook state and returns Promise<[collected, errors]>
+  // 2) run().initiate(objType) -> does NOT touch hook state, returns Promise<[collected, errors]>
+  const run = useCallback((objType) => {
+    if (typeof objType === "undefined") {
+      return {
+        initiate: (objType) => execute(objType, { updateState: false }),
+        clear: () => { setResult(null); setErrorsFound([]); }
+      };
+    }
+    // direct call: update state
+    return execute(objType, { updateState: true });
+  }, [execute]);
+
+  return [result, run, { errorsFound }];
+}
+
 
 export function getObjectLinks() {
   const {