@izara_project/izara-core-library-service-schemas 1.0.73 → 1.0.74

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-library-service-schemas",
-  "version": "1.0.73",
+  "version": "1.0.74",
   "description": "Schemas for the service and objects it controls",
   "main": "index.js",
   "scripts": {
@@ -14,22 +14,22 @@
   "license": "AGPL-3.0-or-later",
   "homepage": "https://bitbucket.org/izara-core-libraries/izara-core-library-service-schemas/src/master/README.md",
   "devDependencies": {
-    "jest": "^30.0.2"
+    "jest": "^30.0.3"
   },
   "jest": {
     "testEnvironment": "node"
   },
   "dependencies": {
-    "@aws-sdk/client-lambda": "^3.835.0",
-    "@aws-sdk/client-s3": "^3.835.0",
-    "@aws-sdk/crc64-nvme-crt": "^3.835.0",
-    "@aws-sdk/client-api-gateway": "^3.835.0",
+    "@aws-sdk/client-lambda": "^3.840.0",
+    "@aws-sdk/client-s3": "^3.840.0",
+    "@aws-sdk/crc64-nvme-crt": "^3.840.0",
+    "@aws-sdk/client-api-gateway": "^3.840.0",
     "@izara_project/izara-core-library-core": "^1.0.19",
     "@izara_project/izara-core-library-external-request": "^1.0.20",
     "@izara_project/izara-core-library-lambda": "^1.0.4",
     "@izara_project/izara-core-library-logger": "^1.0.7",
     "@izara_project/izara-shared-core": "^1.0.2",
-    "@izara_project/izara-shared-service-schemas": "^1.0.19",
+    "@izara_project/izara-shared-service-schemas": "^1.0.20",
     "glob": "^11.0.3",
     "lodash": "^4.17.21",
     "object-hash": "^3.0.0",

package/src/GetObjectSchema.js

@@ -222,7 +222,7 @@ async function getLocalObjectSchemas(_izContext, objectTypes, objSchemaPath = LO
       allObjectSchemas.map(async (objSchema, idx) => {
         const mergeResult = await mergeExtendObjSchema(_izContext, objSchema)
         if (mergeResult?.errorsFound?.length && mergeResult?.errorsFound?.length > 0) {
-          throw new NoRetryError(mergeResult.errorsFound)
+          throw new NoRetryError(mergeResult.errorsFound.join(","))
         } else {
           allObjectSchemas[idx] = mergeResult;
         }
@@ -471,7 +471,7 @@ async function getObjSchemaS3(
 ) {
   return await getObjectSchemaS3Shared(getSchemaByNameWithCache, objType, getExtendObType).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }
@@ -505,7 +505,7 @@ async function getObjSchemaS3WithHierarchy(_izContext, objType) {
   // return await getObjSchemaS3WithCache(_izContext, objType, true)
   return await getObjSchemaWithHierarchy(getSchemaByNameWithCache, objType).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }
@@ -522,7 +522,7 @@ async function getObjSchemaS3WithoutHierarchy(_izContext, objType) {
   // return await getObjSchemaS3WithCache(_izContext, objType, false)
   return await getObjSchemaWithoutHierarchy(getSchemaByNameWithCache, objType).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }
@@ -642,7 +642,7 @@ function getLocalRelationshipSchemas(_izContext, relationshipTags, objSchemaPath
 async function getRefObjectRelationship(_izContext, objType) {
   return await getRefObjectRelationshipShared(getSchemaByNameWithCache, objType).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }
@@ -677,7 +677,7 @@ const getRefObjectRelationshipWithCache = inMemoryCacheLib(
 async function getRelationshipSchema(_izContext, relType) {
   return await getRelationshipSchemaShared(getSchemaByNameWithCache, relType).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }
@@ -790,7 +790,7 @@ async function getObjectRelationship(
 
   return await getObjectRelationshipShared(getSchemaByNameWithCache, objType, specificRelTags, overWriteBaseObjType).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }
@@ -840,7 +840,7 @@ async function getRequiredOnCreateLinks(
 
   return await getRequiredOnCreateLinksShared(getSchemaByNameWithCache, objType, specificRelTags).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }
@@ -922,7 +922,7 @@ async function getLinkConfigByLinkTypeId(_izContext, firstObjType, secondObjType
 
   await getLinkConfigByLinkTypeIdShared(getSchemaByNameWithCache, firstObjType, secondObjType, relType, direction, settings).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }

package/src/libs/CreateNodeLib.js

@@ -26,22 +26,34 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
   _izContext.logger.debug("validateRequiredOnCreateLinks:::", { objType, relationships, settings })
 
 
-  let objectHie = await getObjTypeHierarchy(_izContext, objType);
+  let objectHie = await getObjTypeHierarchy(_izContext, objType).then(objSchema => {
+    if (objSchema.errorsFound.length > 0) {
+      throw new NoRetryError(objSchema.errorsFound.join(","))
+    } else {
+      return objSchema.result
+    }
+  });
   _izContext.logger.debug("objectHierarchy::", objectHie)
 
   if (relationships.length) {
-    let targetHierarchy = await getObjTypeHierarchy(_izContext, relationships[0].targetObjType);
+    let targetHierarchy = await getObjTypeHierarchy(_izContext, relationships[0].targetObjType).then(objSchema => {
+      if (objSchema.errorsFound.length > 0) {
+        throw new NoRetryError(objSchema.errorsFound.join(","))
+      } else {
+        return objSchema.result
+      }
+    });
     _izContext.logger.debug("targetHierarchy::", targetHierarchy)
   }
 
 
-  let errorFound = [];
+  let errorsFound = [];
 
   let requiredOnCreateLinks = await getObjectSchema.getRequiredOnCreateLinksWithCache(_izContext, objType)
   _izContext.logger.debug("requiredOnCreateLinks::", requiredOnCreateLinks)
 
   if (!requiredOnCreateLinks.length && relationships.length > 0) {
-    errorFound.push(`not have requireOnCreate will not create relationship: ${JSON.stringify(relationships)}`)
+    errorsFound.push(`not have requireOnCreate will not create relationship: ${JSON.stringify(relationships)}`)
   }
 
   let filteredRequiredOnCreateLinks = [];
@@ -76,22 +88,28 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
     let relTypeConcat = createRelTypeConcat(_izContext, relationship.relType)
 
     if (!requiredOnCreateLinkGroups[relTypeConcat]) {
-      errorFound.push(`cannot create relationship ${relTypeConcat}`)
+      errorsFound.push(`cannot create relationship ${relTypeConcat}`)
       break;
     }
 
     // match requiredOnCreateLinks with relationshipDirection from requestParams
     const usedLinkGroup = requiredOnCreateLinkGroups[relTypeConcat][relationship.relationshipDirection];
 
-    if (!usedLinkGroup.length) {
-      errorFound.push(`cannot create relationship ${relTypeConcat}`)
+    if (!usedLinkGroup?.length) {
+      errorsFound.push(`cannot create relationship ${relTypeConcat}`)
       break;
     }
 
     for (let link of usedLinkGroup) {
       // check other with targetObjType, check linkType of other should be 'one',
-      let targetObjTypeHierarchy = await getObjTypeHierarchy(_izContext, relationship.targetObjType);
-      _izContext.logger.debug(" ::", targetObjTypeHierarchy)
+      let targetObjTypeHierarchy = await getObjTypeHierarchy(_izContext, relationship.targetObjType).then(objSchema => {
+        if (objSchema.errorsFound.length > 0) {
+          throw new NoRetryError(objSchema.errorsFound.join(","))
+        } else {
+          return objSchema.result
+        }
+      });
+      _izContext.logger.debug("targetObjTypeHierarchy::", targetObjTypeHierarchy)
 
       // if (link.other.objType.objectType === relationship.targetObjType.objectType) {
       if (targetObjTypeHierarchy.some(objType =>
@@ -101,11 +119,11 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
           if (!validateOnCreateRelationships.has(`${relTypeConcat}_${relationship.relationshipDirection}`)) {
             validateOnCreateRelationships.add(`${relTypeConcat}_${relationship.relationshipDirection}`)
           } else {
-            errorFound.push(`unexpected dulicate relationship link ${JSON.stringify(relationship)}`)
+            errorsFound.push(`unexpected duplicate relationship link ${JSON.stringify(relationship)}`)
             break;
           }
         } else {
-          errorFound.push(`invalid linkType should not be many when base: ${link} is requiredOnCreated`)
+          errorsFound.push(`invalid linkType should not be many when base: ${link} is requiredOnCreated`)
           break;
         }
       }
@@ -117,11 +135,11 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
 
   for (const requiredOnCreateRelTypeConcat of requiredOnCreateRelTypeConcats) {
     if (!validateOnCreateRelationships.has(requiredOnCreateRelTypeConcat)) {
-      errorFound.push(`missing requiredOnCreate relationship ${requiredOnCreateRelTypeConcat}`)
+      errorsFound.push(`missing requiredOnCreate relationship ${requiredOnCreateRelTypeConcat}`)
     }
   }
 
-  return errorFound;
+  return errorsFound;
 }
 
 function groupRequiredOnCreateLink(_izContext, relationshipSchemas) {

package/src/libs/DeliminatorTree.js

@@ -205,24 +205,24 @@ async function generateDeliminatorTreeIdentifier(_izContext, objectSchema) {
           }));
 
           // calculate deliminatorTree of identifier
-          let calCompoisteKeyDeliminatorList = {};
+          let calCompositeKeyDeliminatorList = {};
           for (let deliminatorValue of Object.values(compositeKeysDeliminatorTree)) {
             if (deliminatorValue.deliminatorList) {
               for (let [deliminator, deliminatorAmount] of Object.entries(deliminatorValue.deliminatorList)) {
-                if (calCompoisteKeyDeliminatorList.hasOwnProperty(deliminator)) {
-                  calCompoisteKeyDeliminatorList[deliminator] = Math.max(deliminatorAmount, calCompoisteKeyDeliminatorList[deliminator]);
+                if (calCompositeKeyDeliminatorList.hasOwnProperty(deliminator)) {
+                  calCompositeKeyDeliminatorList[deliminator] = Math.max(deliminatorAmount, calCompositeKeyDeliminatorList[deliminator]);
                 } else {
-                  Object.assign(calCompoisteKeyDeliminatorList, { [deliminator]: deliminatorAmount });
+                  Object.assign(calCompositeKeyDeliminatorList, { [deliminator]: deliminatorAmount });
                 }
               }
             }
           }
 
 
-          if (calCompoisteKeyDeliminatorList.hasOwnProperty(identifierDeliminator)) {
-            calCompoisteKeyDeliminatorList[identifierDeliminator]++;
+          if (calCompositeKeyDeliminatorList.hasOwnProperty(identifierDeliminator)) {
+            calCompositeKeyDeliminatorList[identifierDeliminator]++;
           } else {
-            Object.assign(calCompoisteKeyDeliminatorList, { [identifierDeliminator]: 1 });
+            Object.assign(calCompositeKeyDeliminatorList, { [identifierDeliminator]: 1 });
           }
 
           Object.assign(
@@ -230,7 +230,7 @@ async function generateDeliminatorTreeIdentifier(_izContext, objectSchema) {
             {
               [identifierName]: {
                 deliminator: identifierDeliminator,
-                deliminatorList: calCompoisteKeyDeliminatorList,
+                deliminatorList: calCompositeKeyDeliminatorList,
                 children: compositeKeysDeliminatorTree
               }
             }

package/src/libs/RelSchemaLib.js

@@ -29,12 +29,12 @@ const { getObjTypeHierarchy } = require('../GetObjectSchema')
  *
  * @param {object} _izContext
  * @param {object[]} objTypes          - 2 objType in array
- * @param {object[]} relatoinshipLinks - links inside relationshipSchema
+ * @param {object[]} relationshipLinks - links inside relationshipSchema
  */
-async function findLinksByObjTypes(_izContext, objTypes, relatoinshipLinks) {
+async function findLinksByObjTypes(_izContext, objTypes, relationshipLinks) {
 
-  if (!Array.isArray(relatoinshipLinks)) {
-    throw new NoRetryError("relatoinshipLinks should be array");
+  if (!Array.isArray(relationshipLinks)) {
+    throw new NoRetryError("relationshipLinks should be array");
   }
 
   if (!objTypes || !Array.isArray(objTypes) || objTypes.length !== 2) {
@@ -52,8 +52,20 @@ async function findLinksByObjTypes(_izContext, objTypes, relatoinshipLinks) {
   const secondObjType = objTypes[1];
 
   // first create hierarchy of each objType
-  const firstObjTypeTree = await getObjTypeHierarchy(_izContext, objTypes[0]);
-  const secondObjTypeTree = await getObjTypeHierarchy(_izContext, objTypes[1]);
+  const firstObjTypeTree = await getObjTypeHierarchy(_izContext, objTypes[0]).then(objSchema => {
+    if (objSchema.errorsFound.length > 0) {
+      throw new NoRetryError(objSchema.errorsFound.join(","))
+    } else {
+      return objSchema.result
+    }
+  });
+  const secondObjTypeTree = await getObjTypeHierarchy(_izContext, objTypes[1]).then(objSchema => {
+    if (objSchema.errorsFound.length > 0) {
+      throw new NoRetryError(objSchema.errorsFound.join(","))
+    } else {
+      return objSchema.result
+    }
+  });
 
   const firstObjTypeTreeHashes = firstObjTypeTree.reduce(
     (result, objType) => {
@@ -74,7 +86,7 @@ async function findLinksByObjTypes(_izContext, objTypes, relatoinshipLinks) {
 
   let foundLinks = [];
 
-  for (let link of relatoinshipLinks) {
+  for (let link of relationshipLinks) {
     const fromObjTypeHash = hash(link.from.objType);
     const toObjTypeHash = hash(link.to.objType);
 

package/src/libs/UploadUseCase.js

@@ -100,6 +100,10 @@ function generateObjectSchemaForCreate(_izContext, objSchema) {
 
   for (let [fieldName, fieldNameSetting] of Object.entries(objSchema.fieldNames)) {
 
+    if (!fieldNameSetting.requiredOnCreate && !fieldNameSetting.optionalOnCreate) {
+      continue;
+    }
+
     if (!initReturnObj.fieldNames.hasOwnProperty(fieldName)) {
       initReturnObj.fieldNames[fieldName] = {}
     }
@@ -115,6 +119,11 @@ function generateObjectSchemaForCreate(_izContext, objSchema) {
     for (let addOn of objSchema.addOnDataStructure) {
       if (addOn.type === "versionedData") {
         for (let [versionedFieldName, fieldNameData] of Object.entries(addOn.fieldNames)) {
+
+          if (!fieldNameData.requiredOnCreate && !fieldNameData.optionalOnCreate) {
+            continue;
+          }
+
           Object.assign(
             initReturnObj.fieldNames,
             {
@@ -134,8 +143,6 @@ function generateObjectSchemaForCreate(_izContext, objSchema) {
   return initReturnObj;
 }
 
-
-
 /**
  * create object schema for update/display case
  *