@izara_project/izara-core-library-service-schemas 1.0.100 → 1.0.102

package/src/GetObjectSchema.js

@@ -18,64 +18,22 @@ along with this program.If not, see < http://www.gnu.org/licenses/>.
 'use strict';
 
 
-const glob = require('glob')
-const path = require('path')
-const lodash = require('lodash');
-const hash = require('@izara_project/izara-shared-core').objectHash;
-
-const sharedServiceSchema = require("@izara_project/izara-shared-service-schemas");
-const {
-  getObjSchemaS3: getObjectSchemaS3Shared,
-  getObjSchemaWithHierarchy,
-  getObjSchemaWithoutHierarchy,
-  mergeExtendObjSchema: mergeExtendObjSchemaShared,
-  // recursiveMergeExtendObjSchema: recursiveMergeExtendObjSchemaShared,
-  getRefObjectRelationship: getRefObjectRelationshipShared,
-  getRelationshipSchema: getRelationshipSchemaShared,
-  getObjectRelationship: getObjectRelationshipShared,
-  getRequiredOnCreateLinks: getRequiredOnCreateLinksShared,
-  getLinkConfigByLinkTypeId: getLinkConfigByLinkTypeIdShared,
-  getObjTypeHierarchy: getObjTypeHierarchyShared,
-  getObjectSchemaForCreate: getObjectSchemaForCreateShared,
-  getObjectSchemaForUpdate: getObjectSchemaForUpdateShared,
-  getFlowSchemaS3: getFlowSchemaS3Shared
-} = sharedServiceSchema.getObjectSchema;
-const { validateObjType, validateFlowType } = sharedServiceSchema.validateObjType;
-const {
-  basicFieldNameSchema,
-  basicFieldNameSchemaForCombineFieldName
-} = sharedServiceSchema.basicValidatorSchema;
-
-const {
-  inMemoryCacheLib,
-  NoRetryError,
-  validator: { validateObject },
-} = require('@izara_project/izara-core-library-core');
-
-
-// const dynamodbSharedLib = require('@izara_project/izara-shared/src/DynamodbSharedLib');
-// const Logger = require('@izara_project/izara-core-library-logger')
-
-const { getObjectS3, headObjectS3, getSchemaByNameWithCache, getSchemaByName } = require("./libs/s3Utils");
-const { generateObjectSchemaForCombineFieldNames } = require("./libs/UploadUseCase");
-
-const {
-  LOCAL_OBJECT_SCHEMA_PATH,
-
-  UPLOAD_PATH_S3,
-
-  LOCAL_FILENAME,
-  STORAGE_TYPES
-} = require('./Consts')
-
-const {
-  findLinkByObjTypeV2,
-  getUsedFieldNamesOfIdentifiers,
-  createLinkTypeId
-} = require('./Utils');
-
-
-const { listLambdaFunctions } = require('./libs/LambdaUtils');
+import { glob } from 'glob';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import lodash from 'lodash';
+import { objectHash as hash } from '@izara_project/izara-shared-core';
+import { getObjectSchema, validateObjType } from "@izara_project/izara-shared-service-schemas";
+import { inMemoryCacheLib, NoRetryError } from '@izara_project/izara-core-library-core';
+
+
+// import dynamodbSharedLib from ('@izara_project/izara-shared/src/DynamodbSharedLib');
+// import Logger from ('@izara_project/izara-core-library-logger')
+
+import s3Utils from "./libs/s3Utils.js";
+import uploadUseCase from "./libs/UploadUseCase.js"
+import consts from './Consts.js'
+import lambdaUtils from './libs/LambdaUtils.js';
 
 /**
  * get array of data from specific path in local environment
@@ -88,7 +46,7 @@ const { listLambdaFunctions } = require('./libs/LambdaUtils');
  * @param {Boolean} setting.onNotFoundError - optional, default = false -- if true will throw error when not find any file
  * @returns                                 - array of data
  */
-function getDataFromPath(
+async function getDataFromPath(
   _izContext,
   fileName,
   fileStoragePath,
@@ -112,7 +70,7 @@ function getDataFromPath(
   }
 
   // list exists file path from fileStoragePath path
-  const allFilePath = glob.sync(`**/${fileName}`, { cwd: fileStoragePath, dot: true });
+  const allFilePath = await glob(`**/${fileName}`, { cwd: fileStoragePath, dot: true });
 
   // validate fileLimit
   if (fileLimit && allFilePath.length > fileLimit) {
@@ -120,8 +78,13 @@ function getDataFromPath(
   }
 
   if (allFilePath.length > 0) {
-    const allFileData = allFilePath.map(file => require(path.join(fileStoragePath, file)));
-    return allFileData;
+    // const allFileData = allFilePath.map(file => require(path.join(fileStoragePath, file)));
+    const allFileData = await Promise.all(allFilePath.map(async (file) => {
+      let data = await import(pathToFileURL(path.join(fileStoragePath, file)).href);
+      data = data.default;
+      return data;
+    }))
+    return allFileData.flat();
   } else {
 
     if (onNotFoundError === true) {
@@ -132,7 +95,7 @@ function getDataFromPath(
   }
 }
 
-// currenly not use
+// currently not use
 // /**
 //  * get data from file ObjectTypes.js depend on path
 //  *
@@ -144,7 +107,7 @@ function getDataFromPath(
 
 //   const objectTypesData = getDataFromPath(
 //     _izContext,
-//     LOCAL_FILENAME.OBJECT_TYPES,
+//     consts.LOCAL_FILENAME.OBJECT_TYPES,
 //     objSchemaPath,
 //     {
 //       fileLimit: 1,
@@ -165,7 +128,7 @@ function getDataFromPath(
  * @param {boolean} [getExtendObType = false]         Optional default = false , If = true will get extendObjectType before return
  * @returns {Promise<object>}                                  Return object schema of objectTypes
  */
-async function getLocalObjectSchemas(_izContext, objectTypes, objSchemaPath = LOCAL_OBJECT_SCHEMA_PATH, getExtendObType = false) {
+async function getLocalObjectSchemas(_izContext, objectTypes, objSchemaPath = consts.LOCAL_OBJECT_SCHEMA_PATH, getExtendObType = false) {
   let errorsFound = [];
   // validate objectTypes
   if (!objectTypes) {
@@ -211,12 +174,10 @@ async function getLocalObjectSchemas(_izContext, objectTypes, objSchemaPath = LO
     // returnValue.fieldLookup[objectType] = null;
   }
 
-  let allObjectSchemas = lodash.cloneDeep(getDataFromPath(_izContext, LOCAL_FILENAME.OBJECT_SCHEMA, objSchemaPath)
-    .flat()
+  let allObjectSchemas = lodash.cloneDeep((await getDataFromPath(_izContext, consts.LOCAL_FILENAME.OBJECT_SCHEMA, objSchemaPath)).flat()
     .filter(schema => filteredObjectTypes.includes(schema.objectType))
   );
 
-
   // add extendObjectType before assign to returnValue object
   if (getExtendObType) {
     await Promise.all(
@@ -259,7 +220,7 @@ async function getLocalObjectSchemas(_izContext, objectTypes, objSchemaPath = LO
  *
  * @see  {@link getLocalObjectSchemas}
  */
-async function getLocalObjectSchemasWithHierarchy(_izContext, objectTypes, objSchemaPath = LOCAL_OBJECT_SCHEMA_PATH) {
+async function getLocalObjectSchemasWithHierarchy(_izContext, objectTypes, objSchemaPath = consts.LOCAL_OBJECT_SCHEMA_PATH) {
   return await getLocalObjectSchemas(_izContext, objectTypes, objSchemaPath, true)
 }
 
@@ -269,7 +230,7 @@ async function getLocalObjectSchemasWithHierarchy(_izContext, objectTypes, objSc
  *
  * @see  {@link getLocalObjectSchemas}
  */
-async function getLocalObjectSchemasWithoutHierarchy(_izContext, objectTypes, objSchemaPath = LOCAL_OBJECT_SCHEMA_PATH) {
+async function getLocalObjectSchemasWithoutHierarchy(_izContext, objectTypes, objSchemaPath = consts.LOCAL_OBJECT_SCHEMA_PATH) {
   return await getLocalObjectSchemas(_izContext, objectTypes, objSchemaPath, false)
 }
 
@@ -282,7 +243,7 @@ async function getLocalObjectSchemasWithoutHierarchy(_izContext, objectTypes, ob
  * @param {boolean} [getExtendObType = false]         - Optional default = false , If = true will get extendObjectType before return
  * @returns {Promise<object>}                         - Return all objectSchema from local service
  */
-async function getAllLocalObjectSchemas(_izContext, objSchemaPath = LOCAL_OBJECT_SCHEMA_PATH, getExtendObType = false) {
+async function getAllLocalObjectSchemas(_izContext, objSchemaPath = consts.LOCAL_OBJECT_SCHEMA_PATH, getExtendObType = false) {
 
   //initial return value
   let returnValue = {
@@ -293,11 +254,9 @@ async function getAllLocalObjectSchemas(_izContext, objSchemaPath = LOCAL_OBJECT
 
   // const objectTypeList = getObjectTypes(_izContext, objSchemaPath)
 
-  const allObjectSchemas = lodash.cloneDeep(getDataFromPath(_izContext, LOCAL_FILENAME.OBJECT_SCHEMA, objSchemaPath)
-    .flat()
+  const allObjectSchemas = lodash.cloneDeep((await getDataFromPath(_izContext, consts.LOCAL_FILENAME.OBJECT_SCHEMA, objSchemaPath)).flat()
     // .filter(schema => objectTypeList.includes(schema.objectType))
   );
-
   // check objectType that not found in ObjectFieldSchema.js
   // const remainingObjectTypes = objectTypeList.filter(objectType => !allObjectSchemas.some(schema => schema.objectType === objectType));
 
@@ -349,7 +308,7 @@ async function getAllLocalObjectSchemas(_izContext, objSchemaPath = LOCAL_OBJECT
  *
  * @see  {@link getAllLocalObjectSchemas}
  */
-async function getAllLocalObjectSchemasWithHierarchy(_izContext, objSchemaPath = LOCAL_OBJECT_SCHEMA_PATH) {
+async function getAllLocalObjectSchemasWithHierarchy(_izContext, objSchemaPath = consts.LOCAL_OBJECT_SCHEMA_PATH) {
   return await getAllLocalObjectSchemas(_izContext, objSchemaPath, true)
 }
 
@@ -358,7 +317,7 @@ async function getAllLocalObjectSchemasWithHierarchy(_izContext, objSchemaPath =
  *
  * @see  {@link getAllLocalObjectSchemas}
  */
-async function getAllLocalObjectSchemasWithoutHierarchy(_izContext, objSchemaPath = LOCAL_OBJECT_SCHEMA_PATH) {
+async function getAllLocalObjectSchemasWithoutHierarchy(_izContext, objSchemaPath = consts.LOCAL_OBJECT_SCHEMA_PATH) {
   return await getAllLocalObjectSchemas(_izContext, objSchemaPath, false)
 }
 
@@ -370,7 +329,7 @@ async function getLambdaFunctionNames(_izContext) {
   try {
     _izContext.logger.debug("-- function getLambdaFunctionNames --");
 
-    const LambdaFunctions = getDataFromPath(_izContext, LOCAL_FILENAME.LAMBDA_FUNCTIONS, LOCAL_OBJECT_SCHEMA_PATH, {
+    const LambdaFunctions = await getDataFromPath(_izContext, consts.LOCAL_FILENAME.LAMBDA_FUNCTIONS, consts.LOCAL_OBJECT_SCHEMA_PATH, {
       fileLimit: 1
     })[0];
     _izContext.logger.debug("LambdaFunctions: ", LambdaFunctions);
@@ -383,7 +342,7 @@ async function getLambdaFunctionNames(_izContext) {
 
     try {
       do {
-        const { Functions, NextMarker } = await listLambdaFunctions(_izContext, { Marker: marker });
+        const { Functions, NextMarker } = await lambdaUtils(_izContext, { Marker: marker });
 
         const filteredNames = Functions
           .map(func => func.FunctionName)
@@ -471,7 +430,7 @@ async function getObjSchemaS3(
   getExtendObType = false
 ) {
 
-  return await getObjectSchemaS3Shared(getSchemaByNameWithCache, objType, process.env.iz_serviceSchemaBucketName, getExtendObType).then(res => {
+  return await getObjectSchema.getObjSchemaS3(s3Utils.getSchemaByNameWithCache, objType, process.env.iz_serviceSchemaBucketName, getExtendObType).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
       throw new NoRetryError(res.errorsFound.join(","))
     } else {
@@ -505,7 +464,7 @@ const getObjSchemaS3WithCache = inMemoryCacheLib(
  */
 async function getObjSchemaS3WithHierarchy(_izContext, objType, bucketName = process.env.iz_serviceSchemaBucketName) {
   // return await getObjSchemaS3WithCache(_izContext, objType, true)
-  return await getObjSchemaWithHierarchy(getSchemaByNameWithCache, objType, bucketName).then(res => {
+  return await getObjectSchema.getObjSchemaWithHierarchy(s3Utils.getSchemaByNameWithCache, objType, bucketName).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
       throw new NoRetryError(res.errorsFound.join(","))
     } else {
@@ -522,7 +481,7 @@ async function getObjSchemaS3WithHierarchy(_izContext, objType, bucketName = pro
  */
 async function getObjSchemaS3WithoutHierarchy(_izContext, objType, bucketName = process.env.iz_serviceSchemaBucketName) {
   // return await getObjSchemaS3WithCache(_izContext, objType, false)
-  return await getObjSchemaWithoutHierarchy(getSchemaByNameWithCache, objType, bucketName).then(res => {
+  return await getObjectSchema.getObjSchemaWithoutHierarchy(s3Utils.getSchemaByNameWithCache, objType, bucketName).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
       throw new NoRetryError(res.errorsFound.join(","))
     } else {
@@ -544,7 +503,7 @@ async function getObjSchemaS3WithoutHierarchy(_izContext, objType, bucketName =
 async function getObjectSchemaCombineFieldNames(_izContext, objType) {
 
   const objSchema = await getObjSchemaS3WithHierarchy(_izContext, objType);
-  const combinedSchema = generateObjectSchemaForCombineFieldNames(_izContext, objSchema);
+  const combinedSchema = uploadUseCase.generateObjectSchemaForCombineFieldNames(_izContext, objSchema);
   return combinedSchema
 }
 
@@ -580,7 +539,7 @@ const getObjectSchemaCombineFieldNamesWithCache = inMemoryCacheLib(
  * @param {String} [objSchemaPath]                    - Optional default = './src/schemas', need objSchemaPath if use in local machine
  * @returns {Object}                                  - specific relationship schema
  */
-function getLocalRelationshipSchemas(_izContext, relationshipTags, objSchemaPath = LOCAL_OBJECT_SCHEMA_PATH) {
+async function getLocalRelationshipSchemas(_izContext, relationshipTags, objSchemaPath = consts.LOCAL_OBJECT_SCHEMA_PATH) {
 
   // validate objectTypes
   if (!relationshipTags) {
@@ -596,9 +555,9 @@ function getLocalRelationshipSchemas(_izContext, relationshipTags, objSchemaPath
   }
 
 
-  const objectRelationshipDatas = getDataFromPath(
+  const objectRelationshipDatas = await getDataFromPath(
     _izContext,
-    LOCAL_FILENAME.OBJECT_RELATIONSHIPS,
+    consts.LOCAL_FILENAME.OBJECT_RELATIONSHIPS,
     objSchemaPath,
     {
       fileLimit: 1,
@@ -639,7 +598,7 @@ function getLocalRelationshipSchemas(_izContext, relationshipTags, objSchemaPath
  * @returns {Promise<Object>}                 - reference relationship schema of objType
  */
 async function getRefObjectRelationship(_izContext, objType, bucketName = process.env.iz_serviceSchemaBucketName) {
-  return await getRefObjectRelationshipShared(getSchemaByNameWithCache, objType, bucketName).then(res => {
+  return await getObjectSchema.getRefObjectRelationship(s3Utils.getSchemaByNameWithCache, objType, bucketName).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
       throw new NoRetryError(res.errorsFound.join(","))
     } else {
@@ -674,7 +633,7 @@ const getRefObjectRelationshipWithCache = inMemoryCacheLib(
  *
  */
 async function getRelationshipSchema(_izContext, relType, bucketName = process.env.iz_serviceSchemaBucketName) {
-  return await getRelationshipSchemaShared(getSchemaByNameWithCache, relType, bucketName).then(res => {
+  return await getObjectSchema.getRelationshipSchema(s3Utils.getSchemaByNameWithCache, relType, bucketName).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
       throw new NoRetryError(res.errorsFound.join(","))
     } else {
@@ -717,13 +676,13 @@ async function getRelationshipServiceTag(_izContext, relationshipTag, objType) {
     objType,
   });
 
-  const validateObjTypeResult = validateObjType(objType);
+  const validateObjTypeResult = validateObjType.validateObjType(objType);
   if (validateObjTypeResult.errorsFound.length > 0) {
     _izContext.logger.error("getRelationshipServiceTag: Invalid objType: ", validateObjTypeResult.errorsFound);
     throw new NoRetryError(`getRelationshipServiceTag: Invalid objType: ${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
   }
 
-  const relTagPath = UPLOAD_PATH_S3.relationshipTag(
+  const relTagPath = consts.UPLOAD_PATH_S3.relationshipTag(
     _izContext,
     { // relType
       serviceTag: objType.serviceTag,
@@ -731,7 +690,7 @@ async function getRelationshipServiceTag(_izContext, relationshipTag, objType) {
     }
   );
 
-  let relSchemaHeadData = await headObjectS3(_izContext, { Bucket: process.env.iz_serviceSchemaBucketName, Key: relTagPath })
+  let relSchemaHeadData = await s3Util.headObjectS3(_izContext, { Bucket: process.env.iz_serviceSchemaBucketName, Key: relTagPath })
 
   // _izContext.logger.debug("relSchemaHeadData: ", relSchemaHeadData);
 
@@ -787,7 +746,7 @@ async function getObjectRelationship(
   overWriteBaseObjType,
 ) {
 
-  return await getObjectRelationshipShared(getSchemaByNameWithCache, objType, specificRelTags, overWriteBaseObjType, process.env.iz_serviceSchemaBucketName).then(res => {
+  return await getObjectSchema.getObjectRelationship(s3Utils.getSchemaByNameWithCache, objType, specificRelTags, overWriteBaseObjType, process.env.iz_serviceSchemaBucketName).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
       throw new NoRetryError(res.errorsFound.join(","))
     } else {
@@ -837,7 +796,7 @@ async function getRequiredOnCreateLinks(
     specificRelTags,
   });
 
-  return await getRequiredOnCreateLinksShared(getSchemaByNameWithCache, objType, specificRelTags, process.env.iz_serviceSchemaBucketName).then(res => {
+  return await getObjectSchema.getRequiredOnCreateLinks(s3Utils.getSchemaByNameWithCache, objType, specificRelTags, process.env.iz_serviceSchemaBucketName).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
       throw new NoRetryError(res.errorsFound.join(","))
     } else {
@@ -920,7 +879,7 @@ async function getLinkConfigByLinkTypeId(_izContext, firstObjType, secondObjType
     settings,
   });
 
-  return await getLinkConfigByLinkTypeIdShared(getSchemaByNameWithCache, firstObjType, secondObjType, relType, direction, settings, process.env.iz_serviceSchemaBucketName).then(res => {
+  return await getObjectSchema.getLinkConfigByLinkTypeId(s3Utils.getSchemaByNameWithCache, firstObjType, secondObjType, relType, direction, settings, process.env.iz_serviceSchemaBucketName).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
       throw new NoRetryError(res.errorsFound.join(","))
     } else {
@@ -957,7 +916,7 @@ const getLinkConfigByLinkTypeIdWithCache = inMemoryCacheLib(
  * @returns
  */
 async function mergeExtendObjSchema(_izContext, objectSchema) {
-  let mergedObjectSchema = await mergeExtendObjSchemaShared(getSchemaByNameWithCache, objectSchema, process.env.iz_serviceSchemaBucketName).then(res => {
+  let mergedObjectSchema = await getObjectSchema.mergeExtendObjSchema(s3Utils.getSchemaByNameWithCache, objectSchema, process.env.iz_serviceSchemaBucketName).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
       throw new NoRetryError(`objectSchema.objectType: ${objectSchema.objectType} ${res.errorsFound}`)
     } else {
@@ -968,14 +927,14 @@ async function mergeExtendObjSchema(_izContext, objectSchema) {
 }
 
 
-async function getAllLocalFlowSchemas(_izContext, flowSchemaPath = LOCAL_OBJECT_SCHEMA_PATH) {
+async function getAllLocalFlowSchemas(_izContext, flowSchemaPath = consts.LOCAL_OBJECT_SCHEMA_PATH) {
   // initial return Value
   let returnValue = {
     records: [],
     fieldLookup: {}
   }
 
-  const allFlowSchemas = lodash.cloneDeep(getDataFromPath(_izContext, LOCAL_FILENAME.FLOW_SCHEMA, flowSchemaPath).flat());
+  const allFlowSchemas = lodash.cloneDeep((await getDataFromPath(_izContext, consts.LOCAL_FILENAME.FLOW_SCHEMA, flowSchemaPath)).flat());
   _izContext.logger.debug("allFlowSchemas::", allFlowSchemas)
   for (let [idx, flowSchema] of allFlowSchemas.entries()) {
     if (!returnValue.fieldLookup.hasOwnProperty(flowSchema.flowTag)) {
@@ -989,7 +948,7 @@ async function getAllLocalFlowSchemas(_izContext, flowSchemaPath = LOCAL_OBJECT_
   return returnValue
 }
 
-async function getLocalFlowSchemas(_izContext, flowTags, flowSchemaPath = LOCAL_OBJECT_SCHEMA_PATH) {
+async function getLocalFlowSchemas(_izContext, flowTags, flowSchemaPath = consts.LOCAL_OBJECT_SCHEMA_PATH) {
   if (!flowTags) {
     throw new NoRetryError("required flowTags");
   }
@@ -1016,8 +975,7 @@ async function getLocalFlowSchemas(_izContext, flowTags, flowSchemaPath = LOCAL_
     filteredFlowTags.push(flowTag)
   }
 
-  const filterFlowSchemas = lodash.cloneDeep(getDataFromPath(_izContext, LOCAL_FILENAME.FLOW_SCHEMA, flowSchemaPath)
-    .flat()
+  const filterFlowSchemas = lodash.cloneDeep((await getDataFromPath(_izContext, consts.LOCAL_FILENAME.FLOW_SCHEMA, flowSchemaPath)).flat()
     .filter(schema => filteredFlowTags.includes(schema.flowTag))
   );
   _izContext.logger.debug("filterFlowSchemas::", filterFlowSchemas)
@@ -1048,7 +1006,7 @@ async function getFlowSchemaS3(
   flowType,
 ) {
 
-  return await getFlowSchemaS3Shared(getSchemaByNameWithCache, flowType, process.env.iz_serviceSchemaBucketName).then(res => {
+  return await getObjectSchema.getFlowSchemaS3(s3Utils.getSchemaByNameWithCache, flowType, process.env.iz_serviceSchemaBucketName).then(res => {
     if (res.errorsFound.length) {
       throw new NoRetryError(res.errorsFound.join(","))
     } else {
@@ -1072,20 +1030,16 @@ const getFlowSchemaS3WithCache = inMemoryCacheLib(
   }
 )
 
-function getAllLocalRelationshipSchema(_izContext, objSchemaPath = LOCAL_OBJECT_SCHEMA_PATH) {
+async function getAllLocalRelationshipSchema(_izContext, objSchemaPath = consts.LOCAL_OBJECT_SCHEMA_PATH) {
 
-  const allObjectSchemas = lodash.cloneDeep(getDataFromPath(_izContext, LOCAL_FILENAME.OBJECT_RELATIONSHIPS, objSchemaPath)
-    .flat()
-  );
+  const allObjectSchemas = lodash.cloneDeep((await getDataFromPath(_izContext, consts.LOCAL_FILENAME.OBJECT_RELATIONSHIPS, objSchemaPath)).flat());
 
   return allObjectSchemas
 }
 
-function getAllLocalRefObjectRelationshipSchema(_izContext, objSchemaPath = LOCAL_OBJECT_SCHEMA_PATH) {
+async function getAllLocalRefObjectRelationshipSchema(_izContext, objSchemaPath = consts.LOCAL_OBJECT_SCHEMA_PATH) {
 
-  const allRefObjectRelationshipSchemas = lodash.cloneDeep(getDataFromPath(_izContext, LOCAL_FILENAME.REFERENCE_OBJECT_RELATIONSHIPS, objSchemaPath)
-    .flat()
-  );
+  const allRefObjectRelationshipSchemas = lodash.cloneDeep((await getDataFromPath(_izContext, consts.LOCAL_FILENAME.REFERENCE_OBJECT_RELATIONSHIPS, objSchemaPath)).flat());
 
   return allRefObjectRelationshipSchemas
 
@@ -1101,7 +1055,7 @@ function getAllLocalRefObjectRelationshipSchema(_izContext, objSchemaPath = LOCA
  * @returns
  */
 async function getObjTypeHierarchy(_izContext, objType) {
-  return await getObjTypeHierarchyShared(getSchemaByNameWithCache, objType, objType, process.env.iz_serviceSchemaBucketName);
+  return await getObjectSchema.getObjTypeHierarchy(s3Utils.getSchemaByNameWithCache, objType, objType, process.env.iz_serviceSchemaBucketName);
 }
 
 /**
@@ -1120,11 +1074,11 @@ const getObjTypeHierarchyWithCache = inMemoryCacheLib(
 )
 
 async function getObjectSchemaForCreate(_izContext, objType) {
-  return await getObjectSchemaForCreateShared(getSchemaByNameWithCache, objType, process.env.iz_serviceSchemaBucketName)
+  return await getObjectSchema.getObjectSchemaForCreate(s3Utils.getSchemaByNameWithCache, objType, process.env.iz_serviceSchemaBucketName)
 }
 
 async function getObjectSchemaForUpdate(_izContext, objType) {
-  return await getObjectSchemaForUpdateShared(getSchemaByNameWithCache, objType, process.env.iz_serviceSchemaBucketName)
+  return await getObjectSchema.getObjectSchemaForUpdate(s3Utils.getSchemaByNameWithCache, objType, process.env.iz_serviceSchemaBucketName)
 }
 
 
@@ -1167,7 +1121,7 @@ async function getTableNamesByFlowType(_izContext, flowType) {
 }
 
 
-module.exports = {
+export default {
   // getObjectTypes,
   getDataFromPath,
 

package/src/IdentifiersObject.js

@@ -17,13 +17,13 @@ along with this program.If not, see < http://www.gnu.org/licenses/>.
 
 'use strict';
 
-const NoRetryError = require('@izara_project/izara-core-library-core/src/NoRetryError');
-const { validateObjType } = require('@izara_project/izara-shared-service-schemas').validateObjType;
+import { NoRetryError } from '@izara_project/izara-core-library-core';
+import { validateObjType } from '@izara_project/izara-shared-service-schemas';
 
-const deliminatorTree = require('./libs/DeliminatorTree');
-const getSchema = require('./GetObjectSchema')
-const { getUsedFieldNamesOfIdentifiers } = require('./Utils');
-const { STORAGE_TYPES, STORAGE_IDENTIFIER_TYPES, DEFAULT_IDENTIFIER_DELIMINATOR } = require('./Consts');
+import deliminatorTree from './libs/DeliminatorTree.js';
+import getSchema from './GetObjectSchema.js';
+import utils from './Utils.js';
+import consts from './Consts.js';
 
 
 /**
@@ -38,7 +38,7 @@ const { STORAGE_TYPES, STORAGE_IDENTIFIER_TYPES, DEFAULT_IDENTIFIER_DELIMINATOR
 function checkStorageTypeOfObjectSchemaIdentifiers(_izContext, objectSchema) {
 
   let objectSchemaStorageType;
-  for (const [storageType, identifierTypes] of Object.entries(STORAGE_IDENTIFIER_TYPES)) {
+  for (const [storageType, identifierTypes] of Object.entries(consts.STORAGE_IDENTIFIER_TYPES)) {
     if (identifierTypes.includes(objectSchema.identifiers[0].type)) {
       objectSchemaStorageType = storageType
     }
@@ -59,7 +59,7 @@ function checkStorageTypeOfObjectSchemaIdentifiers(_izContext, objectSchema) {
  * @returns {Promise<Object>}        - identifiersObject
  */
 async function identifiersFromObjInstanceBase(_izContext, objType, objInstanceBase, bucketName = process.env.iz_serviceSchemaBucketName) {
-  const validateObjTypeResult = validateObjType(objType);
+  const validateObjTypeResult = validateObjType.validateObjType(objType);
   if (validateObjTypeResult.errorsFound.length > 0) {
     _izContext.logger.error("identifiersObjectFromBaseObjInstance: Invalid objType: ", validateObjTypeResult.errorsFound);
     throw new NoRetryError(`identifiersObjectFromBaseObjInstance: Invalid objType: ${validateObjTypeResult.errorsFound.join(', ')}`);
@@ -76,20 +76,20 @@ async function identifiersFromObjInstanceBase(_izContext, objType, objInstanceBa
   // check which baseObjInstance come from
   let storageOfBaseObjInstance;
 
-  if (checkStorageTypeOfObjectSchemaIdentifiers(_izContext, objSchema) === STORAGE_TYPES.graph) {
+  if (checkStorageTypeOfObjectSchemaIdentifiers(_izContext, objSchema) === consts.STORAGE_TYPES.graph) {
     const graphIdentifierName = Object.keys(deliminatorTreeResult)[0];
 
     if (objInstanceBase.hasOwnProperty(graphIdentifierName)) {
-      storageOfBaseObjInstance = STORAGE_TYPES.dynamoDB;
+      storageOfBaseObjInstance = consts.STORAGE_TYPES.dynamoDB;
     } else {
-      storageOfBaseObjInstance = STORAGE_TYPES.graph;
+      storageOfBaseObjInstance = consts.STORAGE_TYPES.graph;
     }
   }
 
 
   let explodedResults = {};
   // overwrite deliminatorTree if found
-  if (storageOfBaseObjInstance === STORAGE_TYPES.graph) {
+  if (storageOfBaseObjInstance === consts.STORAGE_TYPES.graph) {
     const identifierFieldNames = objSchema.identifiers[0].fieldNames || [objSchema.identifiers[0].fieldName];
 
     for (const identifierName of identifierFieldNames) {
@@ -145,7 +145,7 @@ async function identifiersFromObjInstanceBase(_izContext, objType, objInstanceBa
  * @returns {Promise<Object>}         - concatIdentifiersObject
  */
 async function identifiersBaseFromIdentifiers(_izContext, objType, identifiers, bucketName = process.env.iz_serviceSchemaBucketName) {
-  const validateObjTypeResult = validateObjType(objType);
+  const validateObjTypeResult = validateObjType.validateObjType(objType);
   if (validateObjTypeResult.errorsFound.length > 0) {
     _izContext.logger.error("identifiersBaseFromIdentifiers: Invalid objType: ", validateObjTypeResult.errorsFound);
     throw new NoRetryError(`identifiersBaseFromIdentifiers: Invalid objType: ${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
@@ -158,7 +158,7 @@ async function identifiersBaseFromIdentifiers(_izContext, objType, identifiers,
 
   // validate identifiersObject
   // maybe validate with all deliminatorTree instead of identifiersName
-  const identifiersNames = getUsedFieldNamesOfIdentifiers(_izContext, objSchema.identifiers);
+  const identifiersNames = utils.getUsedFieldNamesOfIdentifiers(_izContext, objSchema.identifiers);
   _izContext.logger.debug("identifiersNames: ", identifiersNames);
 
   for (const identifierName of identifiersNames) {
@@ -201,7 +201,7 @@ async function identifiersBaseFromIdentifiers(_izContext, objType, identifiers,
  * @returns {Promise<Object>}         - refactoredObjInstance
  */
 async function objInstanceFromObjInstanceBase(_izContext, objType, objInstance, bucketName = process.env.iz_serviceSchemaBucketName) {
-  const validateObjTypeResult = validateObjType(objType);
+  const validateObjTypeResult = validateObjType.validateObjType(objType);
   if (validateObjTypeResult.errorsFound.length > 0) {
     _izContext.logger.error("objInstanceFromObjInstanceBase: Invalid objType: ", validateObjTypeResult.errorsFound);
     throw new NoRetryError(`objInstanceFromObjInstanceBase: Invalid objType: ${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
@@ -236,7 +236,7 @@ async function objInstanceFromObjInstanceBase(_izContext, objType, objInstance,
  * @returns {Promise<String>}           - compositeIdentifier
  */
 async function identifiersConcatFromIdentifiers(_izContext, objType, identifiers, bucketName = process.env.iz_serviceSchemaBucketName) {
-  const validateObjTypeResult = validateObjType(objType);
+  const validateObjTypeResult = validateObjType.validateObjType(objType);
   if (validateObjTypeResult.errorsFound.length > 0) {
     _izContext.logger.error("compositeIdentifierFromIdentifiersObject: Invalid objType: ", validateObjTypeResult.errorsFound);
     throw new NoRetryError(`compositeIdentifierFromIdentifiersObject: Invalid objType: ${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
@@ -250,7 +250,7 @@ async function identifiersConcatFromIdentifiers(_izContext, objType, identifiers
 
   // validate identifiersObject
   // maybe validate with all deliminatorTree instead of identifiersName
-  const identifiersNames = getUsedFieldNamesOfIdentifiers(_izContext, objSchema.identifiers,);
+  const identifiersNames = utils.getUsedFieldNamesOfIdentifiers(_izContext, objSchema.identifiers,);
   _izContext.logger.debug("identifiersNames: ", identifiersNames);
 
   for (const identifierName of identifiersNames) {
@@ -334,7 +334,7 @@ async function identifiersConcatFromIdentifiers(_izContext, objType, identifiers
  * @returns {Promise<Object>}             - identifiersObject
  */
 async function identifiersFromIdentifiersConcat(_izContext, objType, identifiersConcat, bucketName = process.env.iz_serviceSchemaBucketName) {
-  const validateObjTypeResult = validateObjType(objType);
+  const validateObjTypeResult = validateObjType.validateObjType(objType);
   if (validateObjTypeResult.errorsFound.length > 0) {
     _izContext.logger.error("identifiersObjectFromCompositeIdentifier: Invalid objType: ", validateObjTypeResult.errorsFound);
     throw new NoRetryError(`identifiersObjectFromCompositeIdentifier: Invalid objType: ${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
@@ -435,7 +435,7 @@ async function createNestedIdentifiersConcat(
   prefixes = [],
   suffixes = [],
   level = 1,
-  deliminator = DEFAULT_IDENTIFIER_DELIMINATOR,
+  deliminator = consts.DEFAULT_IDENTIFIER_DELIMINATOR,
 ) {
 
   const strNotEmptyRegex = /^[a-zA-Z0-9_-]+$/;
@@ -448,7 +448,7 @@ async function createNestedIdentifiersConcat(
     throw new NoRetryError(`one of prefixes and suffixes should exists`);
   }
 
-  const validateObjTypeResult = validateObjType(objType);
+  const validateObjTypeResult = validateObjType.validateObjType(objType);
   if (validateObjTypeResult.errorsFound.length > 0) {
     _izContext.logger.error("createConcatIdentifier: Invalid objType: ", validateObjTypeResult.errorsFound);
     throw new NoRetryError(`createConcatIdentifier: Invalid objType: ${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
@@ -465,7 +465,7 @@ async function createNestedIdentifiersConcat(
     ? deliminatorTreeCompositeIdentifier.deliminatorList[deliminator]
     : 0;
 
-  // start conatenate data
+  // start concatenate data
   const concatenatedIdentifier = [...prefixes, identifiersConcat, ...suffixes].join(deliminator.repeat(compositeDeliminatorAmount + level));
 
   return concatenatedIdentifier;
@@ -478,7 +478,7 @@ async function explodedNestedIdentifiersConcat(
   concatIdentifier,
   bucketName = process.env.iz_serviceSchemaBucketName,
   level = 1,
-  deliminator = DEFAULT_IDENTIFIER_DELIMINATOR,
+  deliminator = consts.DEFAULT_IDENTIFIER_DELIMINATOR,
 ) {
 
   const strNotEmptyRegex = /^[a-zA-Z0-9_-]+$/;
@@ -487,7 +487,7 @@ async function explodedNestedIdentifiersConcat(
     throw new NoRetryError(`invalid compositeIdentifier`);
   }
 
-  const validateObjTypeResult = validateObjType(objType);
+  const validateObjTypeResult = validateObjType.validateObjType(objType);
   if (validateObjTypeResult.errorsFound.length > 0) {
     _izContext.logger.error("explodedConcatIdentifier: Invalid objType: ", validateObjTypeResult.errorsFound);
     throw new NoRetryError(`explodedConcatIdentifier: Invalid objType: ${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
@@ -509,7 +509,7 @@ async function explodedNestedIdentifiersConcat(
 
 
 
-module.exports = {
+export default {
   identifiersFromObjInstanceBase,
   identifiersBaseFromIdentifiers, // concatIdentifiersObjectFromIdentifiersObject
   objInstanceFromObjInstanceBase, // refactoredObjInstanceFromBaseObjInstance