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

package/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-library-service-schemas",
-  "version": "1.0.58",
+  "version": "1.0.60",
   "description": "Schemas for the service and objects it controls",
   "main": "index.js",
   "scripts": {

package/src/GetObjectSchema.js

@@ -53,7 +53,7 @@ const {
 // const dynamodbSharedLib = require('@izara_project/izara-shared/src/DynamodbSharedLib');
 // const Logger = require('@izara_project/izara-core-library-logger')
 
-const { getObjectS3, headObjectS3, getSchemaByName } = require("./libs/s3Utils");
+const { getObjectS3, headObjectS3, getSchemaByNameWithCache } = require("./libs/s3Utils");
 const { generateObjectSchemaForCombineFieldNames } = require("./libs/UploadUseCase");
 
 const {
@@ -449,7 +449,7 @@ async function getObjSchemaS3(
   objType,
   getExtendObType = false
 ) {
-  return await getObjectSchemaS3Shared(getSchemaByName, objType, getExtendObType);
+  return await getObjectSchemaS3Shared(getSchemaByNameWithCache, objType, getExtendObType);
 }
 
 
@@ -477,7 +477,7 @@ const getObjSchemaS3WithCache = inMemoryCacheLib(
  */
 async function getObjSchemaS3WithHierarchy(_izContext, objType) {
   // return await getObjSchemaS3WithCache(_izContext, objType, true)
-  return await getObjSchemaWithHierarchy(getSchemaByName, objType)
+  return await getObjSchemaWithHierarchy(getSchemaByNameWithCache, objType)
 }
 
 /**
@@ -488,7 +488,7 @@ async function getObjSchemaS3WithHierarchy(_izContext, objType) {
  */
 async function getObjSchemaS3WithoutHierarchy(_izContext, objType) {
   // return await getObjSchemaS3WithCache(_izContext, objType, false)
-  return await getObjSchemaWithoutHierarchy(getSchemaByName, objType)
+  return await getObjSchemaWithoutHierarchy(getSchemaByNameWithCache, objType)
 }
 
 
@@ -598,7 +598,7 @@ function getLocalRelationshipSchemas(_izContext, relationshipTags, objSchemaPath
  * @returns {Promise<Object>}                 - reference relationship schema of objType
  */
 async function getRefObjectRelationship(_izContext, objType) {
-  return await getRefObjectRelationshipShared(getSchemaByName, objType)
+  return await getRefObjectRelationshipShared(getSchemaByNameWithCache, objType)
 }
 
 /**
@@ -628,7 +628,7 @@ const getRefObjectRelationshipWithCache = inMemoryCacheLib(
  */
 async function getRelationshipSchema(_izContext, relType) {
 
-  return await getRelationshipSchemaShared(getSchemaByName, relType)
+  return await getRelationshipSchemaShared(getSchemaByNameWithCache, relType)
 }
 
 
@@ -730,7 +730,7 @@ async function getObjectRelationship(
   overWriteBaseObjType,
 ) {
 
-  return await getObjectRelationshipShared(getSchemaByName, objType, specificRelTags, overWriteBaseObjType)
+  return await getObjectRelationshipShared(getSchemaByNameWithCache, objType, specificRelTags, overWriteBaseObjType)
 }
 
 
@@ -774,7 +774,7 @@ async function getRequiredOnCreateLinks(
     specificRelTags,
   });
 
-  return await getRequiredOnCreateLinksShared(getSchemaByName, objType, specificRelTags)
+  return await getRequiredOnCreateLinksShared(getSchemaByNameWithCache, objType, specificRelTags)
 }
 
 
@@ -849,7 +849,7 @@ async function getLinkConfigByLinkTypeId(_izContext, firstObjType, secondObjType
     direction
   });
 
-  return await getLinkConfigByLinkTypeIdShared(getSchemaByName, firstObjType, secondObjType, relType, direction);
+  return await getLinkConfigByLinkTypeIdShared(getSchemaByNameWithCache, firstObjType, secondObjType, relType, direction);
 }
 
 /**
@@ -881,7 +881,7 @@ const getLinkConfigByLinkTypeIdWithCache = inMemoryCacheLib(
  */
 async function mergeExtendObjSchema(_izContext, objectSchema) {
   // return mergedObjectSchema;
-  return await mergeExtendObjSchemaShared(getSchemaByName, objectSchema);
+  return await mergeExtendObjSchemaShared(getSchemaByNameWithCache, objectSchema);
 }
 
 

package/src/SharedUtils.js

@@ -17,6 +17,8 @@ along with this program.If not, see < http://www.gnu.org/licenses/>.
 
 'use strict';
 
+const hash = require('object-hash');
+
 const {
   validateGraphServerTags,
   mergeStorageResources,
@@ -97,6 +99,9 @@ async function _processNodeRelationships(
   const baseNode = isBase ? newLinkRelSchema.from : newLinkRelSchema.to;
   const otherNode = isBase ? newLinkRelSchema.to : newLinkRelSchema.from;
 
+  _izContext.logger.debug('baseNode:', baseNode);
+  _izContext.logger.debug('otherNode:', otherNode);
+
   // Check for existing relationships
   const existingObjRel = objectRelationshipsArray.find(objRel => (
     objRel.relType.relationshipTag === relType.relationshipTag &&
@@ -107,6 +112,8 @@ async function _processNodeRelationships(
     objRel.other.objType.objectType === otherNode.objType.objectType
   ));
 
+  _izContext.logger.debug('existingObjRel:', existingObjRel);
+
   let updatedRelationships = [];
 
   if (existingObjRel) {
@@ -178,6 +185,8 @@ async function _processNodeRelationships(
     updatedRelationships = [...objectRelationshipsArray, newRelationship];
   }
 
+
+
   // Update objectRelationships object
   if (objectRelationships[node.objType.objectType]) {
     objectRelationships[node.objType.objectType].objType = node.objType;
@@ -219,7 +228,7 @@ async function _processObjectLinksGroup(_izContext, relationshipTag, objectLinks
       _izContext.logger.error('Depth limit reached:', loopSetting.depth);
       return {
         success: false,
-        errorMessage: `relTag: ${relTypeTag} - Depth limit`
+        errorMessage: `relTag: ${relationshipTag} - Depth limit`
       };
     }
 
@@ -298,6 +307,8 @@ async function _processObjectLinksGroup(_izContext, relationshipTag, objectLinks
           link.to.objType.objectType === secondNode.objType.objectType
         ));
         _izContext.logger.debug('existingLink:', existingLink);
+
+
         if (existingLink) {
           // Create detailed property comparison for better debugging
           const propertyComparison = {
@@ -321,16 +332,6 @@ async function _processObjectLinksGroup(_izContext, relationshipTag, objectLinks
               requested: secondNode.requiredOnCreate,
               matches: existingLink.to.requiredOnCreate === secondNode.requiredOnCreate
             },
-            fromHandler: {
-              current: existingLink.from.handler,
-              requested: firstNode.handler,
-              matches: firstNode.handler === undefined || existingLink.from.handler === firstNode.handler
-            },
-            toHandler: {
-              current: existingLink.to.handler,
-              requested: secondNode.handler,
-              matches: secondNode.handler === undefined || existingLink.to.handler === secondNode.handler
-            },
             canDelete: {
               current: existingLink.canDelete,
               requested: canDelete,
@@ -381,7 +382,10 @@ async function _processObjectLinksGroup(_izContext, relationshipTag, objectLinks
           }
 
           // Update existing link
-          relationshipSchema.links = relationshipSchema.links.filter(link => link !== existingLink);
+          relationshipSchema.links = relationshipSchema.links.filter(link => {
+            _izContext.logger.debug('compare exists link:', link !== existingLink);
+            return link !== existingLink
+          });
 
           // Create updated link with merged tags
           newLinkRelSchema = {
@@ -394,13 +398,11 @@ async function _processObjectLinksGroup(_izContext, relationshipTag, objectLinks
               ...existingLink.from,
               linkType: firstNode.linkType,
               requiredOnCreate: firstNode.requiredOnCreate,
-              handler: firstNode.handler || existingLink.from.handler,
             },
             to: {
               ...existingLink.to,
               linkType: secondNode.linkType,
               requiredOnCreate: secondNode.requiredOnCreate,
-              handler: secondNode.handler || existingLink.to.handler
             },
             canDelete: canDelete
           };
@@ -411,13 +413,11 @@ async function _processObjectLinksGroup(_izContext, relationshipTag, objectLinks
             from: {
               objType: firstNode.objType,
               linkType: firstNode.linkType,
-              handler: firstNode.handler || false,
               requiredOnCreate: firstNode.requiredOnCreate,
             },
             to: {
               objType: secondNode.objType,
               linkType: secondNode.linkType,
-              handler: secondNode.handler || false,
               requiredOnCreate: secondNode.requiredOnCreate,
             },
             canDelete: canDelete
@@ -438,10 +438,10 @@ async function _processObjectLinksGroup(_izContext, relationshipTag, objectLinks
         // Build link object structure
         const link = {
           relType: {
-            storageResourceTags: storageResourceTags,
             relationshipTag: relType.relationshipTag,
             serviceTag: relType.serviceTag
           },
+          storageResourceTags: storageResourceTags,
           from: newLinkRelSchema.from,
           to: newLinkRelSchema.to,
           canDelete: newLinkRelSchema.canDelete,
@@ -546,7 +546,47 @@ async function _processObjectLinksGroup(_izContext, relationshipTag, objectLinks
         { depth: loopSetting.depth + 1 }
       )
     }
-    const objectRelationshipPromises = Object.values(objectRelationships).map(({ objType, relationships }) =>
+
+    //TODO: need fix bug that make duplicate relationship
+    // filter out duplicate relationships inside objectRelationships
+
+    let newObjectRelationships = {};
+
+    for (let [objectType, { objType, relationships }] of Object.entries(objectRelationships)) {
+      _izContext.logger.debug('objectRelationships length:', relationships.length);
+
+      if (!newObjectRelationships[objectType]) {
+        newObjectRelationships[objectType] = {
+          objType: objType,
+          relationships: []
+        };
+      }
+
+
+      let relationshipsHash = new Set()
+      let newRelationships = []
+
+      for (let relationship of relationships) {
+
+        if (Array.isArray(relationship.storageResourceTags)) {
+          relationship.storageResourceTags = relationship.storageResourceTags.sort();
+        }
+
+        if (!relationshipsHash.has(hash(relationship))) {
+          relationshipsHash.add(hash(relationship));
+
+          newRelationships.push(relationship);
+        }
+      }
+
+      newObjectRelationships[objectType].relationships = newRelationships
+      _izContext.logger.debug('newRelationships length:', newRelationships.length);
+    }
+
+    // _izContext.logger.debug('objectRelationships after modify: ', newObjectRelationships);
+
+
+    const objectRelationshipPromises = Object.values(newObjectRelationships).map(({ objType, relationships }) =>
       uploadObjectToS3(
         _izContext,
         UPLOAD_PATH_S3.objectRelationship(_izContext, objType),
@@ -557,6 +597,8 @@ async function _processObjectLinksGroup(_izContext, relationshipTag, objectLinks
     try {
       // TODO-Part: Upload new LinkTypeId
       _izContext.logger.debug('Uploading new LinkTypeId & ObjectRelationships...');
+
+
       const uploadPromises = [
         ...linkByLinkTypeIds.map(({ linkTypeId, link }) =>
           uploadObjectToS3(

package/src/UploadObjSchema.js

@@ -62,7 +62,6 @@ const {
   generateLinksDataPerLinkTypeId,
   groupRefObjectRelPerObjectType,
 
-  generateCreatedByLinks,
   refRelationshipPerObjectSchema
 } = require('./libs/UploadUseCase');
 
@@ -177,6 +176,9 @@ async function uploadObjectSchemaByUseCase(_izContext) {
 
   const allObjectRelationships = getAllLocalRelationshipSchema(_izContext)
   const allReferenceObjectRelationships = getAllLocalRefObjectRelationshipSchema(_izContext)
+  let refRelationshipPerObjectType = groupRefObjectRelPerObjectType(_izContext, allReferenceObjectRelationships);
+  _izContext.logger.debug("refRelationshipPerObjectType: ", refRelationshipPerObjectType);
+
 
   const lambdaFunctions = await getLambdaFunctionNames(_izContext);
   _izContext.logger.debug("lambdaFunctions: ", lambdaFunctions);
@@ -326,29 +328,29 @@ async function uploadObjectSchemaByUseCase(_izContext) {
     }
 
     // upload to refObjectRelationships for each objectType that have createBy at UserAccount Service and belongTo
-    if (allReferenceObjectRelationships.length) {
-      _izContext.logger.debug("have refRelationship add createdBy and belongTo(if have) to RefRelationship")
-      let refRelationshipData = groupRefObjectRelPerObjectType(_izContext, allReferenceObjectRelationships);
-
-      for (const [refRelObjType, refRelData] of Object.entries(refRelationshipData)) {
-        let refObjectTypeIndex = allObjectSchemasResult.fieldLookup[refRelObjType];
-        Object.assign(refRelData, await refRelationshipPerObjectSchema(_izContext, allObjectSchema[refObjectTypeIndex]));
+    let existsRefObjectRel = refRelationshipPerObjectType[objSchema.objectType];
+    if (existsRefObjectRel) {
+      Object.assign(existsRefObjectRel, await refRelationshipPerObjectSchema(_izContext, objSchema));
 
-        uploadList.push(
-          uploadObjectToS3(
-            _izContext,
-            UPLOAD_PATH_S3.refObjectRelationship(_izContext,
-              {
-                objectType: refRelObjType,
-                serviceTag: process.env.iz_serviceTag
-              }
-            ),
-            refRelData
-          )
+      uploadList.push(
+        uploadObjectToS3(
+          _izContext,
+          UPLOAD_PATH_S3.refObjectRelationship(_izContext,
+            {
+              objectType: objSchema.objectType,
+              serviceTag: process.env.iz_serviceTag
+            }
+          ),
+          existsRefObjectRel
         )
-      }
+      )
     } else {
-      _izContext.logger.debug("not have refRelationship add createdBy and belongTo(if have) to RefRelationship")
+      // add new rule if objectType is not have storageType graph not upload to refObjectRelationships
+      if (!objSchema.storageResources || !Object.values(objSchema.storageResources)
+        .some(storageResource => storageResource.storageType === STORAGE_TYPES.graph)) {
+        continue;
+      }
+
       uploadList.push(
         uploadObjectToS3(
           _izContext,
@@ -377,8 +379,10 @@ async function uploadObjectSchemaByUseCase(_izContext) {
 
   let belongsTo = [];
   let createdBys = [];
+  let translations = [];
 
   // invoke AddBelongTo in userAccount to upload belongTo Relationships
+  // prepare params for invoke AddLinkToTranslationLinksHdrInv
   for (const objectSchema of allObjectSchema) {
     let graphServerTags = new Set();
 
@@ -412,6 +416,18 @@ async function uploadObjectSchemaByUseCase(_izContext) {
         }
       )
     };
+
+    if (objectSchema?.addOnDataStructure?.length) {
+      if (objectSchema.addOnDataStructure.some(addOnData => addOnData.type === "translation") && graphServerTags.size) {
+        translations.push({
+          objType: {
+            objectType: objectSchema.objectType,
+            serviceTag: process.env.iz_serviceTag
+          },
+          graphServerTags: [...graphServerTags]
+        })
+      }
+    }
   };
 
 
@@ -434,14 +450,14 @@ async function uploadObjectSchemaByUseCase(_izContext) {
   }
 
 
-  // uploadList.push(
-  //   uploadObjectToS3(
-  //     _izContext,
-  //     UPLOAD_PATH_S3.objectListCreate(_izContext, process.env.iz_serviceTag),
-  //     objectTypesForCreate
-  //   )
-  // );
-
+  if (translations.length && process.env.iz_serviceTag !== "Translations") {
+    await lambda.invokeSync(_izContext,
+      await lambdaSharedLib.lambdaFunctionName(_izContext, "AddLinkToTranslationLinksHdrInv", "Translations"),
+      {
+        linksData: translations
+      }
+    )
+  }
 
   // ------------  Upload Relationship ------------------
   if (allObjectRelationships) {

package/src/Utils.js

@@ -389,6 +389,7 @@ function validateRelationshipSchema(_izContext, relationshipSchema) {
     }
 
   } else {
+    _izContext.logger.debug("validateStatus: ", validateStatus.error);
     validateStatus.error = `Relationship:${relationshipTag}, ` + validateStatus.error
     return [false, validateStatus.error.split(",")]
   }

package/src/ValidatorSchema.js

@@ -930,6 +930,8 @@ async function validateLocalSchema(_izContext, schemasPath, serviceConfigPath) {
     const allObjectRelationships = getAllLocalRelationshipSchema(_izContext, schemasPath);
     const allReferenceObjectRelationships = getAllLocalRefObjectRelationshipSchema(_izContext, schemasPath);
     const allFlowSchemas = await getAllLocalFlowSchemas(_izContext, schemasPath).then(res => res.records);
+    console.log("allFlowSchemas", allFlowSchemas);
+
 
     // validate all schema
     for (const objSchema of allObjectSchema) {

package/src/libs/SharedUtilsLibs.js

@@ -104,7 +104,7 @@ function validateGraphServerTags(graphServerTags, relationshipSchema, firstNodeO
 
   // Get all unique graphServerTags from schemas
   const getGraphTags = schema =>
-    new Set(Object.values(schema.storageResources || {})
+    new Set(Object.values(schema?.storageResources || {})
       .filter(resource => resource.storageType !== 'dynamoDB')
       .map(resource => {
         if (resource.storageType === 'graph') {

package/src/libs/UploadUseCase.js

@@ -427,114 +427,54 @@ function groupRefObjectRelPerObjectType(_izContext, allRefObjectRelationships) {
   return refRelPerObjectType;
 }
 
-/**
- * return new createdBy links of service UserAccount
- *
- * @param {object} _izContext
- * @param {object[]} objectTypes  - objectTypes that need to add in createdByLink
- * @returns
- */
-async function generateCreatedByLinks(_izContext, addObjectTypes) {
-
-  // modify createdBy relSchema
-  const relTagPath = UPLOAD_PATH_S3.relationshipTag(
-    _izContext,
-    {
-      serviceTag: "UserAccount",
-      relationshipTag: "createdBy"
-    },
-  );
-
-  const getObjRelPathParam = {
-    Bucket: OBJECT_SCHEMA_BUCKET_NAME,
-    Key: relTagPath
-  };
-
-  // let createdByRelSchema = await s3.getObject(getObjRelPathParam).promise()
-  //   .catch(error => {
-  //     if (error.code === "NoSuchKey") {
-  //       return {}
-  //     } else {
-  //       _izContext.logger.error(error);
-  //       throw new NoRetryError(error);
-  //     }
-  //   });
-
-
-  let [createdByRelSchema, s3Response] = await getObjectS3(_izContext, getObjRelPathParam) || {};
-
-
-
-  _izContext.logger.debug("createdByRelSchema ETag: ", s3Response.ETag)
-  _izContext.logger.debug("createdByRelSchema: ", createdByRelSchema)
-
-  // let createdByRelSchemaObj = createdByRelSchema.Body ? JSON.parse(createdByRelSchema.Body.toString('utf-8')) : null;
+async function refRelationshipPerObjectSchema(_izContext, objSchema) {
+  _izContext.logger.debug('refObjectRelationshipCreate Libs:: ', objSchema)
 
+  let refObjectRel = {};
 
-  if (createdByRelSchema?.links?.length) {
 
-    let newLinks = [];
-    for (const linkData of createdByRelSchema.links) {
-      if (linkData.from.objType.serviceTag !== process.env.iz_serviceTag) {
-        newLinks.push(linkData)
+  if (objSchema.hasOwnProperty("belongTo")) {
+    Object.assign(
+      refObjectRel,
+      {
+        "createdBy": {
+          relationshipServiceTag: "UserAccount"
+        },
+        "belongTo": {
+          relationshipServiceTag: "UserAccount"
+        }
       }
-    }
+    )
+  } else {
+    Object.assign(
+      refObjectRel,
+      {
+        "createdBy": {
+          relationshipServiceTag: "UserAccount"
+        }
+      }
+    )
+  }
 
-    // add link for local objectType
-    for (const localObjType of addObjectTypes) {
-      newLinks.push(
-        {
-          storageResourceTags: Object.keys(createdByRelSchema.storageResources),
-          from: {
-            objType: { serviceTag: process.env.iz_serviceTag, objectType: localObjType },
-            linkType: 'many',
-            handler: true,
-            requiredOnCreate: false
-          },
-          to: {
-            objType: { serviceTag: 'UserAccount', objectType: 'user' },
-            linkType: 'one',
-            handler: false,
-            requiredOnCreate: false
-          }
+  if (objSchema?.addOnDataStructure?.length && objSchema.addOnDataStructure.some(addOn => addOn.type === "translation")) {
+    Object.assign(
+      refObjectRel,
+      {
+        hasTranslationLink: {
+          relationshipServiceTag: "Translations",
         },
-      )
-    }
-
-    _izContext.logger.debug("result newLinks: ", newLinks);
-
-    // new createdBy relationship schema
-    Object.assign(createdByRelSchema, { links: newLinks });
-
-    // check ETag before return
-    const createdByRelHead = await headObjectS3(_izContext, getObjRelPathParam);
-    _izContext.logger.debug("createdByRelHead: ", createdByRelHead);
-
-    if (createdByRelHead.ETag === s3Response.ETag) {
-      return createdByRelSchema;
-    }
+        currentTranslationLink: {
+          relationshipServiceTag: "Translations",
+        },
+        defaultTranslationLink: {
+          relationshipServiceTag: "Translations",
+        },
+      }
+    )
   }
 
-}
 
-async function refRelationshipPerObjectSchema(_izContext, objSchema) {
-  _izContext.logger.debug('refObjectRelationshipCreate Libs:: ', objSchema)
-  if (objSchema.hasOwnProperty("belongTo")) {
-    return {
-      "createdBy": {
-        relationshipServiceTag: "UserAccount"
-      },
-      "belongTo": {
-        relationshipServiceTag: "UserAccount"
-      }
-    }
-  } else {
-    return {
-      "createdBy": {
-        relationshipServiceTag: "UserAccount"
-      }
-    }
-  }
+  return refObjectRel;
 }
 
 
@@ -550,6 +490,5 @@ module.exports = {
   DEFAULT_REL_ID_SETTING,
 
   // external service
-  generateCreatedByLinks,
   refRelationshipPerObjectSchema
 };

package/src/libs/s3Utils.js

@@ -28,7 +28,9 @@ const {
   PutObjectCommand,
 } = require("@aws-sdk/client-s3");
 
-const { NoRetryError } = require('@izara_project/izara-core-library-core');
+const hash = require('object-hash');
+
+const { NoRetryError, inMemoryCacheLib } = require('@izara_project/izara-core-library-core');
 const { SCHEMA_NAME_PER_S3_PATH } = require('@izara_project/izara-shared-service-schemas').consts;
 const { OBJECT_SCHEMA_BUCKET_NAME } = require('../Consts');
 
@@ -80,6 +82,21 @@ async function getSchemaByName(params) {
   return objectSchema;
 }
 
+/**
+ * Caches the getSchemaByName function
+ *
+ * @see  {@link getSchemaByName}
+ */
+const getSchemaByNameWithCache = inMemoryCacheLib(
+  getSchemaByName, // fn
+  { // setting
+    max: 100, maxAge: 86400000, promise: true, profileName: 'getSchemaByName',
+    normalizer: function (args) {
+      return hash([args[0]])
+    }
+  }
+)
+
 
 async function getObjectS3(_izContext, param) {
   return await getObjectS3Shared(param);
@@ -131,5 +148,6 @@ module.exports = {
   deleteObject,
   putObjectS3,
   deleteObjects,
-  getSchemaByName
+  getSchemaByName,
+  getSchemaByNameWithCache
 }