@resistdesign/voltra 3.0.0-alpha.3 → 3.0.0-alpha.4

package/common/index.js

@@ -0,0 +1,1760 @@
+import { SyntaxKind, isLiteralTypeNode, isStringLiteral, isNumericLiteral, createSourceFile, ScriptTarget } 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,
+  getTypeInfoMapFromTypeScript: () => getTypeInfoMapFromTypeScript
+});
+
+// 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/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/ParsingUtils/extractCommentTags.ts
+var TAG_NAME_PATH_DELIMITER = ".";
+var getFlatTagValue = (tagValue) => {
+  if (typeof tagValue === "undefined") {
+    return "";
+  } else if (Array.isArray(tagValue)) {
+    const valueNodeArray = tagValue;
+    const valueList = [];
+    for (let i = 0; i < valueNodeArray.length; i++) {
+      const { text } = valueNodeArray[i];
+      valueList.push(getFlatTagValue(text));
+    }
+    return valueList.join(" ");
+  } else {
+    return `${tagValue}`;
+  }
+};
+var getTagNameAndValue = (tag) => {
+  let name = tag.tagName.text, value = getFlatTagValue(tag.comment);
+  if (value.startsWith(TAG_NAME_PATH_DELIMITER)) {
+    const extendedTagNameEndIndex = value.indexOf(" ");
+    const hasActualValue = extendedTagNameEndIndex !== -1;
+    name += hasActualValue ? value.slice(0, extendedTagNameEndIndex) : value;
+    value = hasActualValue ? value.slice(extendedTagNameEndIndex + 1) : "";
+  }
+  if (value === "") {
+    value = "true";
+  }
+  return {
+    name,
+    value
+  };
+};
+var getObjectWithValueAppliedToPath = (path = [], value, baseObject) => {
+  let baseParentObject = void 0, currentParent = void 0;
+  if (path.length === 0) {
+    baseParentObject = value;
+  } else {
+    for (let i = 0; i < path.length; i++) {
+      const pathPart = path[i];
+      const cleanPathPart = typeof pathPart === "number" ? pathPart : `${typeof pathPart !== "undefined" ? pathPart : ""}`;
+      const isNum = typeof cleanPathPart === "number";
+      let newCurrentParent = void 0;
+      if (i === 0) {
+        if (!baseObject) {
+          baseParentObject = isNum ? [] : {};
+        } else {
+          baseParentObject = isNum ? [...Array.isArray(baseObject) ? baseObject : []] : {
+            ...typeof baseObject === "object" ? baseObject : {}
+          };
+        }
+        currentParent = baseParentObject;
+      }
+      if (i < path.length - 1) {
+        const existingNewCurrentParent = currentParent[cleanPathPart];
+        newCurrentParent = isNum ? [
+          ...Array.isArray(existingNewCurrentParent) ? existingNewCurrentParent : []
+        ] : {
+          ...typeof existingNewCurrentParent === "object" ? existingNewCurrentParent : {}
+        };
+        currentParent[cleanPathPart] = newCurrentParent;
+        currentParent = newCurrentParent;
+      } else {
+        currentParent[cleanPathPart] = value;
+      }
+    }
+  }
+  return baseParentObject;
+};
+var extractCommentTags = (node) => {
+  const jsDocComments = node["jsDoc"];
+  let commentTags = {};
+  if (jsDocComments) {
+    jsDocComments.forEach((jsDoc) => {
+      const tags = jsDoc.tags;
+      if (tags) {
+        tags.forEach((tag) => {
+          const { name: tagName, value: tagValue } = getTagNameAndValue(tag);
+          const potentialJSONValue = getPotentialJSONValue(tagValue);
+          commentTags = getObjectWithValueAppliedToPath(
+            getPathArray(tagName, TAG_NAME_PATH_DELIMITER),
+            potentialJSONValue,
+            commentTags
+          );
+        });
+      }
+    });
+  }
+  return commentTags;
+};
+var extractLiteralValues = (node) => {
+  const literalValues = [];
+  let detectedTypeKeyword;
+  for (const type of node.types) {
+    if (isLiteralTypeNode(type)) {
+      const literal = type.literal;
+      if (isStringLiteral(literal)) {
+        if (!detectedTypeKeyword) detectedTypeKeyword = "string";
+        if (detectedTypeKeyword === "string") {
+          literalValues.push(literal.text);
+        }
+      } else if (isNumericLiteral(literal)) {
+        if (!detectedTypeKeyword) detectedTypeKeyword = "number";
+        if (detectedTypeKeyword === "number") {
+          literalValues.push(Number(literal.text));
+        }
+      } else if (literal.kind === SyntaxKind.TrueKeyword || literal.kind === SyntaxKind.FalseKeyword) {
+        if (!detectedTypeKeyword) detectedTypeKeyword = "boolean";
+        if (detectedTypeKeyword === "boolean") {
+          literalValues.push(literal.kind === SyntaxKind.TrueKeyword);
+        }
+      } else if (literal.kind === SyntaxKind.NullKeyword) {
+        literalValues.push(null);
+      }
+    } else {
+      return void 0;
+    }
+  }
+  return literalValues.length ? { values: literalValues, type: detectedTypeKeyword } : void 0;
+};
+
+// src/common/TypeParsing/ParsingUtils/checkUnionType.ts
+var checkUnionType = (unionType) => {
+  const extracted = extractLiteralValues(unionType);
+  let typeKeyword = "string";
+  let options;
+  if (extracted) {
+    options = extracted.values;
+    typeKeyword = extracted.type;
+  }
+  return { options: options || [], typeKeyword };
+};
+var getTypeKeyword = (node) => {
+  switch (node.kind) {
+    case SyntaxKind.StringKeyword:
+      return "string";
+    case SyntaxKind.NumberKeyword:
+      return "number";
+    case SyntaxKind.BooleanKeyword:
+      return "boolean";
+    default:
+      return "string";
+  }
+};
+
+// src/common/TypeParsing/ParsingUtils/checkType.ts
+var checkType = (node) => {
+  let typeReference;
+  let isArray = false;
+  let typeKeyword;
+  let options;
+  if (node.kind === SyntaxKind.TypeReference) {
+    typeReference = node.typeName.getText();
+    typeKeyword = "string";
+  } else if (node.kind === SyntaxKind.ArrayType) {
+    isArray = true;
+    const elementType = node.elementType;
+    const {
+      typeReference: elementReference,
+      isArray: elementIsArray,
+      typeKeyword: elementKeyword,
+      options: elementOptions
+    } = checkType(elementType);
+    typeReference = elementReference;
+    isArray = !!elementIsArray;
+    typeKeyword = elementKeyword || "string";
+    options = elementOptions;
+  } else if (node.kind === SyntaxKind.UnionType) {
+    const { types: unionTypes } = node;
+    const { options: unionOptions, typeKeyword: unionTypeKeyword } = checkUnionType(node);
+    options = unionOptions;
+    typeKeyword = unionTypeKeyword;
+    if (!options) {
+      typeKeyword = getTypeKeyword(unionTypes[0]);
+    }
+  } else if (node.kind === SyntaxKind.ParenthesizedType) {
+    const {
+      typeReference: parenthesizedReference,
+      isArray: parenthesizedIsArray,
+      typeKeyword: parenthesizedKeyword,
+      options: parenthesizedOptions
+    } = checkType(node.type);
+    typeReference = parenthesizedReference;
+    isArray = !!parenthesizedIsArray;
+    typeKeyword = parenthesizedKeyword || "string";
+    options = parenthesizedOptions;
+  } else {
+    typeKeyword = getTypeKeyword(node);
+  }
+  return { typeReference, isArray, typeKeyword, options };
+};
+
+// src/common/TypeParsing/ParsingUtils/extractTypeDetails.ts
+var extractTypeDetails = (type) => {
+  const { isArray, typeReference, options, typeKeyword } = checkType(type);
+  return {
+    type: typeKeyword || "string",
+    typeReference,
+    array: !!isArray,
+    options
+  };
+};
+
+// src/common/TypeParsing/ParsingUtils/getTypeInfoField.ts
+var getTypeInfoField = (propertySignature) => {
+  const { type, modifiers } = propertySignature;
+  const {
+    array,
+    typeReference,
+    type: typeKeyword,
+    options
+  } = type ? extractTypeDetails(type) : {
+    array: false,
+    typeReference: void 0,
+    type: "string",
+    options: void 0
+  };
+  const readonly = modifiers ? modifiers.some((modifier) => modifier.kind === SyntaxKind.ReadonlyKeyword) : false;
+  const optional = !!propertySignature.questionToken;
+  let tags = extractCommentTags(propertySignature);
+  if (readonly) {
+    const {
+      deniedOperations,
+      deniedOperations: { CREATE, UPDATE, DELETE } = {}
+    } = tags || {};
+    tags = {
+      ...tags,
+      deniedOperations: {
+        ...deniedOperations,
+        create: CREATE ?? true,
+        update: UPDATE ?? true,
+        delete: DELETE ?? true
+      }
+    };
+  }
+  return {
+    type: typeKeyword,
+    array,
+    readonly,
+    optional,
+    typeReference,
+    possibleValues: options,
+    tags
+  };
+};
+
+// src/common/TypeParsing/ParsingUtils/getTypeInfo.ts
+var getTypeInfo = (typeLiteral) => {
+  const { members } = typeLiteral;
+  const tags = extractCommentTags(typeLiteral);
+  let fields = {};
+  for (const m of members) {
+    const { name, kind } = m;
+    if (name && kind === SyntaxKind.PropertySignature) {
+      const fieldName = name.getText();
+      const field = getTypeInfoField(m);
+      fields = {
+        ...fields,
+        [fieldName]: field
+      };
+    }
+  }
+  return {
+    fields,
+    tags
+  };
+};
+var getUnionOrIntersectionTypeInfo = (unionType, typeMap) => {
+  const { kind, types } = unionType;
+  const isUnion = kind === SyntaxKind.UnionType;
+  let typeInfo;
+  for (const t of types) {
+    const { kind: kind2 } = t;
+    let nextTypeInfo;
+    if (kind2 === SyntaxKind.TypeReference) {
+      const { typeName } = t;
+      const refNode = typeMap[typeName.getText()];
+      if (refNode) {
+        nextTypeInfo = getTypeInfoFromTypeAlias(refNode, typeMap);
+      }
+    } else if (kind2 === SyntaxKind.TypeLiteral) {
+      nextTypeInfo = getTypeInfo(t);
+    }
+    if (nextTypeInfo) {
+      const {
+        fields: existingFields = {},
+        unionFieldSets: existingFieldSets = []
+      } = typeInfo || {};
+      const { fields: nextFields, unionFieldSets: nextUnionFieldSets = [] } = nextTypeInfo;
+      if (isUnion && nextFields) {
+        const newUnionFieldSet = Object.keys(nextFields);
+        typeInfo = {
+          ...typeInfo,
+          unionFieldSets: [
+            ...existingFieldSets,
+            ...nextUnionFieldSets,
+            newUnionFieldSet
+          ]
+        };
+      }
+      typeInfo = {
+        ...typeInfo,
+        fields: {
+          ...existingFields,
+          ...nextFields
+        }
+      };
+    }
+  }
+  return typeInfo;
+};
+
+// src/common/TypeParsing/ParsingUtils/Constants.ts
+var FIELD_FILTERS = {
+  OMIT: "Omit",
+  PICK: "Pick",
+  EXCLUDE: "Exclude"
+};
+var getUnionOrLiteralStringValues = (node) => {
+  let values = [];
+  if (node) {
+    if (node.kind === SyntaxKind.LiteralType) {
+      const { literal } = node;
+      if (literal.kind === SyntaxKind.StringLiteral || literal.kind === SyntaxKind.NumericLiteral) {
+        const { text } = literal;
+        values = [text];
+      }
+    } else if (node.kind === SyntaxKind.UnionType) {
+      const { types } = node;
+      for (const type of types) {
+        values = [...values, ...getUnionOrLiteralStringValues(type)];
+      }
+    }
+  }
+  return values;
+};
+
+// src/common/TypeParsing/ParsingUtils/getTypeInfoFromFieldFilter.ts
+var getTypeInfoFromPickOmitFieldFilters = (typeNameStr, typeRef, typeMap) => {
+  const picking = typeNameStr === FIELD_FILTERS.PICK;
+  const omitTypeKind = typeRef.typeArguments?.[0].kind;
+  let typeInfo;
+  if (omitTypeKind === SyntaxKind.TypeReference && typeRef.typeArguments && typeRef.typeArguments[0].kind === SyntaxKind.TypeReference) {
+    const omitType = typeRef.typeArguments[0];
+    const omitTypeFields = typeRef.typeArguments[1];
+    const omitTypeName = omitType.typeName.getText();
+    const refNode = typeMap[omitTypeName];
+    if (refNode) {
+      const {
+        fields: existingFields = {},
+        unionFieldSets: existingUnionFieldSets,
+        ...typeInfoOther
+      } = getTypeInfoFromTypeAlias(refNode, typeMap) || {};
+      const omitFieldNames = getUnionOrLiteralStringValues(omitTypeFields);
+      const cleanTypeInfoFields = Object.keys(
+        existingFields
+      ).reduce(
+        (acc, key) => {
+          if (acc && (picking && omitFieldNames.includes(key) || !picking && !omitFieldNames.includes(key)) && existingFields[key]) {
+            acc[key] = existingFields[key];
+          }
+          return acc;
+        },
+        {}
+      );
+      const cleanUnionFieldSets = existingUnionFieldSets ? existingUnionFieldSets.map(
+        (fieldSet) => fieldSet.filter(
+          (field) => picking ? omitFieldNames.includes(field) : !omitFieldNames.includes(field)
+        )
+      ) : void 0;
+      typeInfo = {
+        ...typeInfoOther,
+        fields: cleanTypeInfoFields,
+        unionFieldSets: cleanUnionFieldSets
+      };
+    }
+  }
+  return typeInfo;
+};
+var getTypeInfoFromExcludeFieldFilter = (typeNameStr, typeRef, typeMap) => {
+  const baseTypeKind = typeRef.typeArguments?.[0].kind;
+  const excludeTypeKind = typeRef.typeArguments?.[1].kind;
+  let typeInfo;
+  if (baseTypeKind === SyntaxKind.TypeReference && excludeTypeKind === SyntaxKind.TypeReference && typeRef.typeArguments) {
+    const baseType = typeRef.typeArguments[0];
+    const excludeType = typeRef.typeArguments[1];
+    const baseTypeName = baseType.typeName.getText();
+    const excludeTypeName = excludeType.typeName.getText();
+    const refNode = typeMap[baseTypeName];
+    const excludeNode = typeMap[excludeTypeName];
+    if (refNode && excludeNode) {
+      const baseTypeInfo = getTypeInfoFromTypeAlias(refNode, typeMap);
+      const excludeTypeInfo = getTypeInfoFromTypeAlias(excludeNode, typeMap);
+      if (baseTypeInfo && excludeTypeInfo) {
+        const {
+          fields: baseFields = {},
+          unionFieldSets: existingUnionFieldSets
+        } = baseTypeInfo;
+        const { fields: excludeFields = {} } = excludeTypeInfo;
+        const excludeFieldNames = Object.keys(excludeFields);
+        const cleanTypeInfoFields = Object.keys(
+          baseFields
+        ).reduce(
+          (acc, key) => {
+            if (acc && !excludeFieldNames.includes(key) && baseFields[key]) {
+              acc[key] = baseFields[key];
+            }
+            return acc;
+          },
+          {}
+        );
+        const cleanUnionFieldSets = existingUnionFieldSets ? existingUnionFieldSets.map(
+          (fieldSet) => fieldSet.filter((field) => !excludeFieldNames.includes(field))
+        ) : void 0;
+        typeInfo = {
+          ...baseTypeInfo,
+          fields: cleanTypeInfoFields,
+          unionFieldSets: cleanUnionFieldSets
+        };
+      }
+    }
+  }
+  return typeInfo;
+};
+var defaultFieldFilterProcessor = (typeNameStr, typeRef, typeMap) => {
+  const refNode = typeNameStr ? typeMap[typeNameStr] : void 0;
+  let typeInfo;
+  if (refNode) {
+    typeInfo = getTypeInfoFromTypeAlias(refNode, typeMap);
+  }
+  return typeInfo;
+};
+var FIELD_FILTER_PROCESSORS = {
+  [FIELD_FILTERS.PICK]: getTypeInfoFromPickOmitFieldFilters,
+  [FIELD_FILTERS.OMIT]: getTypeInfoFromPickOmitFieldFilters,
+  [FIELD_FILTERS.EXCLUDE]: getTypeInfoFromExcludeFieldFilter
+};
+var getTypeInfoFromFieldFilter = (typeNameStr, typeRef, typeMap) => {
+  const processor = typeNameStr ? FIELD_FILTER_PROCESSORS[typeNameStr] : void 0;
+  return processor ? processor(typeNameStr, typeRef, typeMap) : defaultFieldFilterProcessor(typeNameStr, typeRef, typeMap);
+};
+
+// src/common/TypeParsing/ParsingUtils/getTypeInfoFromAliasType.ts
+var getTypeInfoFromTypeLiteral = (type) => getTypeInfo(type);
+var getTypeInfoFromUnionOrIntersectionType = (type, typeMap) => getUnionOrIntersectionTypeInfo(type, typeMap);
+var getTypeInfoFromTypeReference = (type, typeMap) => {
+  const typeRef = type;
+  const { typeName } = typeRef;
+  const typeNameStr = typeName.getText();
+  return getTypeInfoFromFieldFilter(typeNameStr, typeRef, typeMap);
+};
+var ALIAS_TYPE_PROCESSORS = {
+  [SyntaxKind.TypeLiteral]: getTypeInfoFromTypeLiteral,
+  [SyntaxKind.UnionType]: getTypeInfoFromUnionOrIntersectionType,
+  [SyntaxKind.IntersectionType]: getTypeInfoFromUnionOrIntersectionType,
+  [SyntaxKind.TypeReference]: getTypeInfoFromTypeReference
+};
+var getTypeInfoFromAliasType = (type, typeMap) => {
+  const { kind } = type;
+  const processor = ALIAS_TYPE_PROCESSORS[kind];
+  const typeInfo = processor ? processor(type, typeMap) : void 0;
+  return typeInfo;
+};
+
+// src/common/TypeParsing/ParsingUtils/getTypeInfoFromTypeAlias.ts
+var getTypeInfoFromTypeAlias = (typeAliasDec, typeMap) => {
+  const { type } = typeAliasDec;
+  const tags = extractCommentTags(typeAliasDec);
+  const typeInfo = getTypeInfoFromAliasType(type, typeMap);
+  return typeInfo ? {
+    ...typeInfo,
+    tags: {
+      ...tags,
+      ...typeInfo.tags
+    }
+  } : void 0;
+};
+
+// src/common/TypeParsing/ParsingUtils/getPrimaryFieldForTypeInfo.ts
+var getPrimaryFieldForTypeInfo = (typeInfo) => {
+  const { fields } = typeInfo;
+  let primaryField = void 0, primaryFieldReadDenied = false;
+  for (const fieldName in fields) {
+    const field = fields[fieldName];
+    const {
+      tags: {
+        primaryField: isPrimaryField = false,
+        deniedOperations: { READ: readDenied = false } = {}
+      } = {}
+    } = field;
+    if (isPrimaryField || !primaryField) {
+      primaryField = fieldName;
+      primaryFieldReadDenied = readDenied;
+    }
+    if (isPrimaryField) {
+      break;
+    }
+  }
+  if (primaryFieldReadDenied) {
+    throw new Error(
+      "READ_DENIED_PRIMARY_FIELD_NOT_SUPPORTED" /* READ_DENIED_PRIMARY_FIELD_NOT_SUPPORTED */
+    );
+  }
+  return primaryField;
+};
+
+// src/common/TypeParsing/TypeParsing.ts
+var getTypeInfoMapFromTypeScript = (source) => {
+  const typeScriptNode = createSourceFile(
+    "x.ts",
+    source,
+    ScriptTarget.Latest,
+    true
+  );
+  const typeMap = convertASTToMap(typeScriptNode, {});
+  const typeInfoMap = {};
+  for (const key in typeMap) {
+    const typeAliasDec = typeMap[key];
+    const { modifiers } = typeAliasDec;
+    let outputTypeInfo = false;
+    if (modifiers) {
+      modifiers.forEach((modifier) => {
+        const { kind } = modifier;
+        if (kind === SyntaxKind.ExportKeyword) {
+          outputTypeInfo = true;
+        }
+      });
+    }
+    if (outputTypeInfo) {
+      const typeInfo = getTypeInfoFromTypeAlias(typeAliasDec, typeMap);
+      if (typeInfo) {
+        typeInfoMap[key] = {
+          ...typeInfo,
+          primaryField: getPrimaryFieldForTypeInfo(typeInfo)
+        };
+      }
+    }
+  }
+  return typeInfoMap;
+};
+
+// 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/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/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 };