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

package/index.js

@@ -24,6 +24,7 @@ module.exports = {
   uploadUseCase: require('./src/libs/UploadUseCase'),
   relSchemaLib: require('./src/libs/RelSchemaLib'),
   s3Utils: require('./src/libs/s3Utils'),
+  createNodeLib: require('./src/libs/CreateNodeLib'),
 
   // .src
   consts: require('./src/Consts'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-library-service-schemas",
-  "version": "1.0.60",
+  "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

@@ -0,0 +1,184 @@
+/*
+Copyright(C) 2021 Sven Mason < http://izara.io>
+
+This program is free software: you can redistribute it and / or modify
+it under the terms of the GNU Affero General Public License as
+  published by the Free Software Foundation, either version 3 of the
+License, or(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.If not, see < http://www.gnu.org/licenses/>.
+*/
+
+'use strict';
+const { createRelTypeConcat, createLinkTypeId } = require('../Utils');
+const getObjectSchema = require('../GetObjectSchema');
+const serviceConfig = require('../ServiceConfig');
+const { STORAGE_TYPES } = require('../Consts')
+
+async function validateRequiredOnCreateLinks(_izContext, objType, relationships, settings = {}) {
+  _izContext.logger.debug("validateRequiredOnCreateLinks:::", { objType, relationships, settings })
+  let errorFound = [];
+
+  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)}`)
+  }
+
+  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;
+  }
+
+  let requiredOnCreateLinkGroups = groupRequiredOnCreateLink(_izContext, filteredRequiredOnCreateLinks);
+  _izContext.logger.debug("requiredOnCreateLinkGroups::", requiredOnCreateLinkGroups);
+
+  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)
+
+    if (!requiredOnCreateLinkGroups[relTypeConcat]) {
+      errorFound.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}`)
+      break;
+    }
+
+    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;
+        }
+      }
+    }
+  }
+
+  _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 errorFound;
+}
+
+function groupRequiredOnCreateLink(_izContext, relationshipSchemas) {
+  let groupLink = {};
+  for (let relationshipSchema of relationshipSchemas) {
+    let relTypeConcat = createRelTypeConcat(_izContext, relationshipSchema.relType);
+    if (!groupLink.hasOwnProperty(relTypeConcat)) {
+      Object.assign(groupLink, {
+        [relTypeConcat]: {
+          from: [],
+          to: []
+        }
+      })
+    }
+
+    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)) {
+    for (const direction of Object.keys(objectRelationshipGroup)) {
+      let objectRelationshipByDirection = objectRelationshipGroup[direction]
+      if (objectRelationshipGroup[direction].length) {
+        for (const objectRelLink of objectRelationshipGroup[direction]) {
+          linkTypeIds.add(createLinkTypeId(
+            _izContext,
+            objectRelLink?.base?.objType,
+            objectRelLink?.other?.objType,
+            objectRelLink?.relType,
+            objectRelLink?.base?.direction
+          ))
+        }
+      }
+    }
+  }
+  return [...linkTypeIds]
+}
+
+
+function switchDirection(direction) {
+  if (direction === "from") {
+    return "to"
+  } else if (direction === "to") {
+    return "from"
+  }
+}
+
+module.exports = {
+  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
     };
@@ -433,44 +440,48 @@ async function refRelationshipPerObjectSchema(_izContext, objSchema) {
   let refObjectRel = {};
 
 
-  if (objSchema.hasOwnProperty("belongTo")) {
-    Object.assign(
-      refObjectRel,
-      {
-        "createdBy": {
-          relationshipServiceTag: "UserAccount"
-        },
-        "belongTo": {
-          relationshipServiceTag: "UserAccount"
+  if (process.env.iz_serviceTag !== "UserAccount") {
+    if (objSchema.hasOwnProperty("belongTo")) {
+      Object.assign(
+        refObjectRel,
+        {
+          "createdBy": {
+            relationshipServiceTag: "UserAccount"
+          },
+          "belongTo": {
+            relationshipServiceTag: "UserAccount"
+          }
         }
-      }
-    )
-  } else {
-    Object.assign(
-      refObjectRel,
-      {
-        "createdBy": {
-          relationshipServiceTag: "UserAccount"
+      )
+    } else {
+      Object.assign(
+        refObjectRel,
+        {
+          "createdBy": {
+            relationshipServiceTag: "UserAccount"
+          }
         }
-      }
-    )
+      )
+    }
   }
 
-  if (objSchema?.addOnDataStructure?.length && objSchema.addOnDataStructure.some(addOn => addOn.type === "translation")) {
-    Object.assign(
-      refObjectRel,
-      {
-        hasTranslationLink: {
-          relationshipServiceTag: "Translations",
-        },
-        currentTranslationLink: {
-          relationshipServiceTag: "Translations",
-        },
-        defaultTranslationLink: {
-          relationshipServiceTag: "Translations",
-        },
-      }
-    )
+  if (process.env.iz_serviceTag !== "Translations") {
+    if (objSchema?.addOnDataStructure?.length && objSchema.addOnDataStructure.some(addOn => addOn.type === "translation")) {
+      Object.assign(
+        refObjectRel,
+        {
+          hasTranslationLink: {
+            relationshipServiceTag: "Translations",
+          },
+          currentTranslationLink: {
+            relationshipServiceTag: "Translations",
+          },
+          defaultTranslationLink: {
+            relationshipServiceTag: "Translations",
+          },
+        }
+      )
+    }
   }