moonflower 0.9.0

package/dist/src/openapi/analyzerModule/nodeParsers.js

@@ -0,0 +1,521 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValuesOfObjectLiteral = exports.getProperTypeShape = exports.getValidatorPropertyStringValue = exports.getValidatorPropertyOptionality = exports.getValidatorPropertyShape = exports.getShapeOfValidatorLiteral = exports.getRecursiveNodeShape = exports.getTypeReferenceShape = exports.findPropertyAssignmentValueNode = exports.findNodeImplementation = void 0;
+const ts_morph_1 = require("ts-morph");
+const OpenApiManager_1 = require("../manager/OpenApiManager");
+const findNodeImplementation = (node) => {
+    var _a, _b;
+    if (node.getKind() === ts_morph_1.SyntaxKind.Identifier) {
+        const implementationNode = (_a = node.asKind(ts_morph_1.SyntaxKind.Identifier).getImplementations()[0]) === null || _a === void 0 ? void 0 : _a.getNode();
+        if (implementationNode) {
+            const implementationParentNode = implementationNode.getParent();
+            const assignmentValueNode = implementationParentNode.getLastChild();
+            if (assignmentValueNode === node) {
+                throw new Error('Recursive implementation found');
+            }
+            return (0, exports.findNodeImplementation)(assignmentValueNode);
+        }
+        const definitionNode = (_b = node.asKind(ts_morph_1.SyntaxKind.Identifier).getDefinitions()[0]) === null || _b === void 0 ? void 0 : _b.getNode();
+        if (definitionNode) {
+            const definitionParentNode = definitionNode.getParent();
+            const assignmentValueNode = definitionParentNode.getLastChild();
+            if (assignmentValueNode === node) {
+                throw new Error('Recursive implementation found');
+            }
+            return (0, exports.findNodeImplementation)(assignmentValueNode);
+        }
+        throw new Error('No implementation nor definition available');
+    }
+    return node;
+};
+exports.findNodeImplementation = findNodeImplementation;
+const findPropertyAssignmentValueNode = (node) => {
+    const identifierChildren = node.getChildrenOfKind(ts_morph_1.SyntaxKind.Identifier);
+    if (identifierChildren.length === 2) {
+        return (0, exports.findNodeImplementation)(identifierChildren[1]);
+    }
+    const lastMatchingChild = node.getChildren().reverse();
+    return lastMatchingChild.find((child) => child.getKind() !== ts_morph_1.SyntaxKind.GreaterThanToken &&
+        child.getKind() !== ts_morph_1.SyntaxKind.CommaToken &&
+        child.getKind() !== ts_morph_1.SyntaxKind.SemicolonToken);
+};
+exports.findPropertyAssignmentValueNode = findPropertyAssignmentValueNode;
+const getTypeReferenceShape = (node) => {
+    const firstChild = node.getFirstChild();
+    if (firstChild.isKind(ts_morph_1.SyntaxKind.SyntaxList)) {
+        return (0, exports.getRecursiveNodeShape)(firstChild.getFirstChild());
+    }
+    else {
+        return (0, exports.getRecursiveNodeShape)(firstChild);
+    }
+};
+exports.getTypeReferenceShape = getTypeReferenceShape;
+const getRecursiveNodeShape = (nodeOrReference) => {
+    var _a;
+    const typeName = (_a = nodeOrReference.getSymbol()) === null || _a === void 0 ? void 0 : _a.getName();
+    if (typeName && OpenApiManager_1.OpenApiManager.getInstance().hasExposedModel(typeName)) {
+        return [
+            {
+                role: 'ref',
+                shape: typeName,
+                optional: false,
+            },
+        ];
+    }
+    const node = (0, exports.findNodeImplementation)(nodeOrReference);
+    const undefinedNode = node.asKind(ts_morph_1.SyntaxKind.UndefinedKeyword);
+    if (undefinedNode) {
+        return 'undefined';
+    }
+    const literalNode = node.asKind(ts_morph_1.SyntaxKind.LiteralType);
+    if (literalNode) {
+        if (literalNode.getFirstChildByKind(ts_morph_1.SyntaxKind.TrueKeyword)) {
+            return 'true';
+        }
+        if (literalNode.getFirstChildByKind(ts_morph_1.SyntaxKind.FalseKeyword)) {
+            return 'false';
+        }
+    }
+    const booleanLiteralNode = node.asKind(ts_morph_1.SyntaxKind.BooleanKeyword) ||
+        node.asKind(ts_morph_1.SyntaxKind.TrueKeyword) ||
+        node.asKind(ts_morph_1.SyntaxKind.FalseKeyword);
+    if (booleanLiteralNode) {
+        return 'boolean';
+    }
+    const stringLiteralNode = node.asKind(ts_morph_1.SyntaxKind.StringKeyword) || node.asKind(ts_morph_1.SyntaxKind.StringLiteral);
+    if (stringLiteralNode) {
+        return 'string';
+    }
+    const numberLiteralNode = node.asKind(ts_morph_1.SyntaxKind.NumberKeyword) || node.asKind(ts_morph_1.SyntaxKind.NumericLiteral);
+    if (numberLiteralNode) {
+        return 'number';
+    }
+    const bigIntNode = node.asKind(ts_morph_1.SyntaxKind.BigIntKeyword) || node.asKind(ts_morph_1.SyntaxKind.BigIntLiteral);
+    if (bigIntNode) {
+        return 'bigint';
+    }
+    const typeLiteralNode = node.asKind(ts_morph_1.SyntaxKind.TypeLiteral);
+    if (typeLiteralNode) {
+        const properties = typeLiteralNode
+            .getFirstChildByKind(ts_morph_1.SyntaxKind.SyntaxList)
+            .getChildrenOfKind(ts_morph_1.SyntaxKind.PropertySignature);
+        const propertyShapes = properties.map((propNode) => {
+            const identifier = propNode.getFirstChildByKind(ts_morph_1.SyntaxKind.Identifier);
+            const valueNode = (0, exports.findPropertyAssignmentValueNode)(propNode);
+            const questionMarkToken = identifier.getNextSiblingIfKind(ts_morph_1.SyntaxKind.QuestionToken);
+            return {
+                role: 'property',
+                identifier: identifier.getText(),
+                shape: (0, exports.getRecursiveNodeShape)(valueNode),
+                optional: valueNode.getType().isNullable() || !!questionMarkToken,
+            };
+        });
+        return propertyShapes;
+    }
+    const typeReferenceNode = node.asKind(ts_morph_1.SyntaxKind.TypeReference);
+    if (typeReferenceNode) {
+        return (0, exports.getRecursiveNodeShape)(typeReferenceNode.getFirstChild());
+    }
+    const propertyAccessNode = node.asKind(ts_morph_1.SyntaxKind.PropertyAccessExpression);
+    if (propertyAccessNode) {
+        const lastChild = (0, exports.findNodeImplementation)(node.getLastChild());
+        return (0, exports.getProperTypeShape)(lastChild.asKind(ts_morph_1.SyntaxKind.CallExpression).getReturnType(), lastChild);
+    }
+    const unionTypeNode = node.asKind(ts_morph_1.SyntaxKind.UnionType);
+    if (unionTypeNode) {
+        return (0, exports.getProperTypeShape)(unionTypeNode.getType(), node);
+    }
+    const typeQueryNode = node.asKind(ts_morph_1.SyntaxKind.TypeQuery);
+    if (typeQueryNode) {
+        return (0, exports.getRecursiveNodeShape)(typeQueryNode.getLastChild());
+    }
+    const qualifiedNameNode = node.asKind(ts_morph_1.SyntaxKind.QualifiedName);
+    if (qualifiedNameNode) {
+        return (0, exports.getRecursiveNodeShape)(qualifiedNameNode.getLastChild());
+    }
+    const callExpressionNode = node.asKind(ts_morph_1.SyntaxKind.CallExpression);
+    if (callExpressionNode) {
+        return (0, exports.getProperTypeShape)(callExpressionNode.getReturnType(), callExpressionNode);
+    }
+    const awaitExpressionNode = node.asKind(ts_morph_1.SyntaxKind.AwaitExpression);
+    if (awaitExpressionNode) {
+        return (0, exports.getRecursiveNodeShape)(awaitExpressionNode.getChildAtIndex(1));
+    }
+    const asExpressionNode = node.asKind(ts_morph_1.SyntaxKind.AsExpression);
+    if (asExpressionNode) {
+        return (0, exports.getRecursiveNodeShape)(asExpressionNode.getChildAtIndex(2));
+    }
+    return 'unknown_1';
+};
+exports.getRecursiveNodeShape = getRecursiveNodeShape;
+const getShapeOfValidatorLiteral = (objectLiteralNode) => {
+    const syntaxListNode = objectLiteralNode.getFirstDescendantByKind(ts_morph_1.SyntaxKind.SyntaxList);
+    const assignmentNodes = syntaxListNode.getChildrenOfKind(ts_morph_1.SyntaxKind.PropertyAssignment);
+    const properties = assignmentNodes.map((node) => {
+        const identifierNode = node.getFirstChild();
+        const identifierName = (() => {
+            if (identifierNode.isKind(ts_morph_1.SyntaxKind.Identifier)) {
+                return identifierNode.getText();
+            }
+            if (identifierNode.isKind(ts_morph_1.SyntaxKind.StringLiteral)) {
+                return identifierNode.getLiteralText();
+            }
+            return 'unknown_30';
+        })();
+        const assignmentValueNode = node.getLastChild();
+        const innerLiteralNode = (0, exports.findNodeImplementation)(assignmentValueNode);
+        return {
+            role: 'property',
+            identifier: identifierName,
+            shape: (0, exports.getValidatorPropertyShape)(innerLiteralNode),
+            optional: (0, exports.getValidatorPropertyOptionality)(innerLiteralNode),
+            description: (0, exports.getValidatorPropertyStringValue)(innerLiteralNode, 'description'),
+            errorMessage: (0, exports.getValidatorPropertyStringValue)(innerLiteralNode, 'errorMessage'),
+        };
+    });
+    return properties || [];
+};
+exports.getShapeOfValidatorLiteral = getShapeOfValidatorLiteral;
+const getValidatorPropertyShape = (innerLiteralNode) => {
+    var _a;
+    const inlineValidatorAsExpression = innerLiteralNode
+        .getParent()
+        .getFirstChildByKind(ts_morph_1.SyntaxKind.AsExpression);
+    if (inlineValidatorAsExpression) {
+        const typeReference = inlineValidatorAsExpression.getLastChildByKind(ts_morph_1.SyntaxKind.TypeReference);
+        return (0, exports.getTypeReferenceShape)(typeReference);
+    }
+    const childTypeReferenceNode = innerLiteralNode.getParent().getFirstChildByKind(ts_morph_1.SyntaxKind.TypeReference);
+    if (childTypeReferenceNode) {
+        return (0, exports.getTypeReferenceShape)(childTypeReferenceNode);
+    }
+    if (innerLiteralNode.getParent().getChildrenOfKind(ts_morph_1.SyntaxKind.SyntaxList).length >= 2) {
+        const typeNode = innerLiteralNode
+            .getParent()
+            .getFirstChildByKind(ts_morph_1.SyntaxKind.SyntaxList)
+            .getFirstChild();
+        return (0, exports.getRecursiveNodeShape)(typeNode);
+    }
+    const childCallExpressionNode = innerLiteralNode.getParent().getFirstChildByKind(ts_morph_1.SyntaxKind.CallExpression);
+    if (childCallExpressionNode) {
+        const callExpressionArgument = (0, exports.findNodeImplementation)(childCallExpressionNode.getFirstChildByKind(ts_morph_1.SyntaxKind.SyntaxList).getFirstChild());
+        const typeReferenceNode = callExpressionArgument
+            .getParent()
+            .getFirstChildByKind(ts_morph_1.SyntaxKind.TypeReference);
+        if (typeReferenceNode) {
+            return (0, exports.getProperTypeShape)(typeReferenceNode.getType(), typeReferenceNode, []);
+        }
+        const thingyNode = callExpressionArgument
+            .getParent()
+            .getFirstChildByKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+        if (thingyNode) {
+            return (0, exports.getValidatorPropertyShape)(thingyNode);
+        }
+        if (callExpressionArgument.getKind() === ts_morph_1.SyntaxKind.CallExpression) {
+            return (0, exports.getValidatorPropertyShape)(callExpressionArgument);
+        }
+        if (callExpressionArgument.getKind() === ts_morph_1.SyntaxKind.IntersectionType) {
+            return (0, exports.getValidatorPropertyShape)(callExpressionArgument);
+        }
+        return 'unknown_3';
+    }
+    const innerNodePropertyAssignments = innerLiteralNode
+        .getFirstChildByKind(ts_morph_1.SyntaxKind.SyntaxList)
+        .getChildrenOfKind(ts_morph_1.SyntaxKind.PropertyAssignment);
+    const parsePropertyAssignment = innerNodePropertyAssignments.find((prop) => {
+        var _a;
+        return ((_a = prop.getFirstChildByKind(ts_morph_1.SyntaxKind.Identifier)) === null || _a === void 0 ? void 0 : _a.getText()) === 'parse';
+    });
+    if (parsePropertyAssignment) {
+        const returnType = (0, exports.findPropertyAssignmentValueNode)(parsePropertyAssignment)
+            .asKind(ts_morph_1.SyntaxKind.ArrowFunction)
+            .getReturnType();
+        return (0, exports.getProperTypeShape)(returnType, parsePropertyAssignment);
+    }
+    const importTypeNode = (_a = innerLiteralNode
+        .getFirstChildByKind(ts_morph_1.SyntaxKind.SyntaxList)) === null || _a === void 0 ? void 0 : _a.getFirstChildByKind(ts_morph_1.SyntaxKind.ImportType);
+    if (importTypeNode) {
+        const indexOfGreaterThanToken = importTypeNode
+            .getLastChildByKind(ts_morph_1.SyntaxKind.GreaterThanToken)
+            .getChildIndex();
+        const targetSyntaxList = importTypeNode.getChildAtIndex(indexOfGreaterThanToken - 1);
+        return (0, exports.getRecursiveNodeShape)(targetSyntaxList.getFirstChild());
+    }
+    return 'unknown_2';
+};
+exports.getValidatorPropertyShape = getValidatorPropertyShape;
+const getValidatorPropertyOptionality = (node) => {
+    const callExpressionNode = node.asKind(ts_morph_1.SyntaxKind.CallExpression);
+    if (callExpressionNode) {
+        const identifierNode = callExpressionNode.getFirstChildByKind(ts_morph_1.SyntaxKind.Identifier);
+        if ((identifierNode === null || identifierNode === void 0 ? void 0 : identifierNode.getText()) === 'OptionalParam') {
+            return true;
+        }
+        else if ((identifierNode === null || identifierNode === void 0 ? void 0 : identifierNode.getText()) === 'RequiredParam') {
+            return false;
+        }
+        const syntaxListNode = callExpressionNode.getFirstChildByKind(ts_morph_1.SyntaxKind.SyntaxList);
+        const literalExpression = (0, exports.findNodeImplementation)(syntaxListNode.getFirstChild());
+        return (0, exports.getValidatorPropertyOptionality)(literalExpression);
+    }
+    const syntaxListNode = node.getFirstDescendantByKind(ts_morph_1.SyntaxKind.SyntaxList);
+    const assignmentNodes = syntaxListNode.getChildrenOfKind(ts_morph_1.SyntaxKind.PropertyAssignment);
+    return assignmentNodes.some((node) => {
+        const identifierNode = node.getFirstDescendantByKind(ts_morph_1.SyntaxKind.Identifier);
+        const identifierName = identifierNode.getText();
+        if (identifierName === 'optional') {
+            const value = (0, exports.findPropertyAssignmentValueNode)(node);
+            return value.getKind() === ts_morph_1.SyntaxKind.TrueKeyword;
+        }
+        return false;
+    });
+};
+exports.getValidatorPropertyOptionality = getValidatorPropertyOptionality;
+const getValidatorPropertyStringValue = (nodeOrReference, name) => {
+    const node = (0, exports.findNodeImplementation)(nodeOrReference);
+    const callExpressionNode = node.asKind(ts_morph_1.SyntaxKind.CallExpression);
+    if (callExpressionNode) {
+        const targetChild = callExpressionNode.getLastChildByKind(ts_morph_1.SyntaxKind.SyntaxList);
+        return (0, exports.getValidatorPropertyStringValue)(targetChild, name);
+    }
+    const syntaxListNode = node.asKind(ts_morph_1.SyntaxKind.SyntaxList);
+    if (syntaxListNode) {
+        const children = syntaxListNode.getChildren().map((c) => (0, exports.getValidatorPropertyStringValue)(c, name));
+        return children.find((value) => !!value && value !== 'unknown_25') || '';
+    }
+    const objectLiteralNode = node.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+    if (objectLiteralNode) {
+        const values = (0, exports.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(ts_morph_1.SyntaxKind.IntersectionType);
+    if (intersectionTypeNode) {
+        return (intersectionTypeNode
+            .getTypeNodes()
+            .flatMap((t) => (0, exports.getValidatorPropertyStringValue)(t, name))
+            .filter((v) => !!v && v !== 'unknown_25')[0] || 'unknown_27');
+    }
+    const typeLiteralNode = node.asKind(ts_morph_1.SyntaxKind.TypeLiteral);
+    if (typeLiteralNode) {
+        return (0, exports.getValidatorPropertyStringValue)(typeLiteralNode.getFirstChildByKind(ts_morph_1.SyntaxKind.SyntaxList), name);
+    }
+    const propertySignatureNode = node.asKind(ts_morph_1.SyntaxKind.PropertySignature);
+    if (propertySignatureNode) {
+        const identifier = node.getFirstDescendantByKind(ts_morph_1.SyntaxKind.Identifier);
+        if (identifier.getText() === name) {
+            const targetNode = (0, exports.findPropertyAssignmentValueNode)(propertySignatureNode).getFirstDescendantByKind(ts_morph_1.SyntaxKind.StringLiteral);
+            return targetNode.getLiteralText();
+        }
+    }
+    return 'unknown_25';
+};
+exports.getValidatorPropertyStringValue = getValidatorPropertyStringValue;
+const isPromise = (type) => {
+    const symbol = type.getSymbol();
+    if (!type.isObject() || !symbol) {
+        return false;
+    }
+    const args = type.getTypeArguments();
+    return symbol.getName() === 'Promise' && args.length === 1;
+};
+const getProperTypeShape = (typeOrPromise, atLocation, stack = []) => {
+    var _a;
+    const typeName = (_a = typeOrPromise.getAliasSymbol()) === null || _a === void 0 ? void 0 : _a.getName();
+    if (typeName && OpenApiManager_1.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',
+                shape: String(type.getLiteralValue()),
+                optional: false,
+            },
+        ];
+    }
+    if (type.isNumberLiteral()) {
+        return [
+            {
+                role: 'literal_number',
+                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',
+                shape: type.getTupleElements().map((t) => ({
+                    role: 'tuple_entry',
+                    shape: (0, exports.getProperTypeShape)(t, atLocation, nextStack),
+                    optional: false,
+                })),
+                optional: false,
+            },
+        ];
+    }
+    if (type.isArray()) {
+        return [
+            {
+                role: 'array',
+                shape: (0, exports.getProperTypeShape)(type.getArrayElementType(), atLocation, nextStack),
+                optional: false,
+            },
+        ];
+    }
+    if (type.isObject() && type.getProperties().length === 0) {
+        const targetType = type.getAliasTypeArguments()[1];
+        return [
+            {
+                role: 'record',
+                shape: (0, exports.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',
+                    identifier: prop.getName(),
+                    shape: (0, exports.getProperTypeShape)(prop.getTypeAtLocation(atLocation), atLocation, nextStack),
+                    optional: false,
+                };
+            }
+            const valueDeclarationNode = valueDeclaration.asKind(ts_morph_1.SyntaxKind.PropertySignature) ||
+                valueDeclaration.asKind(ts_morph_1.SyntaxKind.PropertyAssignment) ||
+                valueDeclaration.asKind(ts_morph_1.SyntaxKind.ShorthandPropertyAssignment);
+            if (!valueDeclarationNode) {
+                return {
+                    role: 'property',
+                    identifier: prop.getName(),
+                    shape: (0, exports.getProperTypeShape)(prop.getTypeAtLocation(atLocation), atLocation, nextStack),
+                    optional: false,
+                };
+            }
+            const isOptional = prop.getTypeAtLocation(atLocation).isNullable();
+            const shape = (0, exports.getProperTypeShape)(prop.getTypeAtLocation(atLocation), atLocation, nextStack);
+            return {
+                role: 'property',
+                identifier: prop.getName(),
+                shape: shape,
+                optional: isOptional,
+            };
+        })
+            .filter((val) => val.shape !== 'undefined');
+    }
+    if (type.isUnion()) {
+        const unfilteredShapes = type.getUnionTypes().map((type) => ({
+            role: 'union_entry',
+            shape: (0, exports.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) => (0, exports.getProperTypeShape)(child, atLocation, nextStack))
+            .filter((shape) => typeof shape !== 'string');
+        return shapesOfChildren.reduce((total, current) => [...total, ...current], []);
+    }
+    return 'unknown_5';
+};
+exports.getProperTypeShape = getProperTypeShape;
+const getLiteralValueOfNode = (node) => {
+    if (node.isKind(ts_morph_1.SyntaxKind.Identifier)) {
+        return getLiteralValueOfNode((0, exports.findNodeImplementation)(node));
+    }
+    else if (node.isKind(ts_morph_1.SyntaxKind.StringLiteral)) {
+        return node.getLiteralValue();
+    }
+    else if (node.isKind(ts_morph_1.SyntaxKind.ArrayLiteralExpression)) {
+        return node.forEachChildAsArray().map((child) => getLiteralValueOfNode(child));
+    }
+    else if (node.isKind(ts_morph_1.SyntaxKind.PropertyAccessExpression)) {
+        return getLiteralValueOfNode((0, exports.findPropertyAssignmentValueNode)(node));
+    }
+    else if (node.isKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression)) {
+        return (0, exports.getValuesOfObjectLiteral)(node);
+    }
+    return 'unknown_6';
+};
+const getValuesOfObjectLiteral = (objectLiteralNode) => {
+    const syntaxListNode = objectLiteralNode.getFirstDescendantByKind(ts_morph_1.SyntaxKind.SyntaxList);
+    const assignmentNodes = syntaxListNode.getChildrenOfKind(ts_morph_1.SyntaxKind.PropertyAssignment);
+    const properties = assignmentNodes.map((node) => {
+        const identifierNode = node.getFirstDescendantByKind(ts_morph_1.SyntaxKind.Identifier);
+        const identifierName = identifierNode.getText();
+        const assignmentValueNode = node.getLastChild();
+        const targetNode = (0, exports.findNodeImplementation)(assignmentValueNode);
+        const value = getLiteralValueOfNode(targetNode);
+        return {
+            identifier: identifierName,
+            value,
+        };
+    });
+    return properties || [];
+};
+exports.getValuesOfObjectLiteral = getValuesOfObjectLiteral;

package/dist/src/openapi/analyzerModule/parseEndpoint.d.ts

@@ -0,0 +1,4 @@
+import { Node, ts } from 'ts-morph';
+import { EndpointData } from '../types';
+export declare const parseEndpoint: (node: Node<ts.Node>, sourceFilePath: string) => EndpointData;
+//# sourceMappingURL=parseEndpoint.d.ts.map

package/dist/src/openapi/analyzerModule/parseEndpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseEndpoint.d.ts","sourceRoot":"","sources":["../../../../src/openapi/analyzerModule/parseEndpoint.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAc,EAAE,EAAE,MAAM,UAAU,CAAA;AAG/C,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAWvC,eAAO,MAAM,aAAa,SAAU,KAAK,OAAO,CAAC,kBAAkB,MAAM,iBAqHxE,CAAA"}