@resistdesign/voltra 3.0.0-alpha.16 → 3.0.0-alpha.18

package/common/index.js

@@ -1,19 +1,3 @@
-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/CommandLine/index.ts
-var CommandLine_exports = {};
-__export(CommandLine_exports, {
-  collectRequiredEnvironmentVariables: () => collectRequiredEnvironmentVariables
-});
-
 // src/common/CommandLine/collectRequiredEnvironmentVariables.ts
 var collectRequiredEnvironmentVariables = (varNames) => {
   const result = {};
@@ -43,40 +27,7 @@ ${missingEnvVars.map((vN) => `- ${vN}`).join(`
   return result;
 };
 
-// src/common/TypeParsing/index.ts
-var TypeParsing_exports = {};
-__export(TypeParsing_exports, {
-  Constants: () => Constants_exports,
-  TypeInfo: () => TypeInfo_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";
@@ -85,92 +36,29 @@ var TypeOperation = /* @__PURE__ */ ((TypeOperation2) => {
   return TypeOperation2;
 })(TypeOperation || {});
 
+// src/common/TypeInfoORM/Types.ts
+var TypeInfoORMServiceError = /* @__PURE__ */ ((TypeInfoORMServiceError2) => {
+  TypeInfoORMServiceError2["NO_DRIVERS_SUPPLIED"] = "NO_DRIVERS_SUPPLIED";
+  TypeInfoORMServiceError2["NO_RELATIONSHIP_DRIVERS_SUPPLIED"] = "NO_RELATIONSHIP_DRIVERS_SUPPLIED";
+  TypeInfoORMServiceError2["NO_PRIMARY_FIELD_VALUE_SUPPLIED"] = "NO_PRIMARY_FIELD_VALUE_SUPPLIED";
+  TypeInfoORMServiceError2["INVALID_DRIVER"] = "INVALID_DRIVER";
+  TypeInfoORMServiceError2["INVALID_RELATIONSHIP_DRIVER"] = "INVALID_RELATIONSHIP_DRIVER";
+  TypeInfoORMServiceError2["INVALID_TYPE_INFO"] = "INVALID_TYPE_INFO";
+  TypeInfoORMServiceError2["TYPE_INFO_MISSING_PRIMARY_FIELD"] = "TYPE_INFO_MISSING_PRIMARY_FIELD";
+  TypeInfoORMServiceError2["INVALID_RELATIONSHIP"] = "INVALID_RELATIONSHIP";
+  TypeInfoORMServiceError2["INVALID_OPERATION"] = "INVALID_OPERATION";
+  TypeInfoORMServiceError2["MISSING_ACCESSING_ROLE"] = "MISSING_ACCESSING_ROLE";
+  TypeInfoORMServiceError2["INDEXING_UNSUPPORTED_CRITERIA"] = "INDEXING_UNSUPPORTED_CRITERIA";
+  TypeInfoORMServiceError2["INDEXING_UNSUPPORTED_COMBINATION"] = "INDEXING_UNSUPPORTED_COMBINATION";
+  TypeInfoORMServiceError2["INDEXING_MISSING_INDEX_FIELD"] = "INDEXING_MISSING_INDEX_FIELD";
+  TypeInfoORMServiceError2["INDEXING_MISSING_BACKEND"] = "INDEXING_MISSING_BACKEND";
+  TypeInfoORMServiceError2["INDEXING_REQUIRES_CRITERIA"] = "INDEXING_REQUIRES_CRITERIA";
+  return TypeInfoORMServiceError2;
+})(TypeInfoORMServiceError || {});
+
 // 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) => {
@@ -522,761 +410,4 @@ var validateTypeInfoValue = (value, typeInfoFullName, typeInfoMap, strict = fals
   return results;
 };
 
-// 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 textEncoder = new TextEncoder();
-var bytesToBinaryString = (bytes) => {
-  let out = "";
-  for (let i = 0; i < bytes.length; i++) {
-    out += String.fromCharCode(bytes[i]);
-  }
-  return out;
-};
-var getBase64EncodedString = (input) => {
-  const bytes = textEncoder.encode(input);
-  let base64 = "";
-  if (typeof globalThis.btoa === "function") {
-    const binary = bytesToBinaryString(bytes);
-    base64 = globalThis.btoa(binary);
-  } else {
-    const anyGlobal = globalThis;
-    if (typeof anyGlobal.Buffer === "function") {
-      base64 = anyGlobal.Buffer.from(bytes).toString("base64");
-    } else {
-      throw new Error("No base64 encoder available (need btoa or Buffer).");
-    }
-  }
-  return 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",
-  MISSING_RELATIONSHIP_ITEM_FIELD: "MISSING_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 (
-        // Invalid Field Value
-        universalRKV in relationshipItem && typeof relationshipItem[universalRKV] !== "string" || omitRKV && universalRKV in relationshipItem
-      ) {
-        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 if (
-        // Missing Field
-        !omitRKV && (!(universalRKV in relationshipItem) || !relationshipItem[universalRKV])
-      ) {
-        results.valid = false;
-        results.error = TYPE_INFO_ORM_RELATIONSHIP_ERRORS.INVALID_RELATIONSHIP_ITEM;
-        results.errorMap[rKV] = [
-          TYPE_INFO_ORM_RELATIONSHIP_ERRORS.MISSING_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;
-  }
-};
-
-// src/common/TypeInfoORM/Types.ts
-var TypeInfoORMServiceError = /* @__PURE__ */ ((TypeInfoORMServiceError2) => {
-  TypeInfoORMServiceError2["NO_DRIVERS_SUPPLIED"] = "NO_DRIVERS_SUPPLIED";
-  TypeInfoORMServiceError2["NO_RELATIONSHIP_DRIVERS_SUPPLIED"] = "NO_RELATIONSHIP_DRIVERS_SUPPLIED";
-  TypeInfoORMServiceError2["NO_PRIMARY_FIELD_VALUE_SUPPLIED"] = "NO_PRIMARY_FIELD_VALUE_SUPPLIED";
-  TypeInfoORMServiceError2["INVALID_DRIVER"] = "INVALID_DRIVER";
-  TypeInfoORMServiceError2["INVALID_RELATIONSHIP_DRIVER"] = "INVALID_RELATIONSHIP_DRIVER";
-  TypeInfoORMServiceError2["INVALID_TYPE_INFO"] = "INVALID_TYPE_INFO";
-  TypeInfoORMServiceError2["TYPE_INFO_MISSING_PRIMARY_FIELD"] = "TYPE_INFO_MISSING_PRIMARY_FIELD";
-  TypeInfoORMServiceError2["INVALID_RELATIONSHIP"] = "INVALID_RELATIONSHIP";
-  TypeInfoORMServiceError2["INVALID_OPERATION"] = "INVALID_OPERATION";
-  TypeInfoORMServiceError2["MISSING_ACCESSING_ROLE"] = "MISSING_ACCESSING_ROLE";
-  TypeInfoORMServiceError2["INDEXING_UNSUPPORTED_CRITERIA"] = "INDEXING_UNSUPPORTED_CRITERIA";
-  TypeInfoORMServiceError2["INDEXING_UNSUPPORTED_COMBINATION"] = "INDEXING_UNSUPPORTED_COMBINATION";
-  TypeInfoORMServiceError2["INDEXING_MISSING_INDEX_FIELD"] = "INDEXING_MISSING_INDEX_FIELD";
-  TypeInfoORMServiceError2["INDEXING_MISSING_BACKEND"] = "INDEXING_MISSING_BACKEND";
-  TypeInfoORMServiceError2["INDEXING_REQUIRES_CRITERIA"] = "INDEXING_REQUIRES_CRITERIA";
-  return TypeInfoORMServiceError2;
-})(TypeInfoORMServiceError || {});
-
-export { CommandLine_exports as CommandLine, DENIED_TYPE_OPERATIONS, ERROR_MESSAGE_CONSTANTS, IdGeneration_exports as IDGeneration, INVALID_CUSTOM_TYPE, ItemRelationshipInfoTypes_exports as ItemRelationshipInfoTypes, ItemRelationships_exports as ItemRelationships, Logging_exports as Logging, PRIMITIVE_ERROR_MESSAGE_CONSTANTS, RelationshipValidationType, Routing_exports as Routing, SearchTypes_exports as SearchTypes, SearchUtils_exports as SearchUtils, StringTransformers_exports as StringTransformers, TYPE_KEYWORD_VALIDATORS, Testing_exports as Testing, TypeInfoORMServiceError, TypeOperation, TypeParsing_exports as TypeParsing, collectRequiredEnvironmentVariables, getValidityValue, hasValue, validateArrayOfTypeInfoFieldValues, validateCustomType, validateKeywordType, validateTypeInfoFieldOperationAllowed, validateTypeInfoFieldValue, validateTypeInfoValue, validateTypeOperationAllowed, validateValueMatchesPattern };
+export { DENIED_TYPE_OPERATIONS, ERROR_MESSAGE_CONSTANTS, INVALID_CUSTOM_TYPE, PRIMITIVE_ERROR_MESSAGE_CONSTANTS, RelationshipValidationType, TYPE_KEYWORD_VALIDATORS, TypeInfoORMServiceError, TypeOperation, collectRequiredEnvironmentVariables, getValidityValue, hasValue, validateArrayOfTypeInfoFieldValues, validateCustomType, validateKeywordType, validateTypeInfoFieldOperationAllowed, validateTypeInfoFieldValue, validateTypeInfoValue, validateTypeOperationAllowed, validateValueMatchesPattern };