@izara_project/izara-core-library-service-schemas 1.0.73 → 1.0.75

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-library-service-schemas",
-  "version": "1.0.73",
+  "version": "1.0.75",
   "description": "Schemas for the service and objects it controls",
   "main": "index.js",
   "scripts": {
@@ -14,22 +14,22 @@
   "license": "AGPL-3.0-or-later",
   "homepage": "https://bitbucket.org/izara-core-libraries/izara-core-library-service-schemas/src/master/README.md",
   "devDependencies": {
-    "jest": "^30.0.2"
+    "jest": "^30.0.4"
   },
   "jest": {
     "testEnvironment": "node"
   },
   "dependencies": {
-    "@aws-sdk/client-lambda": "^3.835.0",
-    "@aws-sdk/client-s3": "^3.835.0",
-    "@aws-sdk/crc64-nvme-crt": "^3.835.0",
-    "@aws-sdk/client-api-gateway": "^3.835.0",
+    "@aws-sdk/client-api-gateway": "^3.840.0",
+    "@aws-sdk/client-lambda": "^3.840.0",
+    "@aws-sdk/client-s3": "^3.842.0",
+    "@aws-sdk/crc64-nvme-crt": "^3.840.0",
     "@izara_project/izara-core-library-core": "^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-core": "^1.0.2",
-    "@izara_project/izara-shared-service-schemas": "^1.0.19",
+    "@izara_project/izara-shared-service-schemas": "^1.0.21",
     "glob": "^11.0.3",
     "lodash": "^4.17.21",
     "object-hash": "^3.0.0",

package/src/Consts.js

@@ -297,13 +297,16 @@ function createValidationFieldNameForEachType(type, validation) {
   }[type]
 }
 
-function flowSchemaPathS3(_izContext, flowType) {
-  validateFlowType(flowType);
-  return `${PREFIX_PATH_S3.perServiceSchemas}/${flowType.serviceTag}/FlowSchema/${flowType.flowTag}.json`
-}
+// function flowSchemaPathS3(_izContext, flowType) {
+//   validateFlowType(flowType);
+//   return `${PREFIX_PATH_S3.perServiceSchemas}/${flowType.serviceTag}/FlowSchema/${flowType.flowTag}.json`
+// }
 
 function getEndpointPerObjectType(_izContext, objType) {
-  validateObjType(objType);
+  let validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    throw new NoRetryError(`function flowSchemaPathS3: invalid flowType ${flowType.name} - ${validateFlowTypeResult.errorsFound.join(", ")}`);
+  }
   return `${PREFIX_PATH_S3.perServiceSchemas}/${objType.serviceTag}/FrontEnd/Endpoint/Endpoint_Get_${objType.objectType}.json`
 }
 

package/src/GetObjectSchema.js

@@ -36,7 +36,9 @@ const {
   getObjectRelationship: getObjectRelationshipShared,
   getRequiredOnCreateLinks: getRequiredOnCreateLinksShared,
   getLinkConfigByLinkTypeId: getLinkConfigByLinkTypeIdShared,
-  getObjTypeHierarchy: getObjTypeHierarchyShared
+  getObjTypeHierarchy: getObjTypeHierarchyShared,
+  getObjectSchemaForCreate: getObjectSchemaForCreateShared,
+  getObjectSchemaForUpdate: getObjectSchemaForUpdateShared,
 } = sharedServiceSchema.getObjectSchema;
 const { validateObjType, validateFlowType } = sharedServiceSchema.validateObjType;
 const {
@@ -222,7 +224,7 @@ async function getLocalObjectSchemas(_izContext, objectTypes, objSchemaPath = LO
       allObjectSchemas.map(async (objSchema, idx) => {
         const mergeResult = await mergeExtendObjSchema(_izContext, objSchema)
         if (mergeResult?.errorsFound?.length && mergeResult?.errorsFound?.length > 0) {
-          throw new NoRetryError(mergeResult.errorsFound)
+          throw new NoRetryError(mergeResult.errorsFound.join(","))
         } else {
           allObjectSchemas[idx] = mergeResult;
         }
@@ -471,7 +473,7 @@ async function getObjSchemaS3(
 ) {
   return await getObjectSchemaS3Shared(getSchemaByNameWithCache, objType, getExtendObType).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }
@@ -505,7 +507,7 @@ async function getObjSchemaS3WithHierarchy(_izContext, objType) {
   // return await getObjSchemaS3WithCache(_izContext, objType, true)
   return await getObjSchemaWithHierarchy(getSchemaByNameWithCache, objType).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }
@@ -522,7 +524,7 @@ async function getObjSchemaS3WithoutHierarchy(_izContext, objType) {
   // return await getObjSchemaS3WithCache(_izContext, objType, false)
   return await getObjSchemaWithoutHierarchy(getSchemaByNameWithCache, objType).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }
@@ -642,7 +644,7 @@ function getLocalRelationshipSchemas(_izContext, relationshipTags, objSchemaPath
 async function getRefObjectRelationship(_izContext, objType) {
   return await getRefObjectRelationshipShared(getSchemaByNameWithCache, objType).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }
@@ -677,7 +679,7 @@ const getRefObjectRelationshipWithCache = inMemoryCacheLib(
 async function getRelationshipSchema(_izContext, relType) {
   return await getRelationshipSchemaShared(getSchemaByNameWithCache, relType).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }
@@ -790,7 +792,7 @@ async function getObjectRelationship(
 
   return await getObjectRelationshipShared(getSchemaByNameWithCache, objType, specificRelTags, overWriteBaseObjType).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }
@@ -840,7 +842,7 @@ async function getRequiredOnCreateLinks(
 
   return await getRequiredOnCreateLinksShared(getSchemaByNameWithCache, objType, specificRelTags).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }
@@ -922,7 +924,7 @@ async function getLinkConfigByLinkTypeId(_izContext, firstObjType, secondObjType
 
   await getLinkConfigByLinkTypeIdShared(getSchemaByNameWithCache, firstObjType, secondObjType, relType, direction, settings).then(res => {
     if (res.errorsFound.length && res.errorsFound.length > 0) {
-      throw new NoRetryError(res.errorsFound)
+      throw new NoRetryError(res.errorsFound.join(","))
     } else {
       return res.result
     }
@@ -1124,6 +1126,14 @@ const getObjTypeHierarchyWithCache = inMemoryCacheLib(
   }
 )
 
+async function getObjectSchemaForCreate(_izContext, objType) {
+  return await getObjectSchemaForCreateShared(getSchemaByNameWithCache, objType)
+}
+
+async function getObjectSchemaForUpdate(_izContext, objType) {
+  return await getObjectSchemaForUpdateShared(getSchemaByNameWithCache, objType)
+}
+
 module.exports = {
   // getObjectTypes,
   getDataFromPath,
@@ -1178,7 +1188,10 @@ module.exports = {
   getFlowSchemaS3WithCache,
 
   getObjTypeHierarchy,
-  getObjTypeHierarchyWithCache
+  getObjTypeHierarchyWithCache,
+
+  getObjectSchemaForCreate,
+  getObjectSchemaForUpdate,
 }
 
 

package/src/Utils.js

@@ -35,6 +35,9 @@ const {
     validateObjType,
     validateRelType,
     validateFlowType
+  },
+  reformatObjectSchema: {
+    getUsedFieldNamesOfIdentifiers: getUsedFieldNamesOfIdentifiersShared
   }
 } = require('@izara_project/izara-shared-service-schemas');
 
@@ -106,21 +109,22 @@ function getIdentifierTypeByPriority(_izContext, storageTypes = [], objSchema) {
  * @returns {string[]}                    - array of fieldName from objectSchema.identifiers
  */
 function getUsedFieldNamesOfIdentifiers(_izContext, identifiers, identifierTypes = []) {
-  let identifierFieldNames = [];
-
-  for (let identifier of identifiers) {
-    if (Array.isArray(identifierTypes) && identifierTypes.length && !identifierTypes.includes(identifier.type)) {
-      continue;
-    }
-
-    if (identifier.fieldName) {
-      identifierFieldNames.push(identifier.fieldName);
-    } else if (identifier.fieldNames) {
-      identifierFieldNames = identifierFieldNames.concat(identifier.fieldNames);
-    }
-  }
-
-  return [...new Set(identifierFieldNames)];
+  return getUsedFieldNamesOfIdentifiersShared(identifiers, identifierTypes)
+  // let identifierFieldNames = [];
+
+  // for (let identifier of identifiers) {
+  //   if (Array.isArray(identifierTypes) && identifierTypes.length && !identifierTypes.includes(identifier.type)) {
+  //     continue;
+  //   }
+
+  //   if (identifier.fieldName) {
+  //     identifierFieldNames.push(identifier.fieldName);
+  //   } else if (identifier.fieldNames) {
+  //     identifierFieldNames = identifierFieldNames.concat(identifier.fieldNames);
+  //   }
+  // }
+
+  // return [...new Set(identifierFieldNames)];
 }
 
 

package/src/libs/CreateNodeLib.js

@@ -26,22 +26,34 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
   _izContext.logger.debug("validateRequiredOnCreateLinks:::", { objType, relationships, settings })
 
 
-  let objectHie = await getObjTypeHierarchy(_izContext, objType);
+  let objectHie = await getObjTypeHierarchy(_izContext, objType).then(objSchema => {
+    if (objSchema.errorsFound.length > 0) {
+      throw new NoRetryError(objSchema.errorsFound.join(","))
+    } else {
+      return objSchema.result
+    }
+  });
   _izContext.logger.debug("objectHierarchy::", objectHie)
 
   if (relationships.length) {
-    let targetHierarchy = await getObjTypeHierarchy(_izContext, relationships[0].targetObjType);
+    let targetHierarchy = await getObjTypeHierarchy(_izContext, relationships[0].targetObjType).then(objSchema => {
+      if (objSchema.errorsFound.length > 0) {
+        throw new NoRetryError(objSchema.errorsFound.join(","))
+      } else {
+        return objSchema.result
+      }
+    });
     _izContext.logger.debug("targetHierarchy::", targetHierarchy)
   }
 
 
-  let errorFound = [];
+  let errorsFound = [];
 
   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)}`)
+    errorsFound.push(`not have requireOnCreate will not create relationship: ${JSON.stringify(relationships)}`)
   }
 
   let filteredRequiredOnCreateLinks = [];
@@ -76,22 +88,28 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
     let relTypeConcat = createRelTypeConcat(_izContext, relationship.relType)
 
     if (!requiredOnCreateLinkGroups[relTypeConcat]) {
-      errorFound.push(`cannot create relationship ${relTypeConcat}`)
+      errorsFound.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}`)
+    if (!usedLinkGroup?.length) {
+      errorsFound.push(`cannot create relationship ${relTypeConcat}`)
       break;
     }
 
     for (let link of usedLinkGroup) {
       // check other with targetObjType, check linkType of other should be 'one',
-      let targetObjTypeHierarchy = await getObjTypeHierarchy(_izContext, relationship.targetObjType);
-      _izContext.logger.debug(" ::", targetObjTypeHierarchy)
+      let targetObjTypeHierarchy = await getObjTypeHierarchy(_izContext, relationship.targetObjType).then(objSchema => {
+        if (objSchema.errorsFound.length > 0) {
+          throw new NoRetryError(objSchema.errorsFound.join(","))
+        } else {
+          return objSchema.result
+        }
+      });
+      _izContext.logger.debug("targetObjTypeHierarchy::", targetObjTypeHierarchy)
 
       // if (link.other.objType.objectType === relationship.targetObjType.objectType) {
       if (targetObjTypeHierarchy.some(objType =>
@@ -101,11 +119,11 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
           if (!validateOnCreateRelationships.has(`${relTypeConcat}_${relationship.relationshipDirection}`)) {
             validateOnCreateRelationships.add(`${relTypeConcat}_${relationship.relationshipDirection}`)
           } else {
-            errorFound.push(`unexpected dulicate relationship link ${JSON.stringify(relationship)}`)
+            errorsFound.push(`unexpected duplicate relationship link ${JSON.stringify(relationship)}`)
             break;
           }
         } else {
-          errorFound.push(`invalid linkType should not be many when base: ${link} is requiredOnCreated`)
+          errorsFound.push(`invalid linkType should not be many when base: ${link} is requiredOnCreated`)
           break;
         }
       }
@@ -117,11 +135,11 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
 
   for (const requiredOnCreateRelTypeConcat of requiredOnCreateRelTypeConcats) {
     if (!validateOnCreateRelationships.has(requiredOnCreateRelTypeConcat)) {
-      errorFound.push(`missing requiredOnCreate relationship ${requiredOnCreateRelTypeConcat}`)
+      errorsFound.push(`missing requiredOnCreate relationship ${requiredOnCreateRelTypeConcat}`)
     }
   }
 
-  return errorFound;
+  return errorsFound;
 }
 
 function groupRequiredOnCreateLink(_izContext, relationshipSchemas) {

package/src/libs/DeliminatorTree.js

@@ -205,24 +205,24 @@ async function generateDeliminatorTreeIdentifier(_izContext, objectSchema) {
           }));
 
           // calculate deliminatorTree of identifier
-          let calCompoisteKeyDeliminatorList = {};
+          let calCompositeKeyDeliminatorList = {};
           for (let deliminatorValue of Object.values(compositeKeysDeliminatorTree)) {
             if (deliminatorValue.deliminatorList) {
               for (let [deliminator, deliminatorAmount] of Object.entries(deliminatorValue.deliminatorList)) {
-                if (calCompoisteKeyDeliminatorList.hasOwnProperty(deliminator)) {
-                  calCompoisteKeyDeliminatorList[deliminator] = Math.max(deliminatorAmount, calCompoisteKeyDeliminatorList[deliminator]);
+                if (calCompositeKeyDeliminatorList.hasOwnProperty(deliminator)) {
+                  calCompositeKeyDeliminatorList[deliminator] = Math.max(deliminatorAmount, calCompositeKeyDeliminatorList[deliminator]);
                 } else {
-                  Object.assign(calCompoisteKeyDeliminatorList, { [deliminator]: deliminatorAmount });
+                  Object.assign(calCompositeKeyDeliminatorList, { [deliminator]: deliminatorAmount });
                 }
               }
             }
           }
 
 
-          if (calCompoisteKeyDeliminatorList.hasOwnProperty(identifierDeliminator)) {
-            calCompoisteKeyDeliminatorList[identifierDeliminator]++;
+          if (calCompositeKeyDeliminatorList.hasOwnProperty(identifierDeliminator)) {
+            calCompositeKeyDeliminatorList[identifierDeliminator]++;
           } else {
-            Object.assign(calCompoisteKeyDeliminatorList, { [identifierDeliminator]: 1 });
+            Object.assign(calCompositeKeyDeliminatorList, { [identifierDeliminator]: 1 });
           }
 
           Object.assign(
@@ -230,7 +230,7 @@ async function generateDeliminatorTreeIdentifier(_izContext, objectSchema) {
             {
               [identifierName]: {
                 deliminator: identifierDeliminator,
-                deliminatorList: calCompoisteKeyDeliminatorList,
+                deliminatorList: calCompositeKeyDeliminatorList,
                 children: compositeKeysDeliminatorTree
               }
             }

package/src/libs/RelSchemaLib.js

@@ -29,12 +29,12 @@ const { getObjTypeHierarchy } = require('../GetObjectSchema')
  *
  * @param {object} _izContext
  * @param {object[]} objTypes          - 2 objType in array
- * @param {object[]} relatoinshipLinks - links inside relationshipSchema
+ * @param {object[]} relationshipLinks - links inside relationshipSchema
  */
-async function findLinksByObjTypes(_izContext, objTypes, relatoinshipLinks) {
+async function findLinksByObjTypes(_izContext, objTypes, relationshipLinks) {
 
-  if (!Array.isArray(relatoinshipLinks)) {
-    throw new NoRetryError("relatoinshipLinks should be array");
+  if (!Array.isArray(relationshipLinks)) {
+    throw new NoRetryError("relationshipLinks should be array");
   }
 
   if (!objTypes || !Array.isArray(objTypes) || objTypes.length !== 2) {
@@ -52,8 +52,20 @@ async function findLinksByObjTypes(_izContext, objTypes, relatoinshipLinks) {
   const secondObjType = objTypes[1];
 
   // first create hierarchy of each objType
-  const firstObjTypeTree = await getObjTypeHierarchy(_izContext, objTypes[0]);
-  const secondObjTypeTree = await getObjTypeHierarchy(_izContext, objTypes[1]);
+  const firstObjTypeTree = await getObjTypeHierarchy(_izContext, objTypes[0]).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 => {
+    if (objSchema.errorsFound.length > 0) {
+      throw new NoRetryError(objSchema.errorsFound.join(","))
+    } else {
+      return objSchema.result
+    }
+  });
 
   const firstObjTypeTreeHashes = firstObjTypeTree.reduce(
     (result, objType) => {
@@ -74,7 +86,7 @@ async function findLinksByObjTypes(_izContext, objTypes, relatoinshipLinks) {
 
   let foundLinks = [];
 
-  for (let link of relatoinshipLinks) {
+  for (let link of relationshipLinks) {
     const fromObjTypeHash = hash(link.from.objType);
     const toObjTypeHash = hash(link.to.objType);
 

package/src/libs/UploadUseCase.js

@@ -18,7 +18,11 @@ along with this program.If not, see < http://www.gnu.org/licenses/>.
 'use strict';
 
 const { NoRetryError } = require('@izara_project/izara-core-library-core');
-
+const {
+  generateObjectSchemaForCreate: generateObjectSchemaForCreateShared,
+  generateObjectSchemaForUpdate: generateObjectSchemaForUpdateShared,
+  generateObjectSchemaForCombineFieldNames: generateObjectSchemaForCombineFieldNamesShared
+} = require('@izara_project/izara-shared-service-schemas').reformatObjectSchema
 const {
   getUsedFieldNamesOfIdentifiers,
   findLinkByObjType,
@@ -45,44 +49,6 @@ const DEFAULT_REL_ID_SETTING = {
   }
 }
 
-
-// add default versionedData fieldNames when upload
-function defaultVersionedDataFieldNames(_izContext, versionedDataLabel, storageTag) {
-  return {
-    [`versionedDataField_${versionedDataLabel}_versionedDataId`]: {
-      type: "string",
-      generatedField: true,
-      versionedDataLabel: versionedDataLabel,
-      storageResourceTags: [storageTag],
-      requiredOnCreate: false,
-      optionalOnCreate: false,
-      canUpdate: false,
-      validation: {},
-    },
-    [`versionedDataField_${versionedDataLabel}_forMatchedId`]: {
-      type: "string",
-      generatedField: true,
-      versionedDataLabel: versionedDataLabel,
-      storageResourceTags: [storageTag],
-      requiredOnCreate: false,
-      optionalOnCreate: false,
-      canUpdate: false,
-      validation: {},
-    },
-    [`versionedDataField_${versionedDataLabel}_originTimestamp`]: {
-      type: "number",
-      generatedField: true,
-      versionedDataLabel: versionedDataLabel,
-      storageResourceTags: [storageTag],
-      requiredOnCreate: false,
-      optionalOnCreate: false,
-      canUpdate: false,
-      validation: {},
-    },
-  }
-}
-
-
 /**
  * create object schema for create case
  *
@@ -92,50 +58,58 @@ function defaultVersionedDataFieldNames(_izContext, versionedDataLabel, storageT
  */
 function generateObjectSchemaForCreate(_izContext, objSchema) {
 
-  // generate data for case create
-  let initReturnObj = {
-    objectType: objSchema.objectType,
-    fieldNames: {}
-  };
-
-  for (let [fieldName, fieldNameSetting] of Object.entries(objSchema.fieldNames)) {
-
-    if (!initReturnObj.fieldNames.hasOwnProperty(fieldName)) {
-      initReturnObj.fieldNames[fieldName] = {}
-    }
-
-    initReturnObj.fieldNames[fieldName].type = fieldNameSetting.type;
-    initReturnObj.fieldNames[fieldName].validation = fieldNameSetting.validation || {};
-    initReturnObj.fieldNames[fieldName].requiredOnCreate = (fieldNameSetting.requiredOnCreate === true) ? true : false;
-    initReturnObj.fieldNames[fieldName].optionalOnCreate = (fieldNameSetting.optionalOnCreate === true) ? true : false;
-  }
-
-  // add fieldNames from versionedData
-  if (objSchema.addOnDataStructure?.length) {
-    for (let addOn of objSchema.addOnDataStructure) {
-      if (addOn.type === "versionedData") {
-        for (let [versionedFieldName, fieldNameData] of Object.entries(addOn.fieldNames)) {
-          Object.assign(
-            initReturnObj.fieldNames,
-            {
-              [versionedFieldName]: {
-                type: fieldNameData.type,
-                validation: fieldNameData.validation || {},
-                requiredOnCreate: fieldNameData.requiredOnCreate || false,
-                optionalOnCreate: fieldNameData.optionalOnCreate || false,
-              }
-            });
-        }
-      }
-    }
-  }
-
-
-  return initReturnObj;
+  return generateObjectSchemaForCreateShared(objSchema)
+  // // generate data for case create
+  // let initReturnObj = {
+  //   objectType: objSchema.objectType,
+  //   fieldNames: {}
+  // };
+
+  // for (let [fieldName, fieldNameSetting] of Object.entries(objSchema.fieldNames)) {
+
+  //   if (!fieldNameSetting.requiredOnCreate && !fieldNameSetting.optionalOnCreate) {
+  //     continue;
+  //   }
+
+  //   if (!initReturnObj.fieldNames.hasOwnProperty(fieldName)) {
+  //     initReturnObj.fieldNames[fieldName] = {}
+  //   }
+
+  //   initReturnObj.fieldNames[fieldName].type = fieldNameSetting.type;
+  //   initReturnObj.fieldNames[fieldName].validation = fieldNameSetting.validation || {};
+  //   initReturnObj.fieldNames[fieldName].requiredOnCreate = (fieldNameSetting.requiredOnCreate === true) ? true : false;
+  //   initReturnObj.fieldNames[fieldName].optionalOnCreate = (fieldNameSetting.optionalOnCreate === true) ? true : false;
+  // }
+
+  // // add fieldNames from versionedData
+  // if (objSchema.addOnDataStructure?.length) {
+  //   for (let addOn of objSchema.addOnDataStructure) {
+  //     if (addOn.type === "versionedData") {
+  //       for (let [versionedFieldName, fieldNameData] of Object.entries(addOn.fieldNames)) {
+
+  //         if (!fieldNameData.requiredOnCreate && !fieldNameData.optionalOnCreate) {
+  //           continue;
+  //         }
+
+  //         Object.assign(
+  //           initReturnObj.fieldNames,
+  //           {
+  //             [versionedFieldName]: {
+  //               type: fieldNameData.type,
+  //               validation: fieldNameData.validation || {},
+  //               requiredOnCreate: fieldNameData.requiredOnCreate || false,
+  //               optionalOnCreate: fieldNameData.optionalOnCreate || false,
+  //             }
+  //           });
+  //       }
+  //     }
+  //   }
+  // }
+
+
+  // return initReturnObj;
 }
 
-
-
 /**
  * create object schema for update/display case
  *
@@ -144,65 +118,67 @@ function generateObjectSchemaForCreate(_izContext, objSchema) {
  * @returns {Object}            - objectSchema that has property for case update
  */
 function generateObjectSchemaForUpdate(_izContext, objSchema) {
-  // generate data for case update
-  let initReturnObj = {
-    objectType: objSchema.objectType,
-    fieldNames: {},
-    identifiers: objSchema.identifiers,
-  };
-
-  if (objSchema.extendObjType) {
-    initReturnObj.extendObjType = objSchema.extendObjType;
-  } else {
-    initReturnObj.identifierFieldNames = getUsedFieldNamesOfIdentifiers(_izContext, objSchema.identifiers);
-  }
-
-  for (let [fieldName, fieldNameSetting] of Object.entries(objSchema.fieldNames)) {
-
-    if (!initReturnObj.fieldNames.hasOwnProperty(fieldName)) {
-      initReturnObj.fieldNames[fieldName] = {}
-    }
 
-    if (fieldNameSetting.canUpdate === true || fieldNameSetting.canUpdate === undefined) {
-      initReturnObj.fieldNames[fieldName].type = fieldNameSetting.type;
-      initReturnObj.fieldNames[fieldName].validation = fieldNameSetting.validation || {};
-      initReturnObj.fieldNames[fieldName].canUpdate = true;
-    } else {
-      initReturnObj.fieldNames[fieldName].type = fieldNameSetting.type;
-    }
-  }
-
-  // add fieldNames from versionedData
-  if (objSchema.addOnDataStructure?.length) {
-    for (let addOn of objSchema.addOnDataStructure) {
-      if (addOn.type === "versionedData") {
-        for (let [versionedFieldName, fieldNameData] of Object.entries(addOn.fieldNames)) {
-
-          if (fieldNameData.canUpdate === true || fieldNameData.canUpdate === undefined) {
-            Object.assign(
-              initReturnObj.fieldNames,
-              {
-                [versionedFieldName]: {
-                  type: fieldNameData.type,
-                  canUpdate: true,
-                  validation: fieldNameData.validation || {},
-                }
-              });
-          } else {
-            Object.assign(
-              initReturnObj.fieldNames,
-              {
-                [versionedFieldName]: {
-                  type: fieldNameData.type,
-                }
-              });
-          }
-        }
-      }
-    }
-  }
-
-  return initReturnObj;
+  return generateObjectSchemaForUpdateShared(objSchema)
+  // // generate data for case update
+  // let initReturnObj = {
+  //   objectType: objSchema.objectType,
+  //   fieldNames: {},
+  //   identifiers: objSchema.identifiers,
+  // };
+
+  // if (objSchema.extendObjType) {
+  //   initReturnObj.extendObjType = objSchema.extendObjType;
+  // } else {
+  //   initReturnObj.identifierFieldNames = getUsedFieldNamesOfIdentifiers(_izContext, objSchema.identifiers);
+  // }
+
+  // for (let [fieldName, fieldNameSetting] of Object.entries(objSchema.fieldNames)) {
+
+  //   if (!initReturnObj.fieldNames.hasOwnProperty(fieldName)) {
+  //     initReturnObj.fieldNames[fieldName] = {}
+  //   }
+
+  //   if (fieldNameSetting.canUpdate === true || fieldNameSetting.canUpdate === undefined) {
+  //     initReturnObj.fieldNames[fieldName].type = fieldNameSetting.type;
+  //     initReturnObj.fieldNames[fieldName].validation = fieldNameSetting.validation || {};
+  //     initReturnObj.fieldNames[fieldName].canUpdate = true;
+  //   } else {
+  //     initReturnObj.fieldNames[fieldName].type = fieldNameSetting.type;
+  //   }
+  // }
+
+  // // add fieldNames from versionedData
+  // if (objSchema.addOnDataStructure?.length) {
+  //   for (let addOn of objSchema.addOnDataStructure) {
+  //     if (addOn.type === "versionedData") {
+  //       for (let [versionedFieldName, fieldNameData] of Object.entries(addOn.fieldNames)) {
+
+  //         if (fieldNameData.canUpdate === true || fieldNameData.canUpdate === undefined) {
+  //           Object.assign(
+  //             initReturnObj.fieldNames,
+  //             {
+  //               [versionedFieldName]: {
+  //                 type: fieldNameData.type,
+  //                 canUpdate: true,
+  //                 validation: fieldNameData.validation || {},
+  //               }
+  //             });
+  //         } else {
+  //           Object.assign(
+  //             initReturnObj.fieldNames,
+  //             {
+  //               [versionedFieldName]: {
+  //                 type: fieldNameData.type,
+  //               }
+  //             });
+  //         }
+  //       }
+  //     }
+  //   }
+  // }
+
+  // return initReturnObj;
 }
 
 
@@ -216,55 +192,57 @@ function generateObjectSchemaForUpdate(_izContext, objSchema) {
  * @returns {Object}            - objectSchema that has property for case update
  */
 function generateObjectSchemaForCombineFieldNames(_izContext, objSchema) {
-  // generate data for case update
-  let initReturnObj = {
-    objectType: objSchema.objectType,
-    fieldNames: objSchema.fieldNames,
-    canDelete: objSchema.canDelete,
-    storageResources: objSchema.storageResources
-  };
-
-  if (objSchema.extendObjType) {
-    initReturnObj.extendObjType = objSchema.extendObjType;
-  }
-
-  if (objSchema.identifiers) {
-    initReturnObj.identifiers = objSchema.identifiers;
-    initReturnObj.identifierFieldNames = getUsedFieldNamesOfIdentifiers(_izContext, objSchema.identifiers);
-  }
-
-  // add fieldNames from versionedData
-  if (objSchema.addOnDataStructure?.length) {
-    let versionedDataLabels = [];
-    // versionedDataField_ceo_versionedDataId
-    for (let addOn of objSchema.addOnDataStructure) {
-      if (addOn.type === "versionedData") {
-        // add default fieldNames of versionedData to main fieldNames
-        Object.assign(
-          initReturnObj.fieldNames,
-          defaultVersionedDataFieldNames(_izContext, addOn.versionedDataLabel, addOn.storageResourceTag)
-        );
 
-        // add each versionedData fieldName to main fieldNames
-        for (let [versionedFieldName, fieldNameData] of Object.entries(addOn.fieldNames)) {
-          Object.assign(initReturnObj.fieldNames, {
-            [versionedFieldName]: {
-              ...fieldNameData,
-              versionedDataLabel: addOn.versionedDataLabel,
-              storageResourceTags: [addOn.storageResourceTag]
-            }
-          });
-        }
-        versionedDataLabels.push(addOn.versionedDataLabel);
-      }
-    }
-
-    if (versionedDataLabels.length) {
-      initReturnObj.versionedDataLabels = versionedDataLabels;
-    }
-  }
-
-  return initReturnObj;
+  return generateObjectSchemaForCombineFieldNamesShared(objSchema)
+  // generate data for case update
+  // let initReturnObj = {
+  //   objectType: objSchema.objectType,
+  //   fieldNames: objSchema.fieldNames,
+  //   canDelete: objSchema.canDelete,
+  //   storageResources: objSchema.storageResources
+  // };
+
+  // if (objSchema.extendObjType) {
+  //   initReturnObj.extendObjType = objSchema.extendObjType;
+  // }
+
+  // if (objSchema.identifiers) {
+  //   initReturnObj.identifiers = objSchema.identifiers;
+  //   initReturnObj.identifierFieldNames = getUsedFieldNamesOfIdentifiers(_izContext, objSchema.identifiers);
+  // }
+
+  // // add fieldNames from versionedData
+  // if (objSchema.addOnDataStructure?.length) {
+  //   let versionedDataLabels = [];
+  //   // versionedDataField_ceo_versionedDataId
+  //   for (let addOn of objSchema.addOnDataStructure) {
+  //     if (addOn.type === "versionedData") {
+  //       // add default fieldNames of versionedData to main fieldNames
+  //       Object.assign(
+  //         initReturnObj.fieldNames,
+  //         defaultVersionedDataFieldNames(_izContext, addOn.versionedDataLabel, addOn.storageResourceTag)
+  //       );
+
+  //       // add each versionedData fieldName to main fieldNames
+  //       for (let [versionedFieldName, fieldNameData] of Object.entries(addOn.fieldNames)) {
+  //         Object.assign(initReturnObj.fieldNames, {
+  //           [versionedFieldName]: {
+  //             ...fieldNameData,
+  //             versionedDataLabel: addOn.versionedDataLabel,
+  //             storageResourceTags: [addOn.storageResourceTag]
+  //           }
+  //         });
+  //       }
+  //       versionedDataLabels.push(addOn.versionedDataLabel);
+  //     }
+  //   }
+
+  //   if (versionedDataLabels.length) {
+  //     initReturnObj.versionedDataLabels = versionedDataLabels;
+  //   }
+  // }
+
+  // return initReturnObj;
 }