@resistdesign/voltra 3.0.0-alpha.6 → 3.0.0-alpha.8

package/common/index.d.ts

@@ -1,4 +1,4 @@
-export { b as IDGeneration, d as ItemRelationships, f as Logging, R as Routing, S as SearchUtils, c as StringTransformers, e as Testing, a as TypeParsing } from '../index-C3-iD9Mh.js';
+export { b as IDGeneration, d as ItemRelationships, f as Logging, R as Routing, S as SearchUtils, c as StringTransformers, e as Testing, a as TypeParsing } from '../index-sIX5qe0K.js';
 export { H as HelperTypes, l as ItemRelationshipInfoTypes, m as SearchTypes } from '../SearchTypes-DjN6YQzE.js';
 import '../Validation-CFP59oIP.js';
 import 'typescript';

package/common/index.js

@@ -1,4 +1,4 @@
-import { SyntaxKind, isLiteralTypeNode, isStringLiteral, isNumericLiteral, createSourceFile, ScriptTarget } from 'typescript';
+import { SyntaxKind } from 'typescript';
 import { promises } from 'fs';
 import Path from 'path';
 import { pathToFileURL } from 'url';
@@ -15,39 +15,42 @@ __export(TypeParsing_exports, {
   Constants: () => Constants_exports,
   TypeInfo: () => TypeInfo_exports,
   TypeMapping: () => TypeMapping_exports,
-  Validation: () => Validation_exports,
-  getTypeInfoMapFromTypeScript: () => getTypeInfoMapFromTypeScript
+  Validation: () => Validation_exports
 });
 
-// src/common/TypeParsing/TypeMapping.ts
-var TypeMapping_exports = {};
-__export(TypeMapping_exports, {
-  convertASTToMap: () => convertASTToMap
+// 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
 });
-var convertASTToMap = (node, map = {}, parentName) => {
-  node.forEachChild((child) => {
-    const { kind: childKind } = child;
-    if (childKind === SyntaxKind.ModuleDeclaration) {
-      const moduleNode = child;
-      const { name: moduleName } = moduleNode;
-      const textModuleName = moduleName.getText();
-      const fullModuleName = parentName ? `${parentName}.${textModuleName}` : textModuleName;
-      convertASTToMap(moduleNode, map, fullModuleName);
-    }
-    if (childKind === SyntaxKind.ModuleBlock) {
-      convertASTToMap(child, map, parentName);
-    }
-    if (childKind === SyntaxKind.TypeAliasDeclaration) {
-      const typeAliasDec = child;
-      const {
-        name: { text: typeName }
-      } = typeAliasDec;
-      const fullTypeName = parentName ? `${parentName}.${typeName}` : typeName;
-      map[fullTypeName] = typeAliasDec;
-    }
-  });
-  return map;
-};
+
+// src/common/TypeParsing/TypeInfo.ts
+var TypeInfo_exports = {};
+__export(TypeInfo_exports, {
+  TypeOperation: () => TypeOperation
+});
+var TypeOperation = /* @__PURE__ */ ((TypeOperation2) => {
+  TypeOperation2["CREATE"] = "CREATE";
+  TypeOperation2["READ"] = "READ";
+  TypeOperation2["UPDATE"] = "UPDATE";
+  TypeOperation2["DELETE"] = "DELETE";
+  return TypeOperation2;
+})(TypeOperation || {});
 
 // src/common/Routing.ts
 var Routing_exports = {};
@@ -136,581 +139,6 @@ var getParamsAndTestPath = (path, testPath, exact = false) => {
   }
 };
 
-// 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";
@@ -1056,6 +484,36 @@ var validateTypeInfoValue = (value, typeInfoFullName, typeInfoMap, strict = fals
   return results;
 };
 
+// src/common/TypeParsing/TypeMapping.ts
+var TypeMapping_exports = {};
+__export(TypeMapping_exports, {
+  convertASTToMap: () => convertASTToMap
+});
+var convertASTToMap = (node, map = {}, parentName) => {
+  node.forEachChild((child) => {
+    const { kind: childKind } = child;
+    if (childKind === SyntaxKind.ModuleDeclaration) {
+      const moduleNode = child;
+      const { name: moduleName } = moduleNode;
+      const textModuleName = moduleName.getText();
+      const fullModuleName = parentName ? `${parentName}.${textModuleName}` : textModuleName;
+      convertASTToMap(moduleNode, map, fullModuleName);
+    }
+    if (childKind === SyntaxKind.ModuleBlock) {
+      convertASTToMap(child, map, parentName);
+    }
+    if (childKind === SyntaxKind.TypeAliasDeclaration) {
+      const typeAliasDec = child;
+      const {
+        name: { text: typeName }
+      } = typeAliasDec;
+      const fullTypeName = parentName ? `${parentName}.${typeName}` : typeName;
+      map[fullTypeName] = typeAliasDec;
+    }
+  });
+  return map;
+};
+
 // src/common/TypeParsing/Constants.ts
 var Constants_exports = {};
 __export(Constants_exports, {