moonflower 0.9.0

package/src/openapi/analyzerModule/nodeParsers.ts

@@ -0,0 +1,648 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import {
+	Node,
+	PropertyAccessExpression,
+	PropertyAssignment,
+	PropertySignature,
+	ShorthandPropertyAssignment,
+	SyntaxKind,
+	ts,
+	Type,
+	TypeReferenceNode,
+} from 'ts-morph'
+
+import { OpenApiManager } from '../manager/OpenApiManager'
+import { ShapeOfProperty, ShapeOfType, ShapeOfUnionEntry } from './types'
+
+export const findNodeImplementation = (node: Node): Node => {
+	if (node.getKind() === SyntaxKind.Identifier) {
+		const implementationNode = node.asKind(SyntaxKind.Identifier)!.getImplementations()[0]?.getNode()
+		if (implementationNode) {
+			const implementationParentNode = implementationNode.getParent()!
+			const assignmentValueNode = implementationParentNode.getLastChild()!
+			if (assignmentValueNode === node) {
+				throw new Error('Recursive implementation found')
+			}
+			return findNodeImplementation(assignmentValueNode)
+		}
+
+		const definitionNode = node.asKind(SyntaxKind.Identifier)!.getDefinitions()[0]?.getNode()
+		if (definitionNode) {
+			const definitionParentNode = definitionNode.getParent()!
+			const assignmentValueNode = definitionParentNode.getLastChild()!
+			if (assignmentValueNode === node) {
+				throw new Error('Recursive implementation found')
+			}
+			return findNodeImplementation(assignmentValueNode)
+		}
+		throw new Error('No implementation nor definition available')
+	}
+
+	return node
+}
+
+export const findPropertyAssignmentValueNode = (
+	node:
+		| PropertyAssignment
+		| TypeReferenceNode
+		| PropertySignature
+		| PropertyAccessExpression
+		| ShorthandPropertyAssignment
+): Node => {
+	const identifierChildren = node.getChildrenOfKind(SyntaxKind.Identifier)
+	if (identifierChildren.length === 2) {
+		return findNodeImplementation(identifierChildren[1])
+	}
+	const lastMatchingChild = node.getChildren().reverse()
+	return lastMatchingChild.find(
+		(child) =>
+			child.getKind() !== SyntaxKind.GreaterThanToken &&
+			child.getKind() !== SyntaxKind.CommaToken &&
+			child.getKind() !== SyntaxKind.SemicolonToken
+	)!
+}
+
+export const getTypeReferenceShape = (node: TypeReferenceNode): ShapeOfType['shape'] => {
+	const firstChild = node.getFirstChild()!
+	if (firstChild.isKind(SyntaxKind.SyntaxList)) {
+		return getRecursiveNodeShape(firstChild.getFirstChild()!)
+	} else {
+		return getRecursiveNodeShape(firstChild)
+	}
+}
+
+export const getRecursiveNodeShape = (nodeOrReference: Node): ShapeOfType['shape'] => {
+	const typeName = nodeOrReference.getSymbol()?.getName()
+	if (typeName && OpenApiManager.getInstance().hasExposedModel(typeName)) {
+		return [
+			{
+				role: 'ref',
+				shape: typeName,
+				optional: false,
+			},
+		]
+	}
+
+	const node = findNodeImplementation(nodeOrReference)
+
+	// Undefined
+	const undefinedNode = node.asKind(SyntaxKind.UndefinedKeyword)
+	if (undefinedNode) {
+		return 'undefined'
+	}
+
+	// Literal type
+	const literalNode = node.asKind(SyntaxKind.LiteralType)
+	if (literalNode) {
+		if (literalNode.getFirstChildByKind(SyntaxKind.TrueKeyword)) {
+			return 'true'
+		}
+		if (literalNode.getFirstChildByKind(SyntaxKind.FalseKeyword)) {
+			return 'false'
+		}
+	}
+
+	// Boolean literal
+	const booleanLiteralNode =
+		node.asKind(SyntaxKind.BooleanKeyword) ||
+		node.asKind(SyntaxKind.TrueKeyword) ||
+		node.asKind(SyntaxKind.FalseKeyword)
+	if (booleanLiteralNode) {
+		return 'boolean'
+	}
+
+	// String literal
+	const stringLiteralNode = node.asKind(SyntaxKind.StringKeyword) || node.asKind(SyntaxKind.StringLiteral)
+	if (stringLiteralNode) {
+		return 'string'
+	}
+
+	// Number literal
+	const numberLiteralNode = node.asKind(SyntaxKind.NumberKeyword) || node.asKind(SyntaxKind.NumericLiteral)
+	if (numberLiteralNode) {
+		return 'number'
+	}
+
+	// BigInt literal
+	const bigIntNode = node.asKind(SyntaxKind.BigIntKeyword) || node.asKind(SyntaxKind.BigIntLiteral)
+	if (bigIntNode) {
+		return 'bigint'
+	}
+
+	// Type literal
+	const typeLiteralNode = node.asKind(SyntaxKind.TypeLiteral)
+	if (typeLiteralNode) {
+		const properties = typeLiteralNode
+			.getFirstChildByKind(SyntaxKind.SyntaxList)!
+			.getChildrenOfKind(SyntaxKind.PropertySignature)
+
+		const propertyShapes = properties.map((propNode) => {
+			const identifier = propNode.getFirstChildByKind(SyntaxKind.Identifier)!
+			const valueNode = findPropertyAssignmentValueNode(propNode)
+			const questionMarkToken = identifier.getNextSiblingIfKind(SyntaxKind.QuestionToken)
+			return {
+				role: 'property' as const,
+				identifier: identifier.getText(),
+				shape: getRecursiveNodeShape(valueNode),
+				optional: valueNode.getType().isNullable() || !!questionMarkToken,
+			}
+		})
+		return propertyShapes
+	}
+
+	// Type reference
+	const typeReferenceNode = node.asKind(SyntaxKind.TypeReference)
+	if (typeReferenceNode) {
+		return getRecursiveNodeShape(typeReferenceNode.getFirstChild()!)
+	}
+
+	// Property access expression
+	const propertyAccessNode = node.asKind(SyntaxKind.PropertyAccessExpression)
+	if (propertyAccessNode) {
+		const lastChild = findNodeImplementation(node.getLastChild()!)
+		return getProperTypeShape(lastChild.asKind(SyntaxKind.CallExpression)!.getReturnType(), lastChild)
+	}
+
+	// Union type
+	const unionTypeNode = node.asKind(SyntaxKind.UnionType)
+	if (unionTypeNode) {
+		return getProperTypeShape(unionTypeNode.getType(), node)
+	}
+
+	// Typeof query
+	const typeQueryNode = node.asKind(SyntaxKind.TypeQuery)
+	if (typeQueryNode) {
+		return getRecursiveNodeShape(typeQueryNode.getLastChild()!)
+	}
+
+	// Qualified name
+	const qualifiedNameNode = node.asKind(SyntaxKind.QualifiedName)
+	if (qualifiedNameNode) {
+		return getRecursiveNodeShape(qualifiedNameNode.getLastChild()!)
+	}
+
+	// Call expression
+	const callExpressionNode = node.asKind(SyntaxKind.CallExpression)
+	if (callExpressionNode) {
+		return getProperTypeShape(callExpressionNode.getReturnType(), callExpressionNode)
+	}
+
+	// Await expression
+	const awaitExpressionNode = node.asKind(SyntaxKind.AwaitExpression)
+	if (awaitExpressionNode) {
+		return getRecursiveNodeShape(awaitExpressionNode.getChildAtIndex(1)!)
+	}
+
+	// 'As' Expression
+	const asExpressionNode = node.asKind(SyntaxKind.AsExpression)
+	if (asExpressionNode) {
+		return getRecursiveNodeShape(asExpressionNode.getChildAtIndex(2)!)
+	}
+
+	// TODO
+	return 'unknown_1'
+}
+
+export const getShapeOfValidatorLiteral = (
+	objectLiteralNode: Node<ts.ObjectLiteralExpression>
+): (ShapeOfProperty & { description: string; errorMessage: string })[] => {
+	const syntaxListNode = objectLiteralNode.getFirstDescendantByKind(SyntaxKind.SyntaxList)!
+	const assignmentNodes = syntaxListNode.getChildrenOfKind(SyntaxKind.PropertyAssignment)!
+
+	const properties = assignmentNodes.map((node) => {
+		const identifierNode = node.getFirstChild()!
+		const identifierName = (() => {
+			if (identifierNode.isKind(SyntaxKind.Identifier)) {
+				return identifierNode.getText()
+			}
+			if (identifierNode.isKind(SyntaxKind.StringLiteral)) {
+				return identifierNode.getLiteralText()
+			}
+			return 'unknown_30'
+		})()
+
+		const assignmentValueNode = node.getLastChild()!
+		const innerLiteralNode = findNodeImplementation(assignmentValueNode)
+
+		return {
+			role: 'property' as const,
+			identifier: identifierName,
+			shape: getValidatorPropertyShape(innerLiteralNode),
+			optional: getValidatorPropertyOptionality(innerLiteralNode),
+			description: getValidatorPropertyStringValue(innerLiteralNode, 'description'),
+			errorMessage: getValidatorPropertyStringValue(innerLiteralNode, 'errorMessage'),
+		}
+	})
+
+	return properties || []
+}
+
+export const getValidatorPropertyShape = (innerLiteralNode: Node): ShapeOfType['shape'] => {
+	// Inline definition with `as Validator<...>` clause
+	const inlineValidatorAsExpression = innerLiteralNode
+		.getParent()!
+		.getFirstChildByKind(SyntaxKind.AsExpression)
+	if (inlineValidatorAsExpression) {
+		const typeReference = inlineValidatorAsExpression.getLastChildByKind(SyntaxKind.TypeReference)!
+		return getTypeReferenceShape(typeReference)
+	}
+
+	// Variable with `: Validator<...>` clause
+	const childTypeReferenceNode = innerLiteralNode.getParent()!.getFirstChildByKind(SyntaxKind.TypeReference)
+	if (childTypeReferenceNode) {
+		return getTypeReferenceShape(childTypeReferenceNode)
+	}
+
+	// `RequiredParam<...>` inline call expression
+	if (innerLiteralNode.getParent()!.getChildrenOfKind(SyntaxKind.SyntaxList).length >= 2) {
+		const typeNode = innerLiteralNode
+			.getParent()!
+			.getFirstChildByKind(SyntaxKind.SyntaxList)!
+			.getFirstChild()!
+		return getRecursiveNodeShape(typeNode)
+	}
+
+	// `RequestParam | RequiredParam | OptionalParam` call expression
+	const childCallExpressionNode = innerLiteralNode.getParent()!.getFirstChildByKind(SyntaxKind.CallExpression)
+	if (childCallExpressionNode) {
+		const callExpressionArgument = findNodeImplementation(
+			childCallExpressionNode.getFirstChildByKind(SyntaxKind.SyntaxList)!.getFirstChild()!
+		)
+
+		// Param is a type reference
+		const typeReferenceNode = callExpressionArgument
+			.getParent()!
+			.getFirstChildByKind(SyntaxKind.TypeReference)!
+		if (typeReferenceNode) {
+			return getProperTypeShape(typeReferenceNode.getType(), typeReferenceNode, [])
+		}
+
+		const thingyNode = callExpressionArgument
+			.getParent()!
+			.getFirstChildByKind(SyntaxKind.ObjectLiteralExpression)!
+		if (thingyNode) {
+			return getValidatorPropertyShape(thingyNode)
+		}
+
+		if (callExpressionArgument.getKind() === SyntaxKind.CallExpression) {
+			return getValidatorPropertyShape(callExpressionArgument)
+		}
+
+		if (callExpressionArgument.getKind() === SyntaxKind.IntersectionType) {
+			return getValidatorPropertyShape(callExpressionArgument)
+		}
+		return 'unknown_3'
+	}
+
+	// Attempting to infer type from `parse` function
+	const innerNodePropertyAssignments = innerLiteralNode
+		.getFirstChildByKind(SyntaxKind.SyntaxList)!
+		.getChildrenOfKind(SyntaxKind.PropertyAssignment)
+	const parsePropertyAssignment = innerNodePropertyAssignments.find((prop) => {
+		return prop.getFirstChildByKind(SyntaxKind.Identifier)?.getText() === 'parse'
+	})
+	if (parsePropertyAssignment) {
+		const returnType = findPropertyAssignmentValueNode(parsePropertyAssignment)
+			.asKind(SyntaxKind.ArrowFunction)!
+			.getReturnType()
+		return getProperTypeShape(returnType, parsePropertyAssignment)
+	}
+
+	// Import statement
+	const importTypeNode = innerLiteralNode
+		.getFirstChildByKind(SyntaxKind.SyntaxList)
+		?.getFirstChildByKind(SyntaxKind.ImportType)
+	if (importTypeNode) {
+		const indexOfGreaterThanToken = importTypeNode
+			.getLastChildByKind(SyntaxKind.GreaterThanToken)!
+			.getChildIndex()
+		const targetSyntaxList = importTypeNode.getChildAtIndex(indexOfGreaterThanToken - 1)
+		return getRecursiveNodeShape(targetSyntaxList.getFirstChild()!)
+	}
+
+	return 'unknown_2'
+}
+
+export const getValidatorPropertyOptionality = (node: Node): boolean => {
+	const callExpressionNode = node.asKind(SyntaxKind.CallExpression)
+	if (callExpressionNode) {
+		const identifierNode = callExpressionNode.getFirstChildByKind(SyntaxKind.Identifier)
+		if (identifierNode?.getText() === 'OptionalParam') {
+			return true
+		} else if (identifierNode?.getText() === 'RequiredParam') {
+			return false
+		}
+
+		const syntaxListNode = callExpressionNode.getFirstChildByKind(SyntaxKind.SyntaxList)!
+		const literalExpression = findNodeImplementation(syntaxListNode.getFirstChild()!)
+		return getValidatorPropertyOptionality(literalExpression)
+	}
+
+	const syntaxListNode = node.getFirstDescendantByKind(SyntaxKind.SyntaxList)!
+	const assignmentNodes = syntaxListNode.getChildrenOfKind(SyntaxKind.PropertyAssignment)!
+
+	return assignmentNodes.some((node) => {
+		const identifierNode = node.getFirstDescendantByKind(SyntaxKind.Identifier)!
+		const identifierName = identifierNode.getText()
+
+		if (identifierName === 'optional') {
+			const value = findPropertyAssignmentValueNode(node)
+			return value.getKind() === SyntaxKind.TrueKeyword
+		}
+		return false
+	})
+}
+
+export const getValidatorPropertyStringValue = (
+	nodeOrReference: Node,
+	name: 'description' | 'errorMessage'
+): string => {
+	const node = findNodeImplementation(nodeOrReference)
+
+	const callExpressionNode = node.asKind(SyntaxKind.CallExpression)
+	if (callExpressionNode) {
+		const targetChild = callExpressionNode.getLastChildByKind(SyntaxKind.SyntaxList)!
+		return getValidatorPropertyStringValue(targetChild, name)
+	}
+
+	const syntaxListNode = node.asKind(SyntaxKind.SyntaxList)
+	if (syntaxListNode) {
+		const children = syntaxListNode.getChildren().map((c) => getValidatorPropertyStringValue(c, name))
+		return children.find((value) => !!value && value !== 'unknown_25') || ''
+	}
+
+	const objectLiteralNode = node.asKind(SyntaxKind.ObjectLiteralExpression)
+	if (objectLiteralNode) {
+		const values = getValuesOfObjectLiteral(objectLiteralNode)
+		const targetValue = values.find((value) => value.identifier === name)
+		if (!targetValue) {
+			return ''
+		}
+		if (Array.isArray(targetValue.value)) {
+			return 'array'
+		}
+		return targetValue.value || ''
+	}
+
+	const intersectionTypeNode = node.asKind(SyntaxKind.IntersectionType)
+	if (intersectionTypeNode) {
+		return (
+			intersectionTypeNode
+				.getTypeNodes()
+				.flatMap((t) => getValidatorPropertyStringValue(t, name))
+				.filter((v) => !!v && v !== 'unknown_25')[0] || 'unknown_27'
+		)
+	}
+
+	const typeLiteralNode = node.asKind(SyntaxKind.TypeLiteral)
+	if (typeLiteralNode) {
+		return getValidatorPropertyStringValue(typeLiteralNode.getFirstChildByKind(SyntaxKind.SyntaxList)!, name)
+	}
+
+	const propertySignatureNode = node.asKind(SyntaxKind.PropertySignature)
+	if (propertySignatureNode) {
+		const identifier = node.getFirstDescendantByKind(SyntaxKind.Identifier)!
+		if (identifier.getText() === name) {
+			const targetNode = findPropertyAssignmentValueNode(propertySignatureNode).getFirstDescendantByKind(
+				SyntaxKind.StringLiteral
+			)!
+			return targetNode.getLiteralText()
+		}
+	}
+
+	return 'unknown_25'
+}
+
+const isPromise = (type: Type) => {
+	const symbol = type.getSymbol()
+	if (!type.isObject() || !symbol) {
+		return false
+	}
+	const args = type.getTypeArguments()
+	return symbol.getName() === 'Promise' && args.length === 1
+}
+
+export const getProperTypeShape = (
+	typeOrPromise: Type,
+	atLocation: Node,
+	stack: Type[] = []
+): ShapeOfType['shape'] => {
+	const typeName = typeOrPromise.getAliasSymbol()?.getName()
+	if (typeName && OpenApiManager.getInstance().hasExposedModel(typeName)) {
+		return [
+			{
+				role: 'ref',
+				shape: typeName,
+				optional: false,
+			},
+		]
+	}
+
+	const type = isPromise(typeOrPromise) ? typeOrPromise.getTypeArguments()[0] : typeOrPromise
+
+	if (stack.some((previousType) => previousType === type)) {
+		return 'circular'
+	}
+
+	const nextStack = stack.concat(type)
+
+	if (type.getText() === 'void') {
+		return 'void'
+	}
+
+	if (type.isAny()) {
+		return 'any'
+	}
+
+	if (type.isNull()) {
+		return 'null'
+	}
+
+	if (type.isUndefined()) {
+		return 'undefined'
+	}
+
+	if (type.isBoolean() || type.isBooleanLiteral()) {
+		return 'boolean'
+	}
+
+	if (type.isStringLiteral()) {
+		return [
+			{
+				role: 'literal_string' as const,
+				shape: String(type.getLiteralValue()!),
+				optional: false,
+			},
+		]
+	}
+
+	if (type.isNumberLiteral()) {
+		return [
+			{
+				role: 'literal_number' as const,
+				shape: String(type.getLiteralValue()!),
+				optional: false,
+			},
+		]
+	}
+
+	if (type.isString() || type.isTemplateLiteral()) {
+		return 'string'
+	}
+
+	if (type.isNumber()) {
+		return 'number'
+	}
+
+	if (type.getText() === 'bigint') {
+		return 'bigint'
+	}
+
+	if (type.isTuple()) {
+		return [
+			{
+				role: 'tuple' as const,
+				shape: type.getTupleElements().map((t) => ({
+					role: 'tuple_entry' as const,
+					shape: getProperTypeShape(t, atLocation, nextStack),
+					optional: false,
+				})),
+				optional: false,
+			},
+		]
+	}
+
+	if (type.isArray()) {
+		return [
+			{
+				role: 'array' as const,
+				shape: getProperTypeShape(type.getArrayElementType()!, atLocation, nextStack),
+				optional: false,
+			},
+		]
+	}
+
+	if (type.isObject() && type.getProperties().length === 0) {
+		const targetType = type.getAliasTypeArguments()[1]
+		return [
+			{
+				role: 'record' as const,
+				shape: getProperTypeShape(targetType, atLocation, nextStack),
+				optional: false,
+			},
+		]
+	}
+
+	if (type.isObject()) {
+		if (type.getText() === 'Date') {
+			return 'Date'
+		}
+		return type
+			.getProperties()
+			.map((prop) => {
+				const valueDeclaration = prop.getValueDeclaration() || prop.getDeclarations()[0]!
+				if (!valueDeclaration) {
+					return {
+						role: 'property' as const,
+						identifier: prop.getName(),
+						shape: getProperTypeShape(prop.getTypeAtLocation(atLocation), atLocation, nextStack),
+						optional: false,
+					}
+				}
+				const valueDeclarationNode =
+					valueDeclaration.asKind(SyntaxKind.PropertySignature) ||
+					valueDeclaration.asKind(SyntaxKind.PropertyAssignment) ||
+					valueDeclaration.asKind(SyntaxKind.ShorthandPropertyAssignment)
+
+				if (!valueDeclarationNode) {
+					return {
+						role: 'property' as const,
+						identifier: prop.getName(),
+						shape: getProperTypeShape(prop.getTypeAtLocation(atLocation), atLocation, nextStack),
+						optional: false,
+					}
+				}
+
+				const isOptional = prop.getTypeAtLocation(atLocation).isNullable()
+
+				const shape = getProperTypeShape(prop.getTypeAtLocation(atLocation), atLocation, nextStack)
+				return {
+					role: 'property' as const,
+					identifier: prop.getName(),
+					shape: shape,
+					optional: isOptional,
+				}
+			})
+			.filter((val) => val.shape !== 'undefined')
+	}
+
+	if (type.isUnion()) {
+		const unfilteredShapes: ShapeOfUnionEntry[] = type.getUnionTypes().map((type) => ({
+			role: 'union_entry',
+			shape: getProperTypeShape(type, atLocation, nextStack),
+			optional: false,
+		}))
+
+		const dedupedShapes = unfilteredShapes.filter(
+			(type, index, arr) => !arr.find((dup, dupIndex) => dup.shape === type.shape && dupIndex > index)
+		)
+		const isNullable = dedupedShapes.some((shape) => shape.shape === 'undefined')
+		const shapes = dedupedShapes.filter((shape) => shape.shape !== 'undefined')
+		if (shapes.length === 1) {
+			return shapes[0].shape
+		}
+		return [
+			{
+				role: 'union',
+				shape: shapes,
+				optional: isNullable,
+			},
+		]
+	}
+
+	if (type.isIntersection()) {
+		const children = type.getIntersectionTypes()
+		const shapesOfChildren = children
+			.map((child) => getProperTypeShape(child, atLocation, nextStack))
+			.filter((shape) => typeof shape !== 'string') as ShapeOfProperty[][]
+		return shapesOfChildren.reduce<ShapeOfType[]>((total, current) => [...total, ...current], [])
+	}
+
+	return 'unknown_5'
+}
+
+const getLiteralValueOfNode = (node: Node): string | string[] | unknown[] => {
+	if (node.isKind(SyntaxKind.Identifier)) {
+		return getLiteralValueOfNode(findNodeImplementation(node))
+	} else if (node.isKind(SyntaxKind.StringLiteral)) {
+		return node.getLiteralValue()
+	} else if (node.isKind(SyntaxKind.ArrayLiteralExpression)) {
+		return node.forEachChildAsArray().map((child) => getLiteralValueOfNode(child)) as string[]
+	} else if (node.isKind(SyntaxKind.PropertyAccessExpression)) {
+		return getLiteralValueOfNode(findPropertyAssignmentValueNode(node))
+	} else if (node.isKind(SyntaxKind.ObjectLiteralExpression)) {
+		return getValuesOfObjectLiteral(node)
+	}
+	return 'unknown_6'
+}
+
+export const getValuesOfObjectLiteral = (objectLiteralNode: Node<ts.ObjectLiteralExpression>) => {
+	const syntaxListNode = objectLiteralNode.getFirstDescendantByKind(SyntaxKind.SyntaxList)!
+	const assignmentNodes = syntaxListNode.getChildrenOfKind(SyntaxKind.PropertyAssignment)!
+
+	const properties = assignmentNodes.map((node) => {
+		const identifierNode = node.getFirstDescendantByKind(SyntaxKind.Identifier)!
+		const identifierName = identifierNode.getText()
+
+		const assignmentValueNode = node.getLastChild()!
+		const targetNode = findNodeImplementation(assignmentValueNode)
+		const value = getLiteralValueOfNode(targetNode)
+
+		return {
+			identifier: identifierName,
+			value,
+		}
+	})
+
+	return properties || []
+}