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

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.61",
   "description": "Schemas for the service and objects it controls",
   "main": "index.js",
   "scripts": {

package/src/libs/CreateNodeLib.js

@@ -0,0 +1,131 @@
+/*
+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 { findLinksByObjTypes } = require('./RelSchemaLib')
+const getObjectSchema = require('../GetObjectSchema');
+
+async function validateRelationshipDirection(_izContext, objType, relationshipProperties) {
+  _izContext.logger.debug("function validateRelationshipDirection::", { objType, relationshipProperties });
+
+  let getObjectRelationship = await getObjectSchema.getRelationshipSchemaWithCache(
+    _izContext,
+    relationshipProperties.relType
+  )
+  _izContext.logger.debug("getObjectRelationship", getObjectRelationship);
+
+  let errorsFound = [];
+  let checkCorrectLinks = [];
+
+  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")
+      }
+    }
+  }
+  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 })} `)
+  }
+
+  for (let link of links) {
+    const { serviceTag: fromServiceTag, objectType: fromObjectType } = objType;
+    const { serviceTag: toServiceTag, objectType: toObjectType } = relationshipProperties.targetObjType
+
+    const { serviceTag: firstServiceTag, objectType: firstObjectType } = link.from.objType;
+    const { serviceTag: secondServiceTag, objectType: secondObjectType } = link.to.objType
+
+    const matchesFromTo =
+      fromServiceTag === firstServiceTag && fromObjectType === firstObjectType &&
+      toServiceTag === secondServiceTag && toObjectType === secondObjectType;
+
+    const matchesToFrom =
+      fromServiceTag === secondServiceTag && fromObjectType === secondObjectType &&
+      toServiceTag === firstServiceTag && toObjectType === firstObjectType
+
+    if ((relationshipProperties.relationshipDirection === "from" && matchesFromTo) ||
+      (relationshipProperties.relationshipDirection === "to" && matchesToFrom)) {
+      checkCorrectLinks.push(true)
+    } else {
+      checkCorrectLinks.push(false)
+    }
+  }
+
+  for (const [index, checkCorrectLink] of checkCorrectLinks.entries()) {
+    if (checkCorrectLink === false) {
+      errorsFound.push(`relationship direction ${JSON.stringify(requestParams.relationships[index])} is invalid`)
+    }
+  }
+  return errorsFound;
+}
+
+function grouplinkRequireOnCreateByRelType(_izContext, links) {
+  let groupLink = {};
+  for (let link of links) {
+    let relTypeConcat = createRelTypeConcat(_izContext, link.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)
+    }
+  }
+  return groupLink
+}
+
+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 validateLinkTypeFromObjectRelLink(_izContext, links) {
+  
+}
+module.exports = {
+  validateRelationshipDirection,
+  grouplinkRequireOnCreateByRelType,
+  createLinkTypeIdFromLinkGroup
+}

package/src/libs/UploadUseCase.js

@@ -433,44 +433,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",
+          },
+        }
+      )
+    }
   }