@valkyrjaio/sindri 26.0.1

package/src/Sindri/Ast/HttpRouteMiddlewareReader.ts

@@ -0,0 +1,214 @@
+/*
+ * This file is part of the Sindri package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { ts } from 'ts-morph';
+
+import { AstReader } from './Abstract/AstReader.ts';
+
+import type { MethodDeclaration } from 'ts-morph';
+
+import type { HttpRouteData } from './Data/HttpRouteData.ts';
+import type { HttpRouteMiddlewareReaderContract } from './Contract/HttpRouteMiddlewareReaderContract.ts';
+
+/**
+ * Reads middleware, request methods, and struct decorators for HTTP routes, and builds
+ * their corresponding AST expressions.
+ *
+ * Extracted from HttpRouteAttributeReader to keep each class under the
+ * complexity threshold; injected as a constructor argument.
+ */
+export class HttpRouteMiddlewareReader extends AstReader implements HttpRouteMiddlewareReaderContract {
+    extractInlineRequestMethods(
+        decoratorArgs: ts.NodeArray<ts.Expression> | ts.Expression[],
+        useMap: Record<string, string>,
+        namespace: string,
+        currentClass: string,
+    ): string[] {
+        const requestMethodsArg = decoratorArgs[3];
+
+        if (requestMethodsArg === undefined || !ts.isArrayLiteralExpression(requestMethodsArg)) {
+            return [];
+        }
+
+        return this.extractClassListFromArrayExpr(requestMethodsArg, useMap, namespace, currentClass);
+    }
+
+    updateRequestMethods(
+        requestMethods: string[],
+        method: MethodDeclaration,
+        useMap: Record<string, string>,
+        namespace: string,
+        currentClass: string,
+    ): string[] {
+        for (const decorator of this.findDecoratorsOnNode(method, 'RequestMethod', useMap, namespace)) {
+            for (const arg of decorator.getArguments()) {
+                const value = this.extractExprValue(arg, useMap, namespace, currentClass);
+
+                if (typeof value === 'string' && value !== '') {
+                    requestMethods = [...requestMethods, value];
+                }
+            }
+        }
+
+        if (requestMethods.length === 0) {
+            requestMethods = [
+                'Valkyrja\\Http\\Message\\Enum\\RequestMethod::HEAD',
+                'Valkyrja\\Http\\Message\\Enum\\RequestMethod::GET',
+            ];
+        }
+
+        return requestMethods;
+    }
+
+    updateMiddleware(
+        method: MethodDeclaration,
+        useMap: Record<string, string>,
+        namespace: string,
+        currentClass: string,
+        routeMatchedMiddleware: string[],
+        routeDispatchedMiddleware: string[],
+        throwableCaughtMiddleware: string[],
+        sendingResponseMiddleware: string[],
+        terminatedMiddleware: string[],
+    ): [string[], string[], string[], string[], string[]] {
+        for (const decorator of this.findDecoratorsOnNode(method, 'Middleware', useMap, namespace)) {
+            const mwName = this.extractExprValue(this.getDecoratorArg(decorator, 0), useMap, namespace, currentClass);
+
+            if (typeof mwName !== 'string' || mwName === '') {
+                continue;
+            }
+
+            [
+                routeMatchedMiddleware,
+                routeDispatchedMiddleware,
+                throwableCaughtMiddleware,
+                sendingResponseMiddleware,
+                terminatedMiddleware,
+            ] = this.classifyMiddleware(
+                mwName,
+                useMap,
+                namespace,
+                routeMatchedMiddleware,
+                routeDispatchedMiddleware,
+                throwableCaughtMiddleware,
+                sendingResponseMiddleware,
+                terminatedMiddleware,
+            );
+        }
+
+        return [
+            routeMatchedMiddleware,
+            routeDispatchedMiddleware,
+            throwableCaughtMiddleware,
+            sendingResponseMiddleware,
+            terminatedMiddleware,
+        ];
+    }
+
+    updateRequestStruct(
+        method: MethodDeclaration,
+        useMap: Record<string, string>,
+        namespace: string,
+        currentClass: string,
+    ): string | null {
+        for (const decorator of this.findDecoratorsOnNode(method, 'RequestStruct', useMap, namespace)) {
+            const value = this.extractExprValue(this.getDecoratorArg(decorator, 0), useMap, namespace, currentClass);
+
+            if (typeof value === 'string' && value !== '') {
+                return value;
+            }
+        }
+
+        return null;
+    }
+
+    updateResponseStruct(
+        method: MethodDeclaration,
+        useMap: Record<string, string>,
+        namespace: string,
+        currentClass: string,
+    ): string | null {
+        for (const decorator of this.findDecoratorsOnNode(method, 'ResponseStruct', useMap, namespace)) {
+            const value = this.extractExprValue(this.getDecoratorArg(decorator, 0), useMap, namespace, currentClass);
+
+            if (typeof value === 'string' && value !== '') {
+                return value;
+            }
+        }
+
+        return null;
+    }
+
+    buildRouteMiddlewareArgs(data: HttpRouteData): ts.Expression[] {
+        return [
+            this.buildClassIdentifierArrayExpr(data.routeMatchedMiddleware),
+            this.buildClassIdentifierArrayExpr(data.routeDispatchedMiddleware),
+            this.buildClassIdentifierArrayExpr(data.throwableCaughtMiddleware),
+            this.buildClassIdentifierArrayExpr(data.sendingResponseMiddleware),
+            this.buildClassIdentifierArrayExpr(data.terminatedMiddleware),
+        ];
+    }
+
+    buildRouteStructArgs(data: HttpRouteData): ts.Expression[] {
+        const args: ts.Expression[] = [];
+
+        if (data.requestStruct !== null) {
+            args.push(this.buildClassConstExpr(data.requestStruct));
+        } else {
+            args.push(this.buildNullExpr());
+        }
+
+        if (data.responseStruct !== null) {
+            args.push(this.buildClassConstExpr(data.responseStruct));
+        } else {
+            args.push(this.buildNullExpr());
+        }
+
+        return args;
+    }
+
+    protected classifyMiddleware(
+        mwName: string,
+        useMap: Record<string, string>,
+        currentFilePath: string,
+        routeMatchedMiddleware: string[],
+        routeDispatchedMiddleware: string[],
+        throwableCaughtMiddleware: string[],
+        sendingResponseMiddleware: string[],
+        terminatedMiddleware: string[],
+    ): [string[], string[], string[], string[], string[]] {
+        if (this.classImplementsInterface(mwName, 'RouteMatchedMiddlewareContract', useMap, currentFilePath)) {
+            routeMatchedMiddleware = [...routeMatchedMiddleware, mwName];
+        }
+
+        if (this.classImplementsInterface(mwName, 'RouteDispatchedMiddlewareContract', useMap, currentFilePath)) {
+            routeDispatchedMiddleware = [...routeDispatchedMiddleware, mwName];
+        }
+
+        if (this.classImplementsInterface(mwName, 'ThrowableCaughtMiddlewareContract', useMap, currentFilePath)) {
+            throwableCaughtMiddleware = [...throwableCaughtMiddleware, mwName];
+        }
+
+        if (this.classImplementsInterface(mwName, 'SendingResponseMiddlewareContract', useMap, currentFilePath)) {
+            sendingResponseMiddleware = [...sendingResponseMiddleware, mwName];
+        }
+
+        if (this.classImplementsInterface(mwName, 'TerminatedMiddlewareContract', useMap, currentFilePath)) {
+            terminatedMiddleware = [...terminatedMiddleware, mwName];
+        }
+
+        return [
+            routeMatchedMiddleware,
+            routeDispatchedMiddleware,
+            throwableCaughtMiddleware,
+            sendingResponseMiddleware,
+            terminatedMiddleware,
+        ];
+    }
+}

package/src/Sindri/Ast/HttpRouteParameterReader.ts

@@ -0,0 +1,193 @@
+/*
+ * This file is part of the Sindri package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { ts } from 'ts-morph';
+
+import { AstReader } from './Abstract/AstReader.ts';
+import { HttpParameterData } from './Data/HttpParameterData.ts';
+
+import type { Decorator, MethodDeclaration } from 'ts-morph';
+
+import type { HttpRouteParameterReaderContract } from './Contract/HttpRouteParameterReaderContract.ts';
+
+/**
+ * Reads and builds AST expressions for HTTP dynamic route parameters.
+ *
+ * Extracted from HttpRouteAttributeReader to keep each class under the
+ * complexity threshold; injected as a constructor argument.
+ */
+export class HttpRouteParameterReader extends AstReader implements HttpRouteParameterReaderContract {
+    updateParameters(
+        decoratorArgs: ts.NodeArray<ts.Expression> | ts.Expression[],
+        method: MethodDeclaration,
+        useMap: Record<string, string>,
+        namespace: string,
+        currentClass: string,
+    ): HttpParameterData[] {
+        return [
+            ...this.collectInlineParameters(decoratorArgs, useMap, namespace, currentClass),
+            ...this.collectAttributeParameters(method, useMap, namespace, currentClass),
+            ...this.collectMethodParamParameters(method, useMap, namespace, currentClass),
+        ];
+    }
+
+    buildParameterListExpr(parameters: HttpParameterData[]): ts.ArrayLiteralExpression {
+        const elements = parameters.map((p) => this.buildParameterExpr(p));
+        return ts.factory.createArrayLiteralExpression(elements);
+    }
+
+    protected collectInlineParameters(
+        decoratorArgs: ts.NodeArray<ts.Expression> | ts.Expression[],
+        useMap: Record<string, string>,
+        currentFilePath: string,
+        currentClass: string,
+    ): HttpParameterData[] {
+        const inlineArg = decoratorArgs[2];
+
+        if (inlineArg === undefined || !ts.isArrayLiteralExpression(inlineArg)) {
+            return [];
+        }
+
+        const parameters: HttpParameterData[] = [];
+
+        for (const element of inlineArg.elements) {
+            if (!ts.isNewExpression(element) || element.arguments === undefined) {
+                continue;
+            }
+
+            const param = this.buildParameterDataFromTsArgs(element.arguments, useMap, currentFilePath, currentClass);
+
+            if (param !== null) {
+                parameters.push(param);
+            }
+        }
+
+        return parameters;
+    }
+
+    protected collectAttributeParameters(
+        method: MethodDeclaration,
+        useMap: Record<string, string>,
+        currentFilePath: string,
+        currentClass: string,
+    ): HttpParameterData[] {
+        const parameters: HttpParameterData[] = [];
+
+        for (const decorator of this.findDecoratorsOnNode(method, 'Parameter', useMap, currentFilePath)) {
+            const param = this.buildParameterDataFromDecorator(decorator, useMap, currentFilePath, currentClass);
+
+            if (param !== null) {
+                parameters.push(param);
+            }
+        }
+
+        return parameters;
+    }
+
+    protected collectMethodParamParameters(
+        method: MethodDeclaration,
+        useMap: Record<string, string>,
+        currentFilePath: string,
+        currentClass: string,
+    ): HttpParameterData[] {
+        const parameters: HttpParameterData[] = [];
+
+        for (const methodParam of method.getParameters()) {
+            for (const decorator of this.findDecoratorsOnNode(methodParam, 'Parameter', useMap, currentFilePath)) {
+                const param = this.buildParameterDataFromDecorator(decorator, useMap, currentFilePath, currentClass);
+
+                if (param !== null) {
+                    parameters.push(param);
+                }
+            }
+        }
+
+        return parameters;
+    }
+
+    protected buildParameterDataFromDecorator(
+        decorator: Decorator,
+        useMap: Record<string, string>,
+        currentFilePath: string,
+        currentClass: string,
+    ): HttpParameterData | null {
+        const name = this.extractStringArg(decorator, 0, useMap, currentFilePath, currentClass);
+        const regex = this.extractStringArg(decorator, 1, useMap, currentFilePath, currentClass);
+
+        if (name === '' || regex === '') {
+            return null;
+        }
+
+        return new HttpParameterData(
+            name,
+            regex,
+            this.extractStringArg(decorator, 2, useMap, currentFilePath, currentClass) || null,
+            this.extractBoolArg(decorator, 3, useMap, currentFilePath, currentClass, false),
+            this.extractBoolArg(decorator, 4, useMap, currentFilePath, currentClass, true),
+        );
+    }
+
+    protected buildParameterDataFromTsArgs(
+        args: ts.NodeArray<ts.Expression>,
+        useMap: Record<string, string>,
+        currentFilePath: string,
+        currentClass: string,
+    ): HttpParameterData | null {
+        const nameNode = args[0];
+        const regexNode = args[1];
+
+        if (nameNode === undefined || regexNode === undefined) {
+            return null;
+        }
+
+        const name = this.extractExprValue(nameNode, useMap, currentFilePath, currentClass);
+        const regex = this.extractExprValue(regexNode, useMap, currentFilePath, currentClass);
+
+        if (typeof name !== 'string' || name === '' || typeof regex !== 'string' || regex === '') {
+            return null;
+        }
+
+        const castNode = args[2];
+        const castRaw =
+            castNode !== undefined ? this.extractExprValue(castNode, useMap, currentFilePath, currentClass) : null;
+        const cast = typeof castRaw === 'string' && castRaw !== '' ? castRaw : null;
+
+        const isOptionalNode = args[3];
+        const isOptionalRaw =
+            isOptionalNode !== undefined
+                ? this.extractExprValue(isOptionalNode, useMap, currentFilePath, currentClass)
+                : false;
+        const isOptional = typeof isOptionalRaw === 'boolean' ? isOptionalRaw : false;
+
+        const shouldCaptureNode = args[4];
+        const shouldCaptureRaw =
+            shouldCaptureNode !== undefined
+                ? this.extractExprValue(shouldCaptureNode, useMap, currentFilePath, currentClass)
+                : true;
+        const shouldCapture = typeof shouldCaptureRaw === 'boolean' ? shouldCaptureRaw : true;
+
+        return new HttpParameterData(name, regex, cast, isOptional, shouldCapture);
+    }
+
+    protected buildParameterExpr(data: HttpParameterData): ts.Expression {
+        const regexExpr = data.regex.includes('::')
+            ? this.buildEnumCaseExpr(data.regex)
+            : this.buildStringExpr(data.regex);
+
+        const args: ts.Expression[] = [
+            this.buildStringExpr(data.name),
+            regexExpr,
+            data.cast !== null ? this.buildEnumCaseExpr(data.cast) : this.buildNullExpr(),
+            this.buildBoolExpr(data.isOptional),
+            this.buildBoolExpr(data.shouldCapture),
+        ];
+
+        return this.buildNewExpr('Valkyrja\\Http\\Routing\\Data\\Parameter', args);
+    }
+}

package/src/Sindri/Ast/ListenerAttributeReader.ts

@@ -0,0 +1,131 @@
+/*
+ * This file is part of the Sindri package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { ts } from 'ts-morph';
+
+import { AstReader } from './Abstract/AstReader.ts';
+import { HandlerData } from './Data/HandlerData.ts';
+import { ListenerData } from './Data/ListenerData.ts';
+import { ListenerAttributeResult } from './Data/Result/ListenerAttributeResult.ts';
+
+import type { ClassDeclaration, Decorator, MethodDeclaration } from 'ts-morph';
+
+import type { ListenerAttributeReaderContract } from './Contract/ListenerAttributeReaderContract.ts';
+
+/**
+ * Scans a listener class file for @Listener and @ListenerHandler decorators
+ * and returns TypeScript compiler API Expr nodes ready for the data cache generator.
+ *
+ * Mirrors the logic of the framework's runtime attribute collector but operates
+ * entirely on AST without executing any TypeScript code.
+ */
+export class ListenerAttributeReader extends AstReader implements ListenerAttributeReaderContract {
+    protected static readonly DEFAULT_HANDLE_METHOD = 'handle';
+
+    readFile(filePath: string): ListenerAttributeResult {
+        const context = this.parseClassFile(filePath);
+
+        if (context === undefined) {
+            return new ListenerAttributeResult();
+        }
+
+        const { classDecl, useMap, currentClass } = context;
+        const listeners: Record<string, ts.Expression> = {};
+
+        for (const decorator of this.findDecoratorsOnNode(classDecl, 'Listener', useMap, filePath)) {
+            const data = this.buildListenerData(decorator, useMap, filePath, currentClass, classDecl, undefined);
+
+            if (data !== null) {
+                listeners[data.name] = this.buildListenerExpr(data);
+            }
+        }
+
+        for (const method of classDecl.getMethods()) {
+            for (const decorator of this.findDecoratorsOnNode(method, 'Listener', useMap, filePath)) {
+                const data = this.buildListenerData(decorator, useMap, filePath, currentClass, classDecl, method);
+
+                if (data !== null) {
+                    listeners[data.name] = this.buildListenerExpr(data);
+                }
+            }
+        }
+
+        return new ListenerAttributeResult(listeners);
+    }
+
+    protected buildListenerData(
+        decorator: Decorator,
+        useMap: Record<string, string>,
+        currentFilePath: string,
+        currentClass: string,
+        classDecl: ClassDeclaration,
+        method: MethodDeclaration | undefined,
+    ): ListenerData | null {
+        const eventId = this.extractStringArg(decorator, 0, useMap, currentFilePath, currentClass);
+        const name = this.extractStringArg(decorator, 1, useMap, currentFilePath, currentClass);
+
+        if (eventId === '' || name === '') {
+            return null;
+        }
+
+        const handlerRaw = this.extractExprValue(
+            this.getDecoratorArg(decorator, 2),
+            useMap,
+            currentFilePath,
+            currentClass,
+        );
+        const handler =
+            handlerRaw instanceof HandlerData
+                ? handlerRaw
+                : this.resolveListenerHandler(useMap, currentFilePath, currentClass, classDecl, method);
+
+        return new ListenerData(eventId, name, handler);
+    }
+
+    protected resolveListenerHandler(
+        useMap: Record<string, string>,
+        currentFilePath: string,
+        currentClass: string,
+        classDecl: ClassDeclaration,
+        method: MethodDeclaration | undefined,
+    ): HandlerData {
+        const node = method ?? classDecl;
+
+        for (const decorator of this.findDecoratorsOnNode(node, 'ListenerHandler', useMap, currentFilePath)) {
+            const handlerRaw = this.extractExprValue(
+                this.getDecoratorArg(decorator, 0),
+                useMap,
+                currentFilePath,
+                currentClass,
+            );
+
+            if (handlerRaw instanceof HandlerData) {
+                return handlerRaw;
+            }
+        }
+
+        if (method !== undefined) {
+            return new HandlerData(currentClass, method.getName());
+        }
+
+        return new HandlerData(currentClass, ListenerAttributeReader.DEFAULT_HANDLE_METHOD);
+    }
+
+    protected buildListenerExpr(data: ListenerData): ts.Expression {
+        const args: ts.Expression[] = [this.buildClassConstExpr(data.eventId), this.buildStringExpr(data.name)];
+
+        if (data.handler !== null) {
+            args.push(this.buildHandlerExpr(data.handler));
+        } else {
+            args.push(this.buildNullExpr());
+        }
+
+        return this.buildNewExpr('Valkyrja\\Event\\Data\\Listener', args);
+    }
+}

package/src/Sindri/Ast/ListenerProviderReader.ts

@@ -0,0 +1,45 @@
+/*
+ * This file is part of the Sindri package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ts } from 'ts-morph';
+
+import { AstReader } from './Abstract/AstReader.ts';
+import { ListenerProviderResult } from './Data/Result/ListenerProviderResult.ts';
+
+import type { ListenerProviderReaderContract } from './Contract/ListenerProviderReaderContract.ts';
+
+export class ListenerProviderReader extends AstReader implements ListenerProviderReaderContract {
+    protected static readonly METHOD_LISTENER_CLASSES = 'getListenerClasses';
+    protected static readonly METHOD_LISTENERS = 'getListeners';
+
+    readFile(filePath: string): ListenerProviderResult {
+        const sourceFile = this.parseFileToSourceFile(filePath);
+        const classDecl = this.findClass(sourceFile);
+
+        if (classDecl === undefined) {
+            return new ListenerProviderResult();
+        }
+
+        const useMap = this.buildUseMap(sourceFile);
+        const methods = this.indexMethods(classDecl);
+
+        return new ListenerProviderResult(
+            this.extractClassListFromValues(methods[ListenerProviderReader.METHOD_LISTENER_CLASSES], useMap, filePath),
+            this.extractListeners(methods[ListenerProviderReader.METHOD_LISTENERS], useMap, filePath),
+        );
+    }
+
+    protected extractListeners(
+        _method: ReturnType<typeof this.indexMethods>[string] | undefined,
+        _useMap: Record<string, string>,
+        _filePath: string,
+    ): ts.Expression[] {
+        return [];
+    }
+}

package/src/Sindri/Ast/RouteProviderReader.ts

@@ -0,0 +1,45 @@
+/*
+ * This file is part of the Sindri package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ts } from 'ts-morph';
+
+import { AstReader } from './Abstract/AstReader.ts';
+import { RouteProviderResult } from './Data/Result/RouteProviderResult.ts';
+
+import type { RouteProviderReaderContract } from './Contract/RouteProviderReaderContract.ts';
+
+export class RouteProviderReader extends AstReader implements RouteProviderReaderContract {
+    protected static readonly METHOD_CONTROLLER_CLASSES = 'getControllerClasses';
+    protected static readonly METHOD_ROUTES = 'getRoutes';
+
+    readFile(filePath: string): RouteProviderResult {
+        const sourceFile = this.parseFileToSourceFile(filePath);
+        const classDecl = this.findClass(sourceFile);
+
+        if (classDecl === undefined) {
+            return new RouteProviderResult();
+        }
+
+        const useMap = this.buildUseMap(sourceFile);
+        const methods = this.indexMethods(classDecl);
+
+        return new RouteProviderResult(
+            this.extractClassListFromValues(methods[RouteProviderReader.METHOD_CONTROLLER_CLASSES], useMap, filePath),
+            this.extractRoutes(methods[RouteProviderReader.METHOD_ROUTES], useMap, filePath),
+        );
+    }
+
+    protected extractRoutes(
+        _method: ReturnType<typeof this.indexMethods>[string] | undefined,
+        _useMap: Record<string, string>,
+        _filePath: string,
+    ): ts.Expression[] {
+        return [];
+    }
+}