@izara_project/izara-core-library-service-schemas 1.0.61 → 1.0.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-library-service-schemas",
-  "version": "1.0.61",
+  "version": "1.0.62",
   "description": "Schemas for the service and objects it controls",
   "main": "index.js",
   "scripts": {
@@ -20,15 +20,15 @@
     "testEnvironment": "node"
   },
   "dependencies": {
-    "@aws-sdk/client-lambda": "^3.787.0",
-    "@aws-sdk/client-s3": "^3.787.0",
-    "@aws-sdk/crc64-nvme-crt": "^3.787.0",
+    "@aws-sdk/client-lambda": "^3.812.0",
+    "@aws-sdk/client-s3": "^3.815.0",
+    "@aws-sdk/crc64-nvme-crt": "^3.815.0",
     "@izara_project/izara-core-library-core": "^1.0.19",
-    "@izara_project/izara-core-library-external-request": "^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-service-schemas": "^1.0.10",
-    "glob": "^11.0.1",
+    "@izara_project/izara-shared-service-schemas": "^1.0.12",
+    "glob": "^11.0.2",
     "lodash": "^4.17.21",
     "object-hash": "^3.0.0",
     "read-yaml-file": "^2.1.0"

package/src/SharedUtils.js

@@ -435,13 +435,21 @@ async function _processObjectLinksGroup(_izContext, relationshipTag, objectLinks
           direction
         );
 
+        let linkStorageResources = newLinkRelSchema.storageResourceTags.reduce((acc, tag) => {
+          const storageResource = relationshipSchema.storageResources[tag];
+          if (storageResource) {
+            acc[tag] = storageResource;
+          }
+          return acc;
+        }, {});
+
         // Build link object structure
         const link = {
           relType: {
             relationshipTag: relType.relationshipTag,
             serviceTag: relType.serviceTag
           },
-          storageResourceTags: storageResourceTags,
+          storageResources: linkStorageResources,
           from: newLinkRelSchema.from,
           to: newLinkRelSchema.to,
           canDelete: newLinkRelSchema.canDelete,
@@ -503,8 +511,8 @@ async function _processObjectLinksGroup(_izContext, relationshipTag, objectLinks
         relationshipSchema.links.push(newLinkRelSchema);
         linkByLinkTypeIds.push({ linkTypeId, link });
 
-        _izContext.logger.debug('relationshipSchema:', relationshipSchema);
-        _izContext.logger.debug('linkByLinkTypeIds:', linkByLinkTypeIds);
+        // _izContext.logger.debug('relationshipSchema:', relationshipSchema);
+        // _izContext.logger.debug('linkByLinkTypeIds:', linkByLinkTypeIds);
 
       } catch (error) {
         _izContext.logger.error('Error in addLinks:', error);

package/src/Utils.js

@@ -264,10 +264,11 @@ function validateAddOnDataStructure(_izContext, objectSchema) {
   const storageResources = objectSchema.storageResources;
   const storageTags = storageResources ? new Set(Object.keys(storageResources)) : new Set();
 
-  const allowedAddOnDataStructures = new Set(["versionedData", "attributeTree", "propertyNode", "translation"]);
+  const allowedAddOnDataStructures = new Set(["versionedData", "attributeTree", "propertyNode", "translation", "propertyValue"]);
 
   let errors = [];
   let fieldNameCollection = Object.keys(objectSchema.fieldNames || {});
+  let attriutebuteTreeTags = [];
 
   if (objectSchema.addOnDataStructure?.length) {
     for (const [idx, addOn] of objectSchema.addOnDataStructure.entries()) {
@@ -378,10 +379,17 @@ function validateRelationshipSchema(_izContext, relationshipSchema) {
         if (link.from?.requiredOnCreate === true && link.to?.requiredOnCreate === true) {
           errors.push(`Relationship:${relationshipTag}/links/${linkIdx}, requiredOnCreate should exists in one of 'from' or 'to'`);
         }
+
+        for (const direction of Object.keys(link)) {
+          if (direction === "from" || direction === "to") {
+            if (link[direction]?.requiredOnCreate === true && link[switchDirection(direction)].linkType === "many") {
+              errors.push(`Relationship:${relationshipTag}/link/${linkIdx}/${switchDirection(direction)}.linkType must be one if ${direction}.requiredOnCreate = ${link[direction].requiredOnCreate}`)
+            }
+          }
+        }
       }
     }
 
-
     if (errors.length) {
       return [false, errors];
     } else {
@@ -395,7 +403,6 @@ function validateRelationshipSchema(_izContext, relationshipSchema) {
   }
 }
 
-
 function validateRefRelationshipSchema(_izContext, refRelationshipSchema, serviceTag) {
   let validateStatus = validateObject(refRelationshipBasicSchema, refRelationshipSchema, null, { strict: false });
   if (validateStatus.pass) {
@@ -606,6 +613,13 @@ function validateBasicFlowSchema(_izContext, flowSchema) {
   }
 }
 
+function switchDirection(direction) {
+  if (direction === "from") {
+    return "to"
+  } else if (direction === "to") {
+    return "from"
+  }
+}
 
 module.exports = {
   createObjType,

package/src/libs/CreateNodeLib.js

@@ -16,90 +16,135 @@ along with this program.If not, see < http://www.gnu.org/licenses/>.
 */
 
 'use strict';
-const { createRelTypeConcat, createLinkTypeId } = require('../Utils')
-const { findLinksByObjTypes } = require('./RelSchemaLib')
+const { createRelTypeConcat, createLinkTypeId } = require('../Utils');
 const getObjectSchema = require('../GetObjectSchema');
+const serviceConfig = require('../ServiceConfig');
+const { STORAGE_TYPES } = require('../Consts')
 
-async function validateRelationshipDirection(_izContext, objType, relationshipProperties) {
-  _izContext.logger.debug("function validateRelationshipDirection::", { objType, relationshipProperties });
+async function validateRequiredOnCreateLinks(_izContext, objType, relationships, settings = {}) {
+  _izContext.logger.debug("validateRequiredOnCreateLinks:::", { objType, relationships, settings })
+  let errorFound = [];
 
-  let getObjectRelationship = await getObjectSchema.getRelationshipSchemaWithCache(
-    _izContext,
-    relationshipProperties.relType
-  )
-  _izContext.logger.debug("getObjectRelationship", getObjectRelationship);
+  let requiredOnCreateLinks = await getObjectSchema.getRequiredOnCreateLinksWithCache(_izContext, objType)
+  _izContext.logger.debug("requiredOnCreateLinks::", requiredOnCreateLinks)
 
-  let errorsFound = [];
-  let checkCorrectLinks = [];
+  if (!requiredOnCreateLinks.length && relationships.length > 0) {
+    errorFound.push(`not have requireOnCreate will not create relationship: ${JSON.stringify(relationships)}`)
+  }
 
-  for (const relationshipLink of Object.values(getObjectRelationship.links)) {
-    if (relationshipLink.from.linkType === "many" && relationshipLink.to.linkType === "many") {
-      if (relationshipLink.from.requiredOnCreate === true || relationshipLink.to.requiredOnCreate === true) {
-        errorsFound.push("error many to many linkType can't have requireOnCreate === true")
+  let filteredRequiredOnCreateLinks = [];
+  if (settings.groupLinksByGraphServiceTag) {
+    await Promise.all(requiredOnCreateLinks.map(async requiredOnCreateLink => {
+
+      const serviceTags = await Promise.all(
+        requiredOnCreateLink.storageResourceTags.map(async (storageTag) => {
+          let storageResource = requiredOnCreateLink.storageResources[storageTag];
+          if (storageResource.storageType === STORAGE_TYPES.graph) {
+            return await serviceConfig.getGraphServiceTagWithCache(_izContext, storageResource.graphServerTag)
+          }
+        })
+      );
+
+      if (serviceTags.includes(settings.groupLinksByGraphServiceTag)) {
+        filteredRequiredOnCreateLinks.push(requiredOnCreateLink);
       }
-    }
+    }))
+  } else {
+    filteredRequiredOnCreateLinks = requiredOnCreateLinks;
   }
-  const links = await findLinksByObjTypes(_izContext, [objType, relationshipProperties.targetObjType], getObjectRelationship.links);
-  _izContext.logger.debug("links", links)
 
-  if (!links.length) {
-    errorsFound.push(`not found link between ${JSON.stringify({ mainObjType: objType })} and ${JSON.stringify({ toObjType: relationshipProperties.targetObjType })} `)
-  }
+  let requiredOnCreateLinkGroups = groupRequiredOnCreateLink(_izContext, filteredRequiredOnCreateLinks);
+  _izContext.logger.debug("requiredOnCreateLinkGroups::", requiredOnCreateLinkGroups);
 
-  for (let link of links) {
-    const { serviceTag: fromServiceTag, objectType: fromObjectType } = objType;
-    const { serviceTag: toServiceTag, objectType: toObjectType } = relationshipProperties.targetObjType
+  let requiredOnCreateRelTypeConcats = createRelTypeConcatWithDirection(_izContext, requiredOnCreateLinkGroups)
+  let validateOnCreateRelationships = new Set();
+  _izContext.logger.debug("start validate relationship from requestParams")
+  for (const relationship of relationships) {
+    // validate all relationship in requestParams
+    let relTypeConcat = createRelTypeConcat(_izContext, relationship.relType)
 
-    const { serviceTag: firstServiceTag, objectType: firstObjectType } = link.from.objType;
-    const { serviceTag: secondServiceTag, objectType: secondObjectType } = link.to.objType
+    if (!requiredOnCreateLinkGroups[relTypeConcat]) {
+      errorFound.push(`cannot create relationship ${relTypeConcat}`)
+      break;
+    }
 
-    const matchesFromTo =
-      fromServiceTag === firstServiceTag && fromObjectType === firstObjectType &&
-      toServiceTag === secondServiceTag && toObjectType === secondObjectType;
+    // match requiredOnCreateLinks with relationshipDirection from requestParams
+    const usedLinkGroup = requiredOnCreateLinkGroups[relTypeConcat][relationship.relationshipDirection];
 
-    const matchesToFrom =
-      fromServiceTag === secondServiceTag && fromObjectType === secondObjectType &&
-      toServiceTag === firstServiceTag && toObjectType === firstObjectType
+    if (!usedLinkGroup.length) {
+      errorFound.push(`cannot create relationship ${relTypeConcat}`)
+      break;
+    }
 
-    if ((relationshipProperties.relationshipDirection === "from" && matchesFromTo) ||
-      (relationshipProperties.relationshipDirection === "to" && matchesToFrom)) {
-      checkCorrectLinks.push(true)
-    } else {
-      checkCorrectLinks.push(false)
+    for (let link of usedLinkGroup) {
+      // check other with targetObjType, check linkType of other should be 'one',
+      if (link.other.objType.objectType === relationship.targetObjType.objectType) {
+        if (link.other.linkType === "one") {
+          if (!validateOnCreateRelationships.has(`${relTypeConcat}_${relationship.relationshipDirection}`)) {
+            validateOnCreateRelationships.add(`${relTypeConcat}_${relationship.relationshipDirection}`)
+          } else {
+            errorFound.push(`unexpected dulicate relationship link ${JSON.stringify(relationship)}`)
+            break;
+          }
+        } else {
+          errorFound.push(`invalid linkType should not be many when base: ${link} is requiredOnCreated`)
+          break;
+        }
+      }
     }
   }
 
-  for (const [index, checkCorrectLink] of checkCorrectLinks.entries()) {
-    if (checkCorrectLink === false) {
-      errorsFound.push(`relationship direction ${JSON.stringify(requestParams.relationships[index])} is invalid`)
+  _izContext.logger.debug("requiredOnCreateRelTypeConcat", requiredOnCreateRelTypeConcats)
+  _izContext.logger.debug("validatedRelationships", validateOnCreateRelationships)
+
+  for (const requiredOnCreateRelTypeConcat of requiredOnCreateRelTypeConcats) {
+    if (!validateOnCreateRelationships.has(requiredOnCreateRelTypeConcat)) {
+      errorFound.push(`missing requiredOnCreate relationship ${requiredOnCreateRelTypeConcat}`)
     }
   }
-  return errorsFound;
+
+  return errorFound;
 }
 
-function grouplinkRequireOnCreateByRelType(_izContext, links) {
+function groupRequiredOnCreateLink(_izContext, relationshipSchemas) {
   let groupLink = {};
-  for (let link of links) {
-    let relTypeConcat = createRelTypeConcat(_izContext, link.relType);
+  for (let relationshipSchema of relationshipSchemas) {
+    let relTypeConcat = createRelTypeConcat(_izContext, relationshipSchema.relType);
     if (!groupLink.hasOwnProperty(relTypeConcat)) {
       Object.assign(groupLink, {
         [relTypeConcat]: {
           from: [],
           to: []
         }
-      }
-      )
+      })
     }
 
-    if (link.base.direction === "from") {
-      groupLink[relTypeConcat].from.push(link)
-    } else {
-      groupLink[relTypeConcat].to.push(link)
+    if (relationshipSchema.base.direction === "from") {
+      groupLink[relTypeConcat].from.push(relationshipSchema)
+    } else if (relationshipSchema.base.direction === "to") {
+      groupLink[relTypeConcat].to.push(relationshipSchema)
     }
   }
   return groupLink
 }
 
+function createRelTypeConcatWithDirection(_izContext, link) {
+  // console.log("createRelTypeConcat", { link })
+  let relTypeConcatSet = new Set();
+  for (const [relTypeConcat, direction] of Object.entries(link)) {
+    if (direction.from.length) {
+      relTypeConcatSet.add(`${relTypeConcat}_from`)
+    }
+
+    if (direction.to.length) {
+      relTypeConcatSet.add(`${relTypeConcat}_to`)
+    }
+
+
+  }
+  return relTypeConcatSet
+}
+
 function createLinkTypeIdFromLinkGroup(_izContext, linkGroup) {
   let linkTypeIds = new Set();
   for (const objectRelationshipGroup of Object.values(linkGroup)) {
@@ -121,11 +166,19 @@ function createLinkTypeIdFromLinkGroup(_izContext, linkGroup) {
   return [...linkTypeIds]
 }
 
-function validateLinkTypeFromObjectRelLink(_izContext, links) {
-  
+
+function switchDirection(direction) {
+  if (direction === "from") {
+    return "to"
+  } else if (direction === "to") {
+    return "from"
+  }
 }
+
 module.exports = {
-  validateRelationshipDirection,
-  grouplinkRequireOnCreateByRelType,
-  createLinkTypeIdFromLinkGroup
+  validateRequiredOnCreateLinks,
+  groupRequiredOnCreateLink,
+  createLinkTypeIdFromLinkGroup,
+  switchDirection,
+  createRelTypeConcatWithDirection
 }

package/src/libs/UploadUseCase.js

@@ -380,13 +380,20 @@ function generateLinksDataPerLinkTypeId(_izContext, relationshipTag, relationshi
       "from"
     );
 
+    let linkStorageResources = link.storageResourceTags.reduce((acc, storageResourceTag) => {
+      if (storageResources.hasOwnProperty(storageResourceTag)) {
+        acc[storageResourceTag] = storageResources[storageResourceTag];
+      }
+      return acc;
+    }, {});
 
     linksData[linkTypeId] = {
       relType: {
         relationshipTag,
         serviceTag: process.env.iz_serviceTag
       },
-      storageResources: storageResources,
+      canDelete: link.canDelete || false,
+      storageResources: linkStorageResources,
       from: link.from,
       to: link.to
     };