@izara_project/izara-core-library-service-schemas 1.0.76 → 1.0.78

package/src/libs/CreateNodeLib.js

@@ -19,14 +19,14 @@ along with this program.If not, see < http://www.gnu.org/licenses/>.
 const { createRelTypeConcat, createLinkTypeId } = require('../Utils');
 const getObjectSchema = require('../GetObjectSchema');
 const serviceConfig = require('../ServiceConfig');
-const { STORAGE_TYPES } = require('../Consts')
+const { STORAGE_TYPES, OBJECT_SCHEMA_BUCKET_NAME } = require('../Consts')
 const { getObjTypeHierarchy } = require('../GetObjectSchema')
 
-async function validateRequiredOnCreateLinks(_izContext, objType, relationships, settings = {}) {
+async function validateRequiredOnCreateLinks(_izContext, objType, relationships = [], settings = { bucketName: OBJECT_SCHEMA_BUCKET_NAME }) {
   _izContext.logger.debug("validateRequiredOnCreateLinks:::", { objType, relationships, settings })
 
-
-  let objectHie = await getObjTypeHierarchy(_izContext, objType).then(objSchema => {
+  let bucketName = settings.bucketName ? settings.bucketName : OBJECT_SCHEMA_BUCKET_NAME
+  let objectHie = await getObjTypeHierarchy(_izContext, objType, settings.bucketName).then(objSchema => {
     if (objSchema.errorsFound.length > 0) {
       throw new NoRetryError(objSchema.errorsFound.join(","))
     } else {
@@ -36,7 +36,7 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
   _izContext.logger.debug("objectHierarchy::", objectHie)
 
   if (relationships.length) {
-    let targetHierarchy = await getObjTypeHierarchy(_izContext, relationships[0].targetObjType).then(objSchema => {
+    let targetHierarchy = await getObjTypeHierarchy(_izContext, relationships[0].targetObjType, settings.bucketName).then(objSchema => {
       if (objSchema.errorsFound.length > 0) {
         throw new NoRetryError(objSchema.errorsFound.join(","))
       } else {
@@ -49,7 +49,7 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
 
   let errorsFound = [];
 
-  let requiredOnCreateLinks = await getObjectSchema.getRequiredOnCreateLinksWithCache(_izContext, objType)
+  let requiredOnCreateLinks = await getObjectSchema.getRequiredOnCreateLinksWithCache(_izContext, objType, [], settings.bucketName)
   _izContext.logger.debug("requiredOnCreateLinks::", requiredOnCreateLinks)
 
   if (!requiredOnCreateLinks.length && relationships.length > 0) {
@@ -64,7 +64,7 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
         requiredOnCreateLink.storageResourceTags.map(async (storageTag) => {
           let storageResource = requiredOnCreateLink.storageResources[storageTag];
           if (storageResource.storageType === STORAGE_TYPES.graph) {
-            return await serviceConfig.getGraphServiceTagWithCache(_izContext, storageResource.graphServerTag)
+            return await serviceConfig.getGraphServiceTagWithCache(_izContext, storageResource.graphServerTag, settings.bucketName)
           }
         })
       );
@@ -102,7 +102,7 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
 
     for (let link of usedLinkGroup) {
       // check other with targetObjType, check linkType of other should be 'one',
-      let targetObjTypeHierarchy = await getObjTypeHierarchy(_izContext, relationship.targetObjType).then(objSchema => {
+      let targetObjTypeHierarchy = await getObjTypeHierarchy(_izContext, relationship.targetObjType, settings.bucketName).then(objSchema => {
         if (objSchema.errorsFound.length > 0) {
           throw new NoRetryError(objSchema.errorsFound.join(","))
         } else {

package/src/libs/DeliminatorTree.js

@@ -20,7 +20,7 @@ along with this program.If not, see < http://www.gnu.org/licenses/>.
 const { NoRetryError } = require('@izara_project/izara-core-library-core');
 
 const { getObjSchemaS3WithHierarchy } = require("../GetObjectSchema");
-const { DEFAULT_IDENTIFIER_DELIMINATOR } = require("../Consts");
+const { DEFAULT_IDENTIFIER_DELIMINATOR, OBJECT_SCHEMA_BUCKET_NAME } = require("../Consts");
 
 
 /**
@@ -31,7 +31,7 @@ const { DEFAULT_IDENTIFIER_DELIMINATOR } = require("../Consts");
  * @param {Object} fieldNameSetting
  * @param {Object} [objType]          use to store objType of child
  */
-async function generateDeliminatorTreePerFieldName(_izContext, fieldName, fieldNameSetting, objType, iter = 0) {
+async function generateDeliminatorTreePerFieldName(_izContext, fieldName, fieldNameSetting, objType, bucketName = OBJECT_SCHEMA_BUCKET_NAME, iter = 0) {
 
   if (iter > 50) {
     throw new NoRetryError("generateValidatorSchemaPerFieldName reach max iteration limit")
@@ -43,7 +43,7 @@ async function generateDeliminatorTreePerFieldName(_izContext, fieldName, fieldN
     [fieldName]: {},
   };
 
-  if (objType) {
+  if (Object.keys(objType).length) {
     Object.assign(deliminatorTree[fieldName], objType);
   }
 
@@ -57,7 +57,8 @@ async function generateDeliminatorTreePerFieldName(_izContext, fieldName, fieldN
       {
         objectType: fieldNameSetting.fromObjectType,
         serviceTag: fieldNameSetting.fromServiceNameTag
-      }
+      },
+      bucketName
     );
 
     if (!childObjectSchema) {
@@ -93,6 +94,7 @@ async function generateDeliminatorTreePerFieldName(_izContext, fieldName, fieldN
           objectType: fieldNameSetting.fromObjectType,
           serviceTag: fieldNameSetting.fromServiceNameTag
         },
+        bucketName,
         iter
       );
       _izContext.logger.debug("childDeliminator: ", childDeliminator)
@@ -136,7 +138,7 @@ async function generateDeliminatorTreePerFieldName(_izContext, fieldName, fieldN
 }
 
 
-async function generateDeliminatorTreeAllFieldNames(_izContext, objectSchema) {
+async function generateDeliminatorTreeAllFieldNames(_izContext, objectSchema, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
   let deliminatorTreeFieldNames = {};
   let deliminatorTreePromises = [];
 
@@ -145,7 +147,7 @@ async function generateDeliminatorTreeAllFieldNames(_izContext, objectSchema) {
       async () => {
         Object.assign(
           deliminatorTreeFieldNames,
-          await generateDeliminatorTreePerFieldName(_izContext, fieldName, fieldNameData))
+          await generateDeliminatorTreePerFieldName(_izContext, fieldName, fieldNameData, {}, bucketName))
       }
     )
   }
@@ -162,7 +164,7 @@ async function generateDeliminatorTreeAllFieldNames(_izContext, objectSchema) {
           async () => {
             Object.assign(
               deliminatorTreeFieldNames,
-              await generateDeliminatorTreePerFieldName(_izContext, versionedFieldName, versionedDataFieldSetting))
+              await generateDeliminatorTreePerFieldName(_izContext, versionedFieldName, versionedDataFieldSetting, {}, bucketName))
           }
         )
       }
@@ -184,7 +186,7 @@ async function generateDeliminatorTreeAllFieldNames(_izContext, objectSchema) {
  * @param {Object} objectSchema
  * @returns
  */
-async function generateDeliminatorTreeIdentifier(_izContext, objectSchema) {
+async function generateDeliminatorTreeIdentifier(_izContext, objectSchema, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
 
   let identifiersDeliminatorTree = {};
 
@@ -199,7 +201,7 @@ async function generateDeliminatorTreeIdentifier(_izContext, objectSchema) {
 
           // collect deliminatorTree of composite key
           await Promise.all(identifier.fieldNames.map(async (compositeKey) => {
-            let compositeKeyDeliminatortree = await generateDeliminatorTreePerFieldName(_izContext, compositeKey, objectSchema.fieldNames[compositeKey]);
+            let compositeKeyDeliminatortree = await generateDeliminatorTreePerFieldName(_izContext, compositeKey, objectSchema.fieldNames[compositeKey], {}, bucketName);
             _izContext.logger.debug("compositeKeyDeliminatortree each fieldname: ", compositeKeyDeliminatortree);
             Object.assign(compositeKeysDeliminatorTree, compositeKeyDeliminatortree);
           }));
@@ -237,7 +239,7 @@ async function generateDeliminatorTreeIdentifier(_izContext, objectSchema) {
           );
 
         } else {
-          let identifierFieldNameDeliminatorTree = await generateDeliminatorTreePerFieldName(_izContext, identifierName, objectSchema.fieldNames[identifierName]);
+          let identifierFieldNameDeliminatorTree = await generateDeliminatorTreePerFieldName(_izContext, identifierName, objectSchema.fieldNames[identifierName], {}, bucketName);
           Object.assign(identifiersDeliminatorTree, identifierFieldNameDeliminatorTree);
         }
       }
@@ -247,9 +249,9 @@ async function generateDeliminatorTreeIdentifier(_izContext, objectSchema) {
   return identifiersDeliminatorTree
 }
 
-async function generateDeliminatorCompositeIdentifier(_izContext, objSchema) {
+async function generateDeliminatorCompositeIdentifier(_izContext, objSchema, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
 
-  let deliminatorTreeResult = await generateDeliminatorTreeIdentifier(_izContext, objSchema);
+  let deliminatorTreeResult = await generateDeliminatorTreeIdentifier(_izContext, objSchema, bucketName);
   _izContext.logger.debug("deliminator: ", deliminatorTreeResult);
 
 

package/src/libs/ExplodedReqParams.js

@@ -20,6 +20,7 @@ along with this program.If not, see < http://www.gnu.org/licenses/>.
 const { NoRetryError } = require('@izara_project/izara-core-library-core');
 
 const deliminatorTree = require("./DeliminatorTree");
+const { OBJECT_SCHEMA_BUCKET_NAME } = require('../Consts');
 
 
 /**
@@ -122,7 +123,7 @@ function explodeDataField(
  * @param {Object} requestParams
  * @param {Object} objType
  */
-async function explodedDataForCreate(_izContext, requestParams, objectSchema) {
+async function explodedDataForCreate(_izContext, requestParams, objectSchema, settings = { bucketName: OBJECT_SCHEMA_BUCKET_NAME }) {
 
   // ------- validate requestParams -------
   let errors = [];
@@ -162,7 +163,7 @@ async function explodedDataForCreate(_izContext, requestParams, objectSchema) {
     fieldNames: {}
   };
 
-  let deliminatorTreeFieldNames = await deliminatorTree.generateDeliminatorTreeAllFieldNames(_izContext, objectSchema);
+  let deliminatorTreeFieldNames = await deliminatorTree.generateDeliminatorTreeAllFieldNames(_izContext, objectSchema, settings.bucketName);
   _izContext.logger.debug("deliminatorTreeFieldNames: ", deliminatorTreeFieldNames);
 
   await Promise.all(
@@ -225,7 +226,7 @@ async function explodedDataForCreate(_izContext, requestParams, objectSchema) {
  * @param {Object} requestParams
  * @param {Object} objType
  */
-async function explodedDataForIdentifiers(_izContext, requestParams, objectSchema) {
+async function explodedDataForIdentifiers(_izContext, requestParams, objectSchema, settings = { bucketName: OBJECT_SCHEMA_BUCKET_NAME }) {
   _izContext.logger.debug("explodedDataForIdentifiers: ",
     { requestParams, objectSchema }
   );
@@ -280,7 +281,9 @@ async function explodedDataForIdentifiers(_izContext, requestParams, objectSchem
           await deliminatorTree.generateDeliminatorTreePerFieldName(
             _izContext,
             identifierKey,
-            objectSchema.fieldNames[identifierKey]
+            objectSchema.fieldNames[identifierKey],
+            {},
+            settings.bucketName
           )
         );
 
@@ -337,15 +340,14 @@ async function explodedDataForIdentifiers(_izContext, requestParams, objectSchem
   return explodedReqParams;
 }
 
-async function explodedDataForUpdate(_izContext, requestParams, objectSchema, setting) {
+async function explodedDataForUpdate(_izContext, requestParams, objectSchema, settings = { bucketName: OBJECT_SCHEMA_BUCKET_NAME }) {
   //validate requestParams
   _izContext.logger.debug("explodedDataForUpdate::",
     {
-      requestParams, objectSchema, setting
+      requestParams, objectSchema, settings
     }
   )
-
-  let errors = [];
+  let errorsFound = [];
 
   const propertiesTypeForUpdate = {
     objInstanceFull: {
@@ -370,16 +372,16 @@ async function explodedDataForUpdate(_izContext, requestParams, objectSchema, se
   for (let prop in propertiesTypeForUpdate) {
     if (propertiesTypeForUpdate[prop].required === true) {
       if (!requestParams.hasOwnProperty(prop)) {
-        errors.push(`Missing require property: ${prop}`);
+        errorsFound.push(`Missing require property: ${prop}`);
       }
 
       if (requestParams.hasOwnProperty(prop)) {
         if (typeof (requestParams[prop]) !== propertiesTypeForUpdate[prop].type) {
-          errors.push(`property  ${prop} type should be ${propertiesTypeForUpdate[prop].type}`);
+          errorsFound.push(`property  ${prop} type should be ${propertiesTypeForUpdate[prop].type}`);
         }
       }
       if (propertiesTypeForUpdate[prop].type === "object" && requestParams[prop] === null) {
-        errors.push(`property: ${[prop]} type should be ${propertiesTypeForUpdate[prop].type}`)
+        errorsFound.push(`property: ${[prop]} type should be ${propertiesTypeForUpdate[prop].type}`)
       }
     }
   }
@@ -394,14 +396,14 @@ async function explodedDataForUpdate(_izContext, requestParams, objectSchema, se
     versionedDataIds: {}
   }
 
-  let deliminatorTreeFieldNames = await deliminatorTree.generateDeliminatorTreeAllFieldNames(_izContext, objectSchema)
+  let deliminatorTreeFieldNames = await deliminatorTree.generateDeliminatorTreeAllFieldNames(_izContext, objectSchema, settings.bucketName)
   _izContext.logger.debug("deliminatorTreeFieldNames", deliminatorTreeFieldNames);
 
   await Promise.all(
     Object.entries(requestParams.objInstanceFull.identifiers).map(
       async ([reqPropKey, reqPropValue]) => {
         if (!deliminatorTreeFieldNames.hasOwnProperty(reqPropKey)) {
-          errors.push(`property:${reqPropKey} not match with fieldNames of ObjectSchema`);
+          errorsFound.push(`property:${reqPropKey} not match with fieldNames of ObjectSchema`);
         }
 
         let explodedIdentifiers
@@ -415,7 +417,7 @@ async function explodedDataForUpdate(_izContext, requestParams, objectSchema, se
             }
           )
         } catch (err) {
-          errors.push(err)
+          errorsFound.push(err)
         }
         _izContext.logger.debug("explodedIdentifiers", explodedIdentifiers)
         Object.assign(explodedReqParams.objInstanceFull.identifiers, explodedIdentifiers)
@@ -438,7 +440,7 @@ async function explodedDataForUpdate(_izContext, requestParams, objectSchema, se
             }
           )
         } catch (err) {
-          errors.push(err)
+          errorsFound.push(err)
         }
         _izContext.logger.debug("explodedField", explodedField)
         Object.assign(explodedReqParams.objInstanceFull.fields, explodedField)

package/src/libs/RelSchemaLib.js

@@ -23,7 +23,8 @@ const hash = require('@izara_project/izara-shared-core').objectHash;
 const { NoRetryError } = require('@izara_project/izara-core-library-core');
 const getObjectSchema = require("../GetObjectSchema");
 const { validateObjType: { validateObjType } } = require("@izara_project/izara-shared-service-schemas");
-const { getObjTypeHierarchy } = require('../GetObjectSchema')
+const { getObjTypeHierarchy } = require('../GetObjectSchema');
+const { OBJECT_SCHEMA_BUCKET_NAME } = require("../Consts");
 /**
  * helper function for find link of 2 objects in links and refactor each link
  *
@@ -31,7 +32,7 @@ const { getObjTypeHierarchy } = require('../GetObjectSchema')
  * @param {object[]} objTypes          - 2 objType in array
  * @param {object[]} relationshipLinks - links inside relationshipSchema
  */
-async function findLinksByObjTypes(_izContext, objTypes, relationshipLinks) {
+async function findLinksByObjTypes(_izContext, objTypes, relationshipLinks, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
 
   if (!Array.isArray(relationshipLinks)) {
     throw new NoRetryError("relationshipLinks should be array");
@@ -52,14 +53,14 @@ async function findLinksByObjTypes(_izContext, objTypes, relationshipLinks) {
   const secondObjType = objTypes[1];
 
   // first create hierarchy of each objType
-  const firstObjTypeTree = await getObjTypeHierarchy(_izContext, objTypes[0]).then(objSchema => {
+  const firstObjTypeTree = await getObjTypeHierarchy(_izContext, objTypes[0], bucketName).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 => {
+  const secondObjTypeTree = await getObjTypeHierarchy(_izContext, objTypes[1], bucketName).then(objSchema => {
     if (objSchema.errorsFound.length > 0) {
       throw new NoRetryError(objSchema.errorsFound.join(","))
     } else {

package/src/libs/UploadUseCase.js

@@ -383,6 +383,10 @@ function generateLinksDataPerLinkTypeId(_izContext, relationshipTag, relationshi
       from: link.from,
       to: link.to
     };
+
+    if (link.requestProperties) {
+      linksData[linkTypeId].requestProperties = link.requestProperties
+    }
   }
 
   return linksData;

package/src/libs/s3Utils.js

@@ -60,7 +60,9 @@ async function getObjectS3Shared(param) {
   return object;
 }
 
-async function getSchemaByName(params) {
+
+
+async function getSchemaByName(params, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
   if (!params.schemaName || !params.getParams) {
     throw new NoRetryError(`getSchemaByName invalid parameters`);
   }
@@ -71,7 +73,7 @@ async function getSchemaByName(params) {
 
   // build params for getObjectS3
   let getDataParam = {
-    Bucket: OBJECT_SCHEMA_BUCKET_NAME,
+    Bucket: bucketName,
     Key: SCHEMA_NAME_PER_S3_PATH[params.schemaName](params.getParams)
   };