@resistdesign/voltra 3.0.0-alpha.0 → 3.0.0-alpha.10

package/common/index.js

@@ -0,0 +1,1218 @@
+import { SyntaxKind } from 'typescript';
+import { promises } from 'fs';
+import Path from 'path';
+import { pathToFileURL } from 'url';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/common/TypeParsing/index.ts
+var TypeParsing_exports = {};
+__export(TypeParsing_exports, {
+  Constants: () => Constants_exports,
+  TypeInfo: () => TypeInfo_exports,
+  TypeMapping: () => TypeMapping_exports,
+  Validation: () => Validation_exports
+});
+
+// src/common/TypeParsing/Validation.ts
+var Validation_exports = {};
+__export(Validation_exports, {
+  DENIED_TYPE_OPERATIONS: () => DENIED_TYPE_OPERATIONS,
+  ERROR_MESSAGE_CONSTANTS: () => ERROR_MESSAGE_CONSTANTS,
+  INVALID_CUSTOM_TYPE: () => INVALID_CUSTOM_TYPE,
+  PRIMITIVE_ERROR_MESSAGE_CONSTANTS: () => PRIMITIVE_ERROR_MESSAGE_CONSTANTS,
+  RelationshipValidationType: () => RelationshipValidationType,
+  TYPE_KEYWORD_VALIDATORS: () => TYPE_KEYWORD_VALIDATORS,
+  getValidityValue: () => getValidityValue,
+  hasValue: () => hasValue,
+  validateArrayOfTypeInfoFieldValues: () => validateArrayOfTypeInfoFieldValues,
+  validateCustomType: () => validateCustomType,
+  validateKeywordType: () => validateKeywordType,
+  validateTypeInfoFieldOperationAllowed: () => validateTypeInfoFieldOperationAllowed,
+  validateTypeInfoFieldValue: () => validateTypeInfoFieldValue,
+  validateTypeInfoValue: () => validateTypeInfoValue,
+  validateTypeOperationAllowed: () => validateTypeOperationAllowed,
+  validateValueMatchesPattern: () => validateValueMatchesPattern
+});
+
+// src/common/TypeParsing/TypeInfo.ts
+var TypeInfo_exports = {};
+__export(TypeInfo_exports, {
+  TypeOperation: () => TypeOperation
+});
+var TypeOperation = /* @__PURE__ */ ((TypeOperation2) => {
+  TypeOperation2["CREATE"] = "CREATE";
+  TypeOperation2["READ"] = "READ";
+  TypeOperation2["UPDATE"] = "UPDATE";
+  TypeOperation2["DELETE"] = "DELETE";
+  return TypeOperation2;
+})(TypeOperation || {});
+
+// src/common/Routing.ts
+var Routing_exports = {};
+__export(Routing_exports, {
+  PATH_DELIMITER: () => PATH_DELIMITER,
+  getParamsAndTestPath: () => getParamsAndTestPath,
+  getPathArray: () => getPathArray,
+  getPathString: () => getPathString,
+  getPotentialJSONValue: () => getPotentialJSONValue,
+  mergeStringPaths: () => mergeStringPaths,
+  resolvePath: () => resolvePath
+});
+var PATH_DELIMITER = "/";
+var getPotentialJSONValue = (value) => {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    return value;
+  }
+};
+var getPathArray = (path, delimiter = PATH_DELIMITER, filterEmptyOutput = false, filterEmptyInput = true, useJson = true, uriDecodeParts = true) => path.split(delimiter).filter(filterEmptyInput ? (p) => p !== "" : () => true).map(uriDecodeParts ? decodeURIComponent : (x) => x).map(useJson ? getPotentialJSONValue : (p) => p).filter(filterEmptyOutput ? (p) => p ?? false : () => true);
+var getPathString = (parts = [], delimiter = PATH_DELIMITER, filterEmptyInput = false, useJson = true, uriEncodeParts = false) => parts.filter(filterEmptyInput ? (p) => p ?? false : () => true).map(useJson ? (p) => JSON.stringify(p) : (x) => x).map(uriEncodeParts ? encodeURIComponent : (x) => x).join(delimiter);
+var mergeStringPaths = (path1, path2, delimiter = PATH_DELIMITER, filterEmptyOutput = false, filterEmptyInput = true, useJson = true, uriEncodeParts = false) => getPathString(
+  [
+    ...getPathArray(
+      path1,
+      delimiter,
+      filterEmptyOutput,
+      filterEmptyInput,
+      useJson,
+      uriEncodeParts
+    ),
+    ...getPathArray(
+      path2,
+      delimiter,
+      filterEmptyOutput,
+      filterEmptyInput,
+      useJson,
+      uriEncodeParts
+    )
+  ],
+  delimiter,
+  filterEmptyInput,
+  useJson,
+  uriEncodeParts
+);
+var resolvePath = (currentPath, newPath) => {
+  const newSegments = getPathArray(newPath, PATH_DELIMITER, true);
+  let currentSegments = getPathArray(currentPath, PATH_DELIMITER, true);
+  if (newPath.startsWith("/")) {
+    currentSegments = [];
+  }
+  newSegments.forEach((segment) => {
+    if (segment === "..") {
+      if (currentSegments.length > 0) {
+        currentSegments.pop();
+      }
+    } else if (segment !== ".") {
+      currentSegments.push(segment);
+    }
+  });
+  return "/" + currentSegments.join("/");
+};
+var getParamsAndTestPath = (path, testPath, exact = false) => {
+  const pathList = getPathArray(path);
+  const testPathList = getPathArray(testPath);
+  if (exact && pathList.length !== testPathList.length) {
+    return false;
+  } else {
+    let params = {};
+    if (pathList.length >= testPathList.length) {
+      for (let i = 0; i < testPathList.length; i++) {
+        const testPathPart = testPathList[i];
+        const pathPart = pathList[i];
+        if (testPathPart.startsWith(":")) {
+          const paramName = testPathPart.slice(1);
+          params[paramName] = pathPart;
+        } else if (pathPart !== testPathPart) {
+          return false;
+        }
+      }
+    } else {
+      return false;
+    }
+    return params;
+  }
+};
+
+// src/common/TypeParsing/Validation.ts
+var RelationshipValidationType = /* @__PURE__ */ ((RelationshipValidationType2) => {
+  RelationshipValidationType2["INCLUDE"] = "INCLUDE";
+  RelationshipValidationType2["EXCLUDE"] = "EXCLUDE";
+  RelationshipValidationType2["STRICT_EXCLUDE"] = "STRICT_EXCLUDE";
+  return RelationshipValidationType2;
+})(RelationshipValidationType || {});
+var INVALID_CUSTOM_TYPE = "INVALID_CUSTOM_TYPE";
+var PRIMITIVE_ERROR_MESSAGE_CONSTANTS = {
+  string: "NOT_A_STRING",
+  number: "NOT_A_NUMBER",
+  boolean: "NOT_A_BOOLEAN"
+};
+var ERROR_MESSAGE_CONSTANTS = {
+  MISSING: "MISSING",
+  INVALID_OPTION: "INVALID_OPTION",
+  INVALID_FIELD: "INVALID_FIELD",
+  RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED: "RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED",
+  INVALID_TYPE: "INVALID_TYPE",
+  NO_UNION_TYPE_MATCHED: "NO_UNION_TYPE_MATCHED",
+  TYPE_DOES_NOT_EXIST: "TYPE_DOES_NOT_EXIST",
+  INVALID_PATTERN: "INVALID_PATTERN",
+  VALUE_DOES_NOT_MATCH_PATTERN: "VALUE_DOES_NOT_MATCH_PATTERN"
+};
+var DENIED_TYPE_OPERATIONS = {
+  CREATE: "DENIED_TYPE_OPERATION_CREATE",
+  READ: "DENIED_TYPE_OPERATION_READ",
+  UPDATE: "DENIED_TYPE_OPERATION_UPDATE",
+  DELETE: "DENIED_TYPE_OPERATION_DELETE"
+};
+var validateValueMatchesPattern = (typeName, value, pattern) => {
+  const results = {
+    typeName,
+    valid: true,
+    error: "",
+    errorMap: {}
+  };
+  const valueSupplied = typeof value !== "undefined";
+  const patternSupplied = typeof pattern === "string" && pattern.trim() !== "";
+  if (!valueSupplied || !patternSupplied) {
+    try {
+      const regex = new RegExp(pattern);
+      const testResult = typeof value === "string" && regex.test(value);
+      if (!testResult) {
+        results.valid = false;
+        results.error = ERROR_MESSAGE_CONSTANTS.VALUE_DOES_NOT_MATCH_PATTERN;
+      }
+    } catch (e) {
+      results.valid = false;
+      results.error = ERROR_MESSAGE_CONSTANTS.INVALID_PATTERN;
+    }
+  }
+  return results;
+};
+var getValidityValue = (existing, pending) => !existing ? false : pending;
+var TYPE_KEYWORD_VALIDATORS = {
+  string: (value) => typeof value === "string",
+  number: (value) => typeof value === "number",
+  boolean: (value) => typeof value === "boolean"
+};
+var hasValue = (value) => value ?? false;
+var validateKeywordType = (value, type) => {
+  const validator = TYPE_KEYWORD_VALIDATORS[type];
+  let valid = true;
+  if (validator) {
+    valid = validator(value);
+  }
+  return valid;
+};
+var validateCustomType = (value, customType, customValidators) => {
+  let valid = true;
+  if (customValidators && customType) {
+    const validator = customValidators[customType];
+    if (validator) {
+      try {
+        valid = validator(value);
+      } catch (e) {
+        valid = false;
+      }
+    }
+  }
+  return valid;
+};
+var validateTypeInfoFieldValue = (value, typeInfoField, typeInfoMap, ignoreArray = false, strict = false, customValidators, typeOperation, relationshipValidationType = "STRICT_EXCLUDE" /* STRICT_EXCLUDE */, itemIsPartial) => {
+  const {
+    type,
+    typeReference,
+    array,
+    optional,
+    possibleValues,
+    tags: { customType, constraints: { pattern = void 0 } = {} } = {}
+  } = typeInfoField;
+  const results = {
+    typeName: typeReference ?? type,
+    valid: true,
+    error: "",
+    errorMap: {}
+  };
+  const requiredValueAllowed = !typeReference || relationshipValidationType === "INCLUDE" /* INCLUDE */;
+  if (requiredValueAllowed && !itemIsPartial && !optional && !hasValue(value)) {
+    results.valid = false;
+    results.error = ERROR_MESSAGE_CONSTANTS.MISSING;
+  } else if (array && !ignoreArray) {
+    const {
+      valid: validArray,
+      error: arrayError,
+      errorMap: arrayErrorMap
+    } = validateArrayOfTypeInfoFieldValues(
+      value,
+      typeInfoField,
+      typeInfoMap,
+      strict,
+      customValidators,
+      typeOperation,
+      relationshipValidationType,
+      itemIsPartial
+    );
+    results.valid = getValidityValue(results.valid, validArray);
+    results.error = arrayError;
+    results.errorMap = arrayErrorMap;
+  } else {
+    if (typeReference) {
+      if (relationshipValidationType === "INCLUDE" /* INCLUDE */) {
+        const {
+          valid: validTypeInfo,
+          error: typeInfoError,
+          errorMap: typeInfoErrorMap
+        } = validateTypeInfoValue(
+          value,
+          typeReference,
+          typeInfoMap,
+          strict,
+          customValidators,
+          typeOperation,
+          relationshipValidationType,
+          itemIsPartial
+        );
+        results.valid = getValidityValue(results.valid, validTypeInfo);
+        results.error = typeInfoError;
+        results.errorMap = typeInfoErrorMap;
+      } else if (relationshipValidationType === "STRICT_EXCLUDE" /* STRICT_EXCLUDE */) {
+        const valueSupplied = typeof value !== "undefined";
+        if (valueSupplied) {
+          results.valid = false;
+          results.error = ERROR_MESSAGE_CONSTANTS.RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED;
+        }
+      } else if (relationshipValidationType === "EXCLUDE" /* EXCLUDE */) {
+        results.valid = getValidityValue(results.valid, true);
+      }
+    } else if (possibleValues && !possibleValues.includes(value)) {
+      results.valid = false;
+      results.error = ERROR_MESSAGE_CONSTANTS.INVALID_OPTION;
+    } else {
+      const pendingValid = validateKeywordType(value, type);
+      const customValid = validateCustomType(
+        value,
+        customType,
+        customValidators
+      );
+      results.valid = getValidityValue(results.valid, pendingValid);
+      results.valid = getValidityValue(results.valid, customValid);
+      if (type === "string" && typeof pattern === "string") {
+        const { valid: patternValid, error: patternError } = validateValueMatchesPattern(value, pattern);
+        results.valid = getValidityValue(results.valid, patternValid);
+        results.error = patternError;
+      }
+      if (!customValid) {
+        results.error = INVALID_CUSTOM_TYPE;
+      } else if (!results.valid) {
+        results.error = results.error ? results.error : PRIMITIVE_ERROR_MESSAGE_CONSTANTS[type];
+      }
+    }
+  }
+  return results;
+};
+var validateArrayOfTypeInfoFieldValues = (values = [], typeInfoField, typeInfoMap, strict = false, customValidators, typeOperation, relationshipValidationType, itemIsPartial) => {
+  const { type, typeReference } = typeInfoField;
+  const results = {
+    typeName: typeReference ?? type,
+    valid: true,
+    error: "",
+    errorMap: {}
+  };
+  for (let i = 0; i < values.length; i++) {
+    const v = values[i];
+    const {
+      valid: indexValid,
+      error: indexError = "",
+      errorMap: indexErrorMap
+    } = validateTypeInfoFieldValue(
+      v,
+      typeInfoField,
+      typeInfoMap,
+      true,
+      strict,
+      customValidators,
+      typeOperation,
+      relationshipValidationType,
+      itemIsPartial
+    );
+    results.valid = getValidityValue(results.valid, indexValid);
+    results.errorMap[getPathString([i])] = [indexError];
+    for (const er in indexErrorMap) {
+      results.errorMap[getPathString([i, er])] = indexErrorMap[er];
+    }
+  }
+  return results;
+};
+var validateTypeInfoFieldOperationAllowed = (fieldName, fieldOperation, typeInfoField) => {
+  const results = {
+    typeName: null,
+    valid: true,
+    error: "",
+    errorMap: {}
+  };
+  if (fieldOperation && typeInfoField) {
+    const {
+      type,
+      typeReference,
+      tags = {}
+    } = typeInfoField || {};
+    const { deniedOperations: { [fieldOperation]: denied = false } = {} } = tags;
+    results.typeName = typeReference ?? type;
+    results.valid = !denied;
+    if (!results.valid) {
+      results.error = DENIED_TYPE_OPERATIONS[fieldOperation];
+      results.errorMap[fieldName] = [results.error];
+    }
+  }
+  return results;
+};
+var validateTypeOperationAllowed = (typeName, valueFields, typeOperation, typeInfo) => {
+  const results = {
+    typeName,
+    valid: true,
+    error: "",
+    errorMap: {}
+  };
+  const { fields = {}, tags = {} } = typeInfo;
+  const { deniedOperations: { [typeOperation]: denied = false } = {} } = tags;
+  if (denied) {
+    results.valid = false;
+    results.error = DENIED_TYPE_OPERATIONS[typeOperation];
+  } else {
+    for (const vF of valueFields) {
+      const vFieldInfo = fields[vF];
+      const { valid: vFValid, error: vFError } = validateTypeInfoFieldOperationAllowed(vF, typeOperation, vFieldInfo);
+      results.valid = getValidityValue(results.valid, vFValid);
+      if (!vFValid) {
+        results.errorMap[vF] = [vFError];
+      }
+    }
+  }
+  return results;
+};
+var validateTypeInfoValue = (value, typeInfoFullName, typeInfoMap, strict = false, customValidators, typeOperation, relationshipValidationType, itemIsPartial) => {
+  const typeInfo = typeInfoMap[typeInfoFullName];
+  const results = {
+    typeName: typeInfoFullName,
+    valid: !!typeInfo,
+    error: !!typeInfo ? "" : ERROR_MESSAGE_CONSTANTS.TYPE_DOES_NOT_EXIST,
+    errorMap: {}
+  };
+  if (typeInfo) {
+    const { primaryField, fields, unionFieldSets } = typeInfo;
+    if (typeOperation) {
+      const valueFields = typeof value === "object" ? Object.keys(value ?? {}) : [];
+      const {
+        valid: operationValid,
+        error: operationError,
+        errorMap: operationErrorMap
+      } = validateTypeOperationAllowed(
+        typeInfoFullName,
+        valueFields,
+        typeOperation,
+        typeInfo
+      );
+      results.valid = getValidityValue(results.valid, operationValid);
+      results.error = operationError;
+      for (const oE in operationErrorMap) {
+        const existingError = results.errorMap[oE] ?? [];
+        results.errorMap[oE] = existingError ? [...existingError, ...operationErrorMap[oE]] : operationErrorMap[oE];
+      }
+      if (!operationValid && operationError) {
+        results.error = operationError;
+      }
+    }
+    if (unionFieldSets) {
+      const valueFields = Object.keys(value || {});
+      let valid = false;
+      for (const uFS of unionFieldSets) {
+        valid = valueFields.every((vF) => uFS.includes(vF));
+        if (valid) {
+          break;
+        }
+      }
+      if (!valid) {
+        results.valid = false;
+        results.error = ERROR_MESSAGE_CONSTANTS.NO_UNION_TYPE_MATCHED;
+      }
+    } else if (strict) {
+      const knownFields = Object.keys(fields || {});
+      const valueFields = Object.keys(value || {});
+      for (const vF of valueFields) {
+        if (!knownFields.includes(vF)) {
+          results.valid = false;
+          results.errorMap[vF] = [ERROR_MESSAGE_CONSTANTS.INVALID_FIELD];
+        }
+      }
+    }
+    if (fields) {
+      for (const key in fields) {
+        if (typeOperation !== "CREATE" /* CREATE */ || typeof primaryField !== "string" || key !== primaryField) {
+          const typeInfoField = fields[key];
+          const fieldValue = value[key];
+          const {
+            valid: fieldValid,
+            error: fieldError,
+            errorMap: fieldErrorMap
+          } = validateTypeInfoFieldValue(
+            fieldValue,
+            typeInfoField,
+            typeInfoMap,
+            false,
+            strict,
+            customValidators,
+            typeOperation,
+            relationshipValidationType,
+            itemIsPartial
+          );
+          results.valid = getValidityValue(results.valid, fieldValid);
+          results.errorMap[key] = [fieldError];
+          for (const fE in fieldErrorMap) {
+            results.errorMap[getPathString([key, fE])] = fieldErrorMap[fE];
+          }
+        }
+      }
+    }
+    if (!results.valid && !results.error) {
+      results.error = ERROR_MESSAGE_CONSTANTS.INVALID_TYPE;
+    }
+  }
+  return results;
+};
+
+// src/common/TypeParsing/TypeMapping.ts
+var TypeMapping_exports = {};
+__export(TypeMapping_exports, {
+  convertASTToMap: () => convertASTToMap
+});
+var convertASTToMap = (node, map = {}, parentName) => {
+  node.forEachChild((child) => {
+    const { kind: childKind } = child;
+    if (childKind === SyntaxKind.ModuleDeclaration) {
+      const moduleNode = child;
+      const { name: moduleName } = moduleNode;
+      const textModuleName = moduleName.getText();
+      const fullModuleName = parentName ? `${parentName}.${textModuleName}` : textModuleName;
+      convertASTToMap(moduleNode, map, fullModuleName);
+    }
+    if (childKind === SyntaxKind.ModuleBlock) {
+      convertASTToMap(child, map, parentName);
+    }
+    if (childKind === SyntaxKind.TypeAliasDeclaration) {
+      const typeAliasDec = child;
+      const {
+        name: { text: typeName }
+      } = typeAliasDec;
+      const fullTypeName = parentName ? `${parentName}.${typeName}` : typeName;
+      map[fullTypeName] = typeAliasDec;
+    }
+  });
+  return map;
+};
+
+// src/common/TypeParsing/Constants.ts
+var Constants_exports = {};
+__export(Constants_exports, {
+  BUILTIN_TYPE_NAMES: () => BUILTIN_TYPE_NAMES
+});
+var BUILTIN_TYPE_NAMES = [
+  "string",
+  "number",
+  "boolean",
+  "null",
+  "object",
+  "array",
+  "any",
+  "unknown",
+  "never"
+];
+
+// src/common/IdGeneration/index.ts
+var IdGeneration_exports = {};
+__export(IdGeneration_exports, {
+  getSimpleId: () => getSimpleId
+});
+
+// src/common/IdGeneration/getSimpleId.ts
+var LAST_HAST_ID = 0;
+var getBase64EncodedString = (input) => Buffer.from(input).toString("base64");
+var getSimpleId = () => {
+  const hashId = LAST_HAST_ID++;
+  const base64Datetime = getBase64EncodedString(
+    (/* @__PURE__ */ new Date()).toISOString()
+  );
+  const rand1 = Math.random().toString(36).substring(2, 15);
+  const rand2 = Math.random().toString(36).substring(2, 15);
+  return `${hashId}-${base64Datetime}-${rand1}-${rand2}`;
+};
+
+// src/common/SearchTypes.ts
+var SearchTypes_exports = {};
+__export(SearchTypes_exports, {
+  ComparisonOperators: () => ComparisonOperators,
+  LogicalOperators: () => LogicalOperators
+});
+var LogicalOperators = /* @__PURE__ */ ((LogicalOperators2) => {
+  LogicalOperators2["AND"] = "AND";
+  LogicalOperators2["OR"] = "OR";
+  return LogicalOperators2;
+})(LogicalOperators || {});
+var ComparisonOperators = /* @__PURE__ */ ((ComparisonOperators2) => {
+  ComparisonOperators2["EQUALS"] = "EQUALS";
+  ComparisonOperators2["NOT_EQUALS"] = "NOT_EQUALS";
+  ComparisonOperators2["GREATER_THAN"] = "GREATER_THAN";
+  ComparisonOperators2["GREATER_THAN_OR_EQUAL"] = "GREATER_THAN_OR_EQUAL";
+  ComparisonOperators2["LESS_THAN"] = "LESS_THAN";
+  ComparisonOperators2["LESS_THAN_OR_EQUAL"] = "LESS_THAN_OR_EQUAL";
+  ComparisonOperators2["IN"] = "IN";
+  ComparisonOperators2["NOT_IN"] = "NOT_IN";
+  ComparisonOperators2["LIKE"] = "LIKE";
+  ComparisonOperators2["NOT_LIKE"] = "NOT_LIKE";
+  ComparisonOperators2["EXISTS"] = "EXISTS";
+  ComparisonOperators2["NOT_EXISTS"] = "NOT_EXISTS";
+  ComparisonOperators2["IS_NOT_EMPTY"] = "IS_NOT_EMPTY";
+  ComparisonOperators2["IS_EMPTY"] = "IS_EMPTY";
+  ComparisonOperators2["BETWEEN"] = "BETWEEN";
+  ComparisonOperators2["NOT_BETWEEN"] = "NOT_BETWEEN";
+  ComparisonOperators2["CONTAINS"] = "CONTAINS";
+  ComparisonOperators2["NOT_CONTAINS"] = "NOT_CONTAINS";
+  ComparisonOperators2["STARTS_WITH"] = "STARTS_WITH";
+  ComparisonOperators2["ENDS_WITH"] = "ENDS_WITH";
+  ComparisonOperators2["DOES_NOT_START_WITH"] = "DOES_NOT_START_WITH";
+  ComparisonOperators2["DOES_NOT_END_WITH"] = "DOES_NOT_END_WITH";
+  return ComparisonOperators2;
+})(ComparisonOperators || {});
+
+// src/common/SearchUtils.ts
+var SearchUtils_exports = {};
+__export(SearchUtils_exports, {
+  COMPARATORS: () => COMPARATORS,
+  compare: () => compare,
+  compareArray: () => compareArray,
+  getFilterTypeInfoDataItemsBySearchCriteria: () => getFilterTypeInfoDataItemsBySearchCriteria,
+  getSortedItems: () => getSortedItems
+});
+var COMPARATORS = {
+  ["EQUALS" /* EQUALS */]: (criterionValue, criterionValueOptions, fieldValue) => fieldValue === criterionValue,
+  ["NOT_EQUALS" /* NOT_EQUALS */]: (criterionValue, criterionValueOptions, fieldValue) => fieldValue !== criterionValue,
+  ["GREATER_THAN" /* GREATER_THAN */]: (criterionValue, criterionValueOptions, fieldValue) => fieldValue > criterionValue,
+  ["GREATER_THAN_OR_EQUAL" /* GREATER_THAN_OR_EQUAL */]: (criterionValue, criterionValueOptions, fieldValue) => fieldValue >= criterionValue,
+  ["LESS_THAN" /* LESS_THAN */]: (criterionValue, criterionValueOptions, fieldValue) => fieldValue < criterionValue,
+  ["LESS_THAN_OR_EQUAL" /* LESS_THAN_OR_EQUAL */]: (criterionValue, criterionValueOptions, fieldValue) => fieldValue <= criterionValue,
+  ["IN" /* IN */]: (criterionValue, criterionValueOptions, fieldValue) => Array.isArray(criterionValueOptions) && criterionValueOptions.includes(fieldValue),
+  ["NOT_IN" /* NOT_IN */]: (criterionValue, criterionValueOptions, fieldValue) => !Array.isArray(criterionValueOptions) || !criterionValueOptions.includes(fieldValue),
+  ["LIKE" /* LIKE */]: (criterionValue, criterionValueOptions, fieldValue) => `${fieldValue}`.includes(`${criterionValue}`),
+  ["NOT_LIKE" /* NOT_LIKE */]: (criterionValue, criterionValueOptions, fieldValue) => !`${fieldValue}`.includes(`${criterionValue}`),
+  ["EXISTS" /* EXISTS */]: (criterionValue, criterionValueOptions, fieldValue) => fieldValue !== void 0 && fieldValue !== null,
+  ["NOT_EXISTS" /* NOT_EXISTS */]: (criterionValue, criterionValueOptions, fieldValue) => fieldValue === void 0 || fieldValue === null,
+  ["IS_NOT_EMPTY" /* IS_NOT_EMPTY */]: (criterionValue, criterionValueOptions, fieldValue) => fieldValue !== void 0 && fieldValue !== null && fieldValue !== "",
+  ["IS_EMPTY" /* IS_EMPTY */]: (criterionValue, criterionValueOptions, fieldValue) => fieldValue === void 0 || fieldValue === null || fieldValue === "",
+  ["BETWEEN" /* BETWEEN */]: (criterionValue, criterionValueOptions, fieldValue) => Array.isArray(criterionValueOptions) && fieldValue >= criterionValueOptions[0] && fieldValue <= criterionValueOptions[1],
+  ["NOT_BETWEEN" /* NOT_BETWEEN */]: (criterionValue, criterionValueOptions, fieldValue) => !Array.isArray(criterionValueOptions) || fieldValue < criterionValueOptions[0] || fieldValue > criterionValueOptions[1],
+  ["CONTAINS" /* CONTAINS */]: (criterionValue, criterionValueOptions, fieldValue) => Array.isArray(fieldValue) && fieldValue.includes(criterionValue),
+  ["NOT_CONTAINS" /* NOT_CONTAINS */]: (criterionValue, criterionValueOptions, fieldValue) => !Array.isArray(fieldValue) || !fieldValue.includes(criterionValue),
+  ["STARTS_WITH" /* STARTS_WITH */]: (criterionValue, criterionValueOptions, fieldValue) => `${fieldValue}`.startsWith(`${criterionValue}`),
+  ["ENDS_WITH" /* ENDS_WITH */]: (criterionValue, criterionValueOptions, fieldValue) => `${fieldValue}`.endsWith(`${criterionValue}`),
+  ["DOES_NOT_START_WITH" /* DOES_NOT_START_WITH */]: (criterionValue, criterionValueOptions, fieldValue) => !`${fieldValue}`.startsWith(`${criterionValue}`),
+  ["DOES_NOT_END_WITH" /* DOES_NOT_END_WITH */]: (criterionValue, criterionValueOptions, fieldValue) => !`${fieldValue}`.endsWith(`${criterionValue}`)
+};
+var compare = (fieldCriterion, fieldValue) => {
+  const {
+    operator,
+    value: criterionValue,
+    valueOptions: criterionValueOptions
+  } = fieldCriterion;
+  const comparator = operator ? COMPARATORS[operator] : void 0;
+  if (comparator) {
+    return comparator(criterionValue, criterionValueOptions, fieldValue);
+  } else {
+    return false;
+  }
+};
+var compareArray = (fieldCriterion, fieldValue) => {
+  if (Array.isArray(fieldValue)) {
+    const { operator } = fieldCriterion;
+    const isArrayOperator = operator === "CONTAINS" /* CONTAINS */ || operator === "NOT_CONTAINS" /* NOT_CONTAINS */;
+    return isArrayOperator ? compare(fieldCriterion, fieldValue) : fieldValue.some((value) => compare(fieldCriterion, value));
+  } else {
+    return false;
+  }
+};
+var getFilterTypeInfoDataItemsBySearchCriteria = (searchCriteria, items, typeInfoName, typeInfoMap) => {
+  const { fields = {} } = typeInfoMap?.[typeInfoName] || {};
+  const { logicalOperator = "AND" /* AND */, fieldCriteria = [] } = searchCriteria;
+  const filteredItems = [];
+  for (const currentItem of items) {
+    if (typeof currentItem === "object" && currentItem !== null) {
+      let meetsCriteria = true;
+      for (const fieldCriterion of fieldCriteria) {
+        const { fieldName } = fieldCriterion;
+        const { array: isArrayType, typeReference } = fields[fieldName] || {};
+        const currentFieldValue = currentItem[fieldName];
+        if (!typeReference) {
+          const result = isArrayType ? compareArray(
+            fieldCriterion,
+            currentFieldValue
+          ) : compare(fieldCriterion, currentFieldValue);
+          if (logicalOperator === "AND" /* AND */) {
+            meetsCriteria = result;
+            if (!meetsCriteria) {
+              break;
+            }
+          } else {
+            meetsCriteria = meetsCriteria || result;
+            if (meetsCriteria) {
+              break;
+            }
+          }
+        }
+      }
+      if (meetsCriteria) {
+        filteredItems.push(currentItem);
+      }
+    }
+  }
+  return filteredItems;
+};
+var getSortedItems = (sortFields = [], items = []) => {
+  let newItems = [...items];
+  if (sortFields.length > 0) {
+    for (const sortF of sortFields) {
+      const { field, reverse } = sortF;
+      newItems = newItems.sort((a, b) => {
+        const aValue = a[field];
+        const bValue = b[field];
+        if (aValue < bValue) {
+          return reverse ? 1 : -1;
+        } else if (aValue > bValue) {
+          return reverse ? -1 : 1;
+        } else {
+          return 0;
+        }
+      });
+    }
+  }
+  return newItems;
+};
+
+// src/common/StringTransformers.ts
+var StringTransformers_exports = {};
+__export(StringTransformers_exports, {
+  CUSTOM_STRING_TRANSFORMERS: () => CUSTOM_STRING_TRANSFORMERS,
+  STRING_TRANSFORMERS: () => STRING_TRANSFORMERS,
+  transformValueToString: () => transformValueToString
+});
+var transformWhenStringExpected = (value) => (value ?? false) === false ? "" : `${value}`;
+var STRING_TRANSFORMERS = {
+  string: transformWhenStringExpected,
+  number: transformWhenStringExpected,
+  boolean: (value) => value ? "true" : "false"
+};
+var CUSTOM_STRING_TRANSFORMERS = {
+  date: (value) => value.toISOString(),
+  time: (value) => value.toISOString(),
+  datetime: (value) => value.toISOString(),
+  duration: (value) => value.toString(),
+  reference: (value) => value.toString(),
+  unknown: (value) => value.toString()
+};
+var transformValueToString = (value, typeKeyword, customType) => {
+  const transformer = customType ? CUSTOM_STRING_TRANSFORMERS[customType] : STRING_TRANSFORMERS[typeKeyword];
+  return transformer ? transformer(value) : "";
+};
+
+// src/common/ItemRelationshipInfoTypes.ts
+var ItemRelationshipInfoTypes_exports = {};
+__export(ItemRelationshipInfoTypes_exports, {
+  ItemRelationshipInfoIdentifyingKeys: () => ItemRelationshipInfoIdentifyingKeys,
+  ItemRelationshipInfoKeys: () => ItemRelationshipInfoKeys
+});
+var ItemRelationshipInfoKeys = /* @__PURE__ */ ((ItemRelationshipInfoKeys2) => {
+  ItemRelationshipInfoKeys2["fromTypeName"] = "fromTypeName";
+  ItemRelationshipInfoKeys2["fromTypeFieldName"] = "fromTypeFieldName";
+  ItemRelationshipInfoKeys2["fromTypePrimaryFieldValue"] = "fromTypePrimaryFieldValue";
+  ItemRelationshipInfoKeys2["toTypePrimaryFieldValue"] = "toTypePrimaryFieldValue";
+  return ItemRelationshipInfoKeys2;
+})(ItemRelationshipInfoKeys || {});
+var ItemRelationshipInfoIdentifyingKeys = /* @__PURE__ */ ((ItemRelationshipInfoIdentifyingKeys2) => {
+  ItemRelationshipInfoIdentifyingKeys2["id"] = "id";
+  return ItemRelationshipInfoIdentifyingKeys2;
+})(ItemRelationshipInfoIdentifyingKeys || {});
+
+// src/common/ItemRelationships/index.ts
+var ItemRelationships_exports = {};
+__export(ItemRelationships_exports, {
+  TYPE_INFO_ORM_RELATIONSHIP_ERRORS: () => TYPE_INFO_ORM_RELATIONSHIP_ERRORS,
+  validateRelationshipItem: () => validateRelationshipItem
+});
+
+// src/common/ItemRelationships/ItemRelationshipValidation.ts
+var TYPE_INFO_ORM_RELATIONSHIP_ERRORS = {
+  INVALID_RELATIONSHIP_ITEM: "INVALID_RELATIONSHIP_ITEM",
+  INVALID_RELATIONSHIP_ITEM_FIELD: "INVALID_RELATIONSHIP_ITEM_FIELD"
+};
+var validateRelationshipItem = (relationshipItem, omitFields = []) => {
+  const { fromTypeName } = relationshipItem;
+  const results = {
+    typeName: fromTypeName,
+    valid: true,
+    error: "",
+    errorMap: {}
+  };
+  if (typeof relationshipItem === "object" && relationshipItem !== null) {
+    const relKeyValues = Object.values(ItemRelationshipInfoKeys);
+    for (const rKV of relKeyValues) {
+      const universalRKV = rKV;
+      const omitRKV = omitFields.includes(rKV);
+      if (!omitRKV && (typeof relationshipItem[universalRKV] !== "string" || !relationshipItem[universalRKV])) {
+        results.valid = false;
+        results.error = TYPE_INFO_ORM_RELATIONSHIP_ERRORS.INVALID_RELATIONSHIP_ITEM;
+        results.errorMap[rKV] = [
+          TYPE_INFO_ORM_RELATIONSHIP_ERRORS.INVALID_RELATIONSHIP_ITEM_FIELD
+        ];
+      }
+    }
+  } else {
+    results.valid = false;
+    results.error = TYPE_INFO_ORM_RELATIONSHIP_ERRORS.INVALID_RELATIONSHIP_ITEM;
+  }
+  return results;
+};
+
+// src/common/Testing/index.ts
+var Testing_exports = {};
+__export(Testing_exports, {
+  OPERATIONS: () => OPERATIONS,
+  TestComparisonOperation: () => TestComparisonOperation,
+  compare: () => compare2,
+  executeTestingCommand: () => executeTestingCommand,
+  generateTestsForFile: () => generateTestsForFile,
+  getResolvedConditions: () => getResolvedConditions,
+  getResolvedTestConfig: () => getResolvedTestConfig,
+  getSetupInstance: () => getSetupInstance,
+  getTestConfig: () => getTestConfig,
+  getTestFunction: () => getTestFunction,
+  mergeTestResults: () => mergeTestResults,
+  runTest: () => runTest,
+  runTestsForFile: () => runTestsForFile
+});
+
+// src/common/Testing/Types.ts
+var TestComparisonOperation = /* @__PURE__ */ ((TestComparisonOperation2) => {
+  TestComparisonOperation2["EQUALS"] = "===";
+  TestComparisonOperation2["NOT_EQUALS"] = "!==";
+  TestComparisonOperation2["IN"] = "IN";
+  TestComparisonOperation2["ARRAY_CONTAINS"] = "ARRAY_CONTAINS";
+  TestComparisonOperation2["BETWEEN"] = "BETWEEN";
+  TestComparisonOperation2["CONTAINS"] = "CONTAINS";
+  TestComparisonOperation2["REGEX"] = "REGEX";
+  TestComparisonOperation2["EXT_REGEX"] = "EXT_REGEX";
+  TestComparisonOperation2["DEEP_EQUALS"] = "DEEP_EQUALS";
+  TestComparisonOperation2["ARRAY_EQUALS"] = "ARRAY_EQUALS";
+  return TestComparisonOperation2;
+})(TestComparisonOperation || {});
+var importModule = async (modulePath) => {
+  const moduleUrl = pathToFileURL(modulePath);
+  return import(moduleUrl.href);
+};
+var stringifyOutput = (value) => JSON.stringify(
+  value,
+  function(_key, value2) {
+    return typeof value2 === "function" ? "[Function]" : value2;
+  },
+  2
+);
+var OPERATIONS = {
+  ["===" /* EQUALS */]: (a, b) => a === b,
+  ["!==" /* NOT_EQUALS */]: (a, b) => a !== b,
+  ["IN" /* IN */]: (a, b) => Array.isArray(b) && b.includes(a),
+  ["BETWEEN" /* BETWEEN */]: (a, b) => {
+    if (Array.isArray(b) && b.length === 2 && typeof b[0] === "number" && typeof b[1] === "number") {
+      return typeof a === "number" && a >= b[0] && a <= b[1];
+    }
+    throw new Error("BETWEEN requires an array of two numbers as expectation.");
+  },
+  ["CONTAINS" /* CONTAINS */]: (a, b) => typeof a === "string" && typeof b === "string" && a.includes(b),
+  ["REGEX" /* REGEX */]: (a, b) => {
+    if (typeof b === "object" && b !== null && "pattern" in b) {
+      const { pattern, flags } = b;
+      try {
+        const regex = new RegExp(pattern, flags);
+        return typeof a === "string" && regex.test(a);
+      } catch (err) {
+        throw new Error(`Invalid REGEX: ${err.message}`);
+      }
+    }
+    throw new Error(
+      "REGEX requires an expectation with 'pattern' and optional 'flags'."
+    );
+  },
+  ["EXT_REGEX" /* EXT_REGEX */]: (a, b) => {
+    if (typeof b === "object" && b !== null && "pattern" in b) {
+      const { pattern, flags } = b;
+      const buildRegexFromPattern = (pattern2, flags2 = "") => {
+        if (!Array.isArray(pattern2)) {
+          throw new Error("EXT_REGEX pattern must be an array of objects.");
+        }
+        const regexBody = pattern2.map(({ value, escaped }) => {
+          if (typeof value !== "string") {
+            throw new Error(
+              "Each pattern element must have a string 'value'."
+            );
+          }
+          return escaped ? value.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&") : value;
+        }).join("");
+        return new RegExp(regexBody, flags2);
+      };
+      try {
+        const regex = buildRegexFromPattern(pattern, flags);
+        return typeof a === "string" && regex.test(a);
+      } catch (err) {
+        throw new Error(`Invalid EXT_REGEX: ${err.message}`);
+      }
+    }
+    throw new Error(
+      "EXT_REGEX requires an expectation with 'pattern' as an array of PatternElement and optional 'flags'."
+    );
+  },
+  ["DEEP_EQUALS" /* DEEP_EQUALS */]: (a, b) => {
+    if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {
+      return JSON.stringify(a) === JSON.stringify(b);
+    }
+    return false;
+  },
+  ["ARRAY_CONTAINS" /* ARRAY_CONTAINS */]: (a, b) => {
+    if (Array.isArray(a)) {
+      return a.includes(b);
+    }
+    throw new Error("ARRAY_CONTAINS requires an array as the first argument.");
+  },
+  ["ARRAY_EQUALS" /* ARRAY_EQUALS */]: (a, b) => {
+    if (Array.isArray(a) && Array.isArray(b)) {
+      return JSON.stringify(a) === JSON.stringify(b);
+    }
+    throw new Error("ARRAY_EQUALS requires two arrays as arguments.");
+  }
+};
+var compare2 = (result, expectation, operation = "===" /* EQUALS */) => {
+  const op = OPERATIONS[operation];
+  if (!op) {
+    throw new Error(`Unsupported operation: ${operation}`);
+  }
+  return op(result, expectation);
+};
+var getResolvedConditions = async (testFilePath, targetTestIndex, targetTestExport, conditions, isSetup = false) => {
+  if (Array.isArray(conditions)) {
+    return conditions;
+  } else if (typeof conditions === "object" && conditions !== null) {
+    const { file, export: targetConditionExport } = conditions;
+    const modulePath = Path.resolve(Path.dirname(testFilePath), file);
+    const targetModule = await importModule(modulePath);
+    const conditionArray = targetModule[targetConditionExport];
+    if (Array.isArray(conditionArray)) {
+      return conditionArray;
+    }
+  }
+  throw new Error(
+    `Invalid conditions for TEST${isSetup ? " SETUP" : ""} ${targetTestIndex + 1} (${targetTestExport}) in ${testFilePath}`
+  );
+};
+var getSetupInstance = async (testFilePath, targetTestIndex, targetTestExport, test, module) => {
+  const { setup } = test;
+  if (!setup) return module;
+  const { conditions: baseConditions, export: targetSetupExport } = setup;
+  const setupFunction = module[targetSetupExport];
+  const conditions = await getResolvedConditions(
+    testFilePath,
+    targetTestIndex,
+    targetTestExport,
+    baseConditions,
+    true
+  );
+  if (typeof setupFunction !== "function") {
+    throw new Error(`Setup export "${setup.export}" is not a function.`);
+  }
+  return setup.instantiate ? new setupFunction(...conditions) : await setupFunction(...conditions);
+};
+var getTestFunction = async (testFilePath, file, targetTestIndex, test, targetModule) => {
+  const { export: targetExport } = test;
+  if (!targetExport) {
+    throw new Error(
+      `Invalid test export (${targetExport}) for TEST ${targetTestIndex + 1} in ${testFilePath}`
+    );
+  }
+  const instance = await getSetupInstance(
+    testFilePath,
+    targetTestIndex,
+    targetExport,
+    test,
+    targetModule
+  );
+  const testFunction = instance[targetExport];
+  if (typeof testFunction !== "function") {
+    throw new Error(
+      `Export "${targetExport}" from "${file}", declared in TEST ${targetTestIndex + 1}, is not a function.`
+    );
+  }
+  return testFunction;
+};
+var getTestConfig = async (testFilePath) => {
+  const testConfig = JSON.parse(
+    await promises.readFile(testFilePath, "utf8")
+  );
+  return testConfig;
+};
+var getResolvedTestConfig = async (testFilePath) => {
+  const { file, tests } = await getTestConfig(testFilePath);
+  if (!file) {
+    throw new Error(`Invalid test configuration in ${testFilePath}`);
+  }
+  const modulePath = Path.resolve(Path.dirname(testFilePath), file);
+  const targetModule = await importModule(modulePath);
+  return {
+    file,
+    targetModule,
+    tests
+  };
+};
+var mergeTestResults = (...results) => results.reduce(
+  ({
+    messages: accMessages = [],
+    generated: accGenerated = [],
+    passes: accPasses = [],
+    failures: accFailures = [],
+    errors: accErrors = []
+  }, {
+    messages = [],
+    generated = [],
+    passes = [],
+    failures = [],
+    errors = []
+  }) => ({
+    messages: [...accMessages, ...messages],
+    generated: [...accGenerated, ...generated],
+    passes: [...accPasses, ...passes],
+    failures: [...accFailures, ...failures],
+    errors: [...accErrors, ...errors]
+  }),
+  { messages: [], passes: [], failures: [], errors: [] }
+);
+var runTest = async (testFilePath, testFunction, test, index, targetExport, report) => {
+  const {
+    conditions: baseConditions,
+    expectation,
+    operation,
+    expectUndefined
+  } = test;
+  const conditions = await getResolvedConditions(
+    testFilePath,
+    index,
+    targetExport,
+    baseConditions
+  );
+  try {
+    const result = await testFunction(...conditions);
+    const passed = expectUndefined || compare2(result, expectation, operation);
+    if (passed) {
+      report({
+        passes: [`Test ${index + 1} (${targetExport})`]
+      });
+    } else {
+      report({
+        failures: [
+          `Test ${index + 1} (${targetExport}):
+
+Result:
+
+${stringifyOutput(result)}`
+        ]
+      });
+    }
+  } catch (err) {
+    report({
+      errors: [
+        `Test ${index + 1} (${targetExport}):
+
+Error:
+
+${err.message}`
+      ]
+    });
+  }
+};
+var generateTestsForFile = async (testFilePath, report) => {
+  try {
+    const { file, targetModule, tests } = await getResolvedTestConfig(testFilePath);
+    report({
+      messages: [`Generating expectations for tests in ${testFilePath}`]
+    });
+    const generatedTests = [];
+    let hasNewExpectations = false;
+    for (let i = 0; i < tests.length; i++) {
+      const test = tests[i];
+      const {
+        export: targetExport,
+        conditions: baseConditions,
+        expectation,
+        operation,
+        expectUndefined
+      } = test;
+      const conditions = await getResolvedConditions(
+        testFilePath,
+        i,
+        targetExport,
+        baseConditions
+      );
+      if (expectation !== void 0 || expectUndefined) {
+        generatedTests.push(test);
+      } else {
+        const testFunction = await getTestFunction(
+          testFilePath,
+          file,
+          i,
+          test,
+          targetModule
+        );
+        const result = await testFunction(...conditions);
+        report({
+          generated: [
+            `Expectation for TEST ${i + 1} (${targetExport}):
+
+${stringifyOutput(result)}`
+          ]
+        });
+        generatedTests.push({
+          ...test,
+          expectation: result,
+          operation: operation || "===" /* EQUALS */
+        });
+        hasNewExpectations = true;
+      }
+    }
+    if (hasNewExpectations) {
+      const updatedTestConfig = { file, tests: generatedTests };
+      await promises.writeFile(
+        testFilePath,
+        JSON.stringify(updatedTestConfig, null, 2)
+      );
+      report({ messages: [`Updated test file saved to ${testFilePath}`] });
+    } else {
+      report({
+        messages: [`No new expectations were generated for ${testFilePath}`]
+      });
+    }
+  } catch (err) {
+    report({
+      errors: [`Error processing test file ${testFilePath}:
+
+${err.message}`]
+    });
+  }
+};
+var runTestsForFile = async (testFilePath, report) => {
+  try {
+    const { file, targetModule, tests } = await getResolvedTestConfig(testFilePath);
+    report({
+      messages: [`Running tests from ${testFilePath}`]
+    });
+    for (const [index, test] of tests.entries()) {
+      const { export: targetExport } = test;
+      const testFunction = await getTestFunction(
+        testFilePath,
+        file,
+        index,
+        test,
+        targetModule
+      );
+      await runTest(
+        testFilePath,
+        testFunction,
+        test,
+        index,
+        targetExport,
+        report
+      );
+    }
+  } catch (err) {
+    report({
+      errors: [`Error processing test file ${testFilePath}: ${err.message}`]
+    });
+  }
+};
+var executeTestingCommand = async (testFiles, generateMode = false, report) => {
+  const completeMessage = generateMode ? "Test generation complete." : "Testing complete.";
+  try {
+    for (const testFile of testFiles) {
+      const resolvedTestFile = Path.resolve(testFile);
+      if (generateMode) {
+        await generateTestsForFile(resolvedTestFile, report);
+      } else {
+        await runTestsForFile(resolvedTestFile, report);
+      }
+    }
+    report({
+      messages: [completeMessage]
+    });
+  } catch (err) {
+    report({ errors: [`Error running tests:
+
+${err.message}`] });
+  }
+};
+
+// src/common/Logging/index.ts
+var Logging_exports = {};
+__export(Logging_exports, {
+  LOGGING_MESSAGES: () => LOGGING_MESSAGES,
+  logFunctionCall: () => logFunctionCall
+});
+
+// src/common/Logging/Utils.ts
+var LOGGING_MESSAGES = /* @__PURE__ */ ((LOGGING_MESSAGES2) => {
+  LOGGING_MESSAGES2["LOGGING_FUNCTION_CALL"] = "LOGGING_FUNCTION_CALL";
+  LOGGING_MESSAGES2["INPUT"] = "INPUT";
+  LOGGING_MESSAGES2["OUTPUT"] = "OUTPUT";
+  LOGGING_MESSAGES2["ERROR"] = "ERROR";
+  return LOGGING_MESSAGES2;
+})(LOGGING_MESSAGES || {});
+var logFunctionCall = async (label, args, functionRef, enabled) => {
+  if (enabled) {
+    console.log(
+      "LOGGING_FUNCTION_CALL" /* LOGGING_FUNCTION_CALL */,
+      "INPUT" /* INPUT */,
+      label,
+      ":",
+      JSON.stringify(args, null, 2)
+    );
+  }
+  try {
+    const result = await functionRef(...args);
+    if (enabled) {
+      console.log(
+        "LOGGING_FUNCTION_CALL" /* LOGGING_FUNCTION_CALL */,
+        "OUTPUT" /* OUTPUT */,
+        label,
+        ":",
+        JSON.stringify(result, null, 2)
+      );
+    }
+    return result;
+  } catch (error) {
+    if (enabled) {
+      console.error(
+        "LOGGING_FUNCTION_CALL" /* LOGGING_FUNCTION_CALL */,
+        "ERROR" /* ERROR */,
+        label,
+        ":",
+        error
+      );
+    }
+    throw error;
+  }
+};
+
+export { IdGeneration_exports as IDGeneration, ItemRelationshipInfoTypes_exports as ItemRelationshipInfoTypes, ItemRelationships_exports as ItemRelationships, Logging_exports as Logging, Routing_exports as Routing, SearchTypes_exports as SearchTypes, SearchUtils_exports as SearchUtils, StringTransformers_exports as StringTransformers, Testing_exports as Testing, TypeParsing_exports as TypeParsing };