@resistdesign/voltra 3.0.0-alpha.5 → 3.0.0-alpha.51

package/build/TypeMapping.d.ts

@@ -0,0 +1,17 @@
+/**
+ * AST mapping helpers for extracting type aliases from TypeScript sources.
+ */
+import { Node, TypeAliasDeclaration } from "typescript";
+/**
+ * A map of type aliases in the TypeScript AST.
+ */
+export type TypeMap = Record<string, TypeAliasDeclaration>;
+/**
+ * Converts a TypeScript AST to a map of type aliases.
+ *
+ * @param node - AST node to traverse.
+ * @param map - Accumulator map of type aliases.
+ * @param parentName - Parent module name for nested namespaces.
+ * @returns Map of type alias declarations keyed by name.
+ */
+export declare const convertASTToMap: (node: Node, map?: Record<string, TypeAliasDeclaration>, parentName?: string) => TypeMap;

package/build/TypeParsing.d.ts

@@ -0,0 +1,10 @@
+import { TypeInfoMap } from "../common/TypeParsing/TypeInfo";
+/**
+ * Extracts type information from TypeScript content.
+ *
+ * @category TypeInfo
+ *
+ * @param source - TypeScript source text to parse.
+ * @returns Map of exported type info definitions.
+ */
+export declare const getTypeInfoMapFromTypeScript: (source: string) => TypeInfoMap;

package/build/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @packageDocumentation
+ *
+ * Various build tools like a dynamic TypeScript-to-TypeInfo parser.
+ */
+/**
+ * @category build
+ * @group Type Mapping
+ */
+export * from "./TypeMapping";
+/**
+ * @category build
+ * @group Type Parsing
+ */
+export * from "./TypeParsing";

package/build/index.js

@@ -0,0 +1,569 @@
+import { getPotentialJSONValue, getPathArray } from '../chunk-2JDOM6PB.js';
+import '../chunk-I2KLQ2HA.js';
+import { SyntaxKind, isLiteralTypeNode, isStringLiteral, isNumericLiteral, createSourceFile, ScriptTarget } from 'typescript';
+
+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/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,
+      typeKeyword: elementKeyword,
+      options: elementOptions
+    } = checkType(elementType);
+    typeReference = elementReference;
+    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)
+        )
+      ).filter((fieldSet) => fieldSet.length > 0) : 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))
+        ).filter((fieldSet) => fieldSet.length > 0) : 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/build/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;
+};
+
+export { convertASTToMap, getTypeInfoMapFromTypeScript };