@valkyrjaio/sindri 26.2.0 → 26.4.0

package/src/Sindri/Generator/Ast/Http/AstHttpDataFileGenerator.ts

@@ -13,6 +13,7 @@ import { DynamicRoute } from '@valkyrjaio/valkyrja/Http/Routing/Data/DynamicRout
 import { Parameter } from '@valkyrjaio/valkyrja/Http/Routing/Data/Parameter.ts';
 import { Regex } from '@valkyrjaio/valkyrja/Http/Routing/Constant/Regex.ts';
 import { Processor } from '@valkyrjaio/valkyrja/Http/Routing/Processor/Processor.ts';
+import { RequestMethod, allRequestMethods } from '@valkyrjaio/valkyrja/Http/Message/Enum/RequestMethod.ts';
 
 import { AstFileGenerator } from '../../Abstract/AstFileGenerator.ts';
 import { GeneratorUnreachableException } from '../../Throwable/Exception/GeneratorUnreachableException.ts';
@@ -22,7 +23,32 @@ import type { HttpParameterData } from '../../../Ast/Data/HttpParameterData.ts';
 import type { HttpRouteData } from '../../../Ast/Data/HttpRouteData.ts';
 import type { ProcessorContract } from '@valkyrjaio/valkyrja/Http/Routing/Processor/Contract/ProcessorContract.ts';
 
+/** Metadata extracted from an imperative `new Route(...)` / `new DynamicRoute(...)` expression. */
+interface ImperativeRouteMeta {
+    readonly expr: ts.Expression;
+    readonly name: string;
+    readonly path: string;
+    readonly isDynamic: boolean;
+    readonly regex: string;
+    readonly methods: readonly string[];
+}
+
 export class AstHttpDataFileGenerator extends AstFileGenerator implements HttpDataFileGeneratorContract {
+    /** The framework classes every generated HTTP data file imports as values. */
+    protected static readonly FRAMEWORK_IMPORTS: Readonly<Record<string, string>> = {
+        HttpRoutingData: '@valkyrjaio/valkyrja/Http/Routing/Data/HttpRoutingData.ts',
+        DynamicRoute: '@valkyrjaio/valkyrja/Http/Routing/Data/DynamicRoute.ts',
+        Route: '@valkyrjaio/valkyrja/Http/Routing/Data/Route.ts',
+        Parameter: '@valkyrjaio/valkyrja/Http/Routing/Data/Parameter.ts',
+        RequestMethod: '@valkyrjaio/valkyrja/Http/Message/Enum/RequestMethod.ts',
+        Regex: '@valkyrjaio/valkyrja/Http/Routing/Constant/Regex.ts',
+    };
+
+    /** The framework types every generated HTTP data file imports. */
+    protected static readonly FRAMEWORK_TYPE_IMPORTS: Readonly<Record<string, string>> = {
+        RouteContract: '@valkyrjaio/valkyrja/Http/Routing/Data/Contract/RouteContract.ts',
+    };
+
     public classImportMap: Record<string, string> = {};
 
     protected readonly processor: ProcessorContract;
@@ -49,27 +75,68 @@ export class AstHttpDataFileGenerator extends AstFileGenerator implements HttpDa
         routes: Record<string, ts.Expression>,
         routeData: Record<string, HttpRouteData>,
     ): GenerateStatus {
-        const userImports = Object.entries(this.classImportMap)
-            .map(([name, specifier]) => `import { ${name} } from '${specifier}';`)
-            .join('\n');
-
-        const userImportsBlock = userImports ? `${userImports}\n` : '';
+        const userImportsBlock = this.buildUserImportsBlock(this.classImportMap, [
+            ...Object.keys(AstHttpDataFileGenerator.FRAMEWORK_IMPORTS),
+            ...Object.keys(AstHttpDataFileGenerator.FRAMEWORK_TYPE_IMPORTS),
+        ]);
 
         const routesContent = this.getRoutesAsContent(routes, routeData);
         const paths = this.printNestedObject(this.buildPaths(routeData));
         const dynamicPaths = this.printNestedObject(this.buildDynamicPaths(routeData));
         const regexes = this.printNestedObject(this.buildRegexes(routeData));
 
-        const data = [
+        const data = this.assembleFile(className, userImportsBlock, routesContent, paths, dynamicPaths, regexes);
+
+        return this.writeFile(directory, className, data);
+    }
+
+    /**
+     * Generate the routing data file from imperative `getRoutes()` route
+     * objects (as opposed to attribute-scanned routes).
+     *
+     * Each route expression is emitted verbatim as a route closure and the
+     * path/dynamic-path/regex lookup maps are derived from the route objects'
+     * own arguments, mirroring the framework's runtime `RouteCollection`
+     * (literal path and regex, request methods defaulting to `[HEAD, GET]`).
+     */
+    public generateFileFromRoutes(
+        directory: string,
+        className: string,
+        _namespace: string,
+        routeExprs: readonly ts.Expression[],
+    ): GenerateStatus {
+        const userImportsBlock = this.buildUserImportsBlock(this.classImportMap, [
+            ...Object.keys(AstHttpDataFileGenerator.FRAMEWORK_IMPORTS),
+            ...Object.keys(AstHttpDataFileGenerator.FRAMEWORK_TYPE_IMPORTS),
+        ]);
+
+        const metas = routeExprs
+            .map((expr) => this.extractRouteMeta(expr))
+            .filter((meta): meta is ImperativeRouteMeta => meta !== undefined);
+
+        const routesContent = this.getImperativeRoutesContent(metas);
+        const paths = this.printNestedObject(this.buildImperativePaths(metas, false));
+        const dynamicPaths = this.printNestedObject(this.buildImperativePaths(metas, true));
+        const regexes = this.printNestedObject(this.buildImperativeRegexes(metas));
+
+        const data = this.assembleFile(className, userImportsBlock, routesContent, paths, dynamicPaths, regexes);
+
+        return this.writeFile(directory, className, data);
+    }
+
+    protected assembleFile(
+        className: string,
+        userImportsBlock: string,
+        routesContent: string,
+        paths: string,
+        dynamicPaths: string,
+        regexes: string,
+    ): string {
+        return [
             '// This file was automatically generated by Sindri.',
             '',
-            `import { HttpRoutingData } from '@valkyrjaio/valkyrja/Http/Routing/Data/HttpRoutingData.ts';`,
-            `import { DynamicRoute } from '@valkyrjaio/valkyrja/Http/Routing/Data/DynamicRoute.ts';`,
-            `import { Route } from '@valkyrjaio/valkyrja/Http/Routing/Data/Route.ts';`,
-            `import { Parameter } from '@valkyrjaio/valkyrja/Http/Routing/Data/Parameter.ts';`,
-            `import { RequestMethod } from '@valkyrjaio/valkyrja/Http/Message/Enum/RequestMethod.ts';`,
-            `import { Regex } from '@valkyrjaio/valkyrja/Http/Routing/Constant/Regex.ts';`,
-            `import type { RouteContract } from '@valkyrjaio/valkyrja/Http/Routing/Data/Contract/RouteContract.ts';`,
+            ...this.buildFrameworkImportLines(AstHttpDataFileGenerator.FRAMEWORK_IMPORTS),
+            ...this.buildFrameworkImportLines(AstHttpDataFileGenerator.FRAMEWORK_TYPE_IMPORTS, true),
             userImportsBlock,
             `export class ${className} extends HttpRoutingData {`,
             `    constructor() {`,
@@ -83,8 +150,6 @@ export class AstHttpDataFileGenerator extends AstFileGenerator implements HttpDa
             `}`,
             '',
         ].join('\n');
-
-        return this.writeFile(directory, className, data);
     }
 
     public generateClassContents(
@@ -292,15 +357,130 @@ export class AstHttpDataFileGenerator extends AstFileGenerator implements HttpDa
                 expr = ts.factory.createNewExpression(expr.expression, expr.typeArguments, args);
             }
 
-            const keyExpr = this.buildEnumCaseExpr(key);
-            const printedKey = this.printer.printNode(ts.EmitHint.Unspecified, keyExpr, this.dummySourceFile);
             const printedRoute = this.printer.printNode(ts.EmitHint.Unspecified, expr, this.dummySourceFile);
-
-            const formattedKey = key.includes('::') ? `[${printedKey}]` : `['${printedKey}']`;
+            const formattedKey = key.includes('::')
+                ? `[${this.printer.printNode(ts.EmitHint.Unspecified, this.buildEnumCaseExpr(key), this.dummySourceFile)}]`
+                : `['${key}']`;
 
             lines.push(`            ${formattedKey}: (): RouteContract => ${printedRoute},`);
         }
 
         return ['{', ...lines, '        }'].join('\n        ');
     }
+
+    // -------------------------------------------------------------------------
+    // Imperative `getRoutes()` support
+    // -------------------------------------------------------------------------
+
+    /**
+     * Extract routing metadata from a `new Route(...)` / `new DynamicRoute(...)`
+     * expression, matching the framework constructor argument order:
+     *   Route(path, name, handler, requestMethods?)
+     *   DynamicRoute(path, name, regex, parameters, handler, requestMethods?)
+     */
+    protected extractRouteMeta(expr: ts.Expression): ImperativeRouteMeta | undefined {
+        if (!ts.isNewExpression(expr) || !ts.isIdentifier(expr.expression)) {
+            return undefined;
+        }
+
+        const isDynamic = expr.expression.text === 'DynamicRoute';
+        const args = expr.arguments ?? ts.factory.createNodeArray<ts.Expression>();
+
+        const path = this.stringArg(args[0]);
+        const name = this.stringArg(args[1]);
+
+        if (name === undefined || path === undefined) {
+            return undefined;
+        }
+
+        const regex = isDynamic ? (this.stringArg(args[2]) ?? '') : '';
+        const methodsArg = isDynamic ? args[5] : args[3];
+        const methods = this.extractMethodNamesFromArg(methodsArg);
+
+        return { expr, name, path, isDynamic, regex, methods };
+    }
+
+    protected stringArg(node: ts.Expression | undefined): string | undefined {
+        return node !== undefined && ts.isStringLiteral(node) ? node.text : undefined;
+    }
+
+    /**
+     * Resolve a `[RequestMethod.GET, ...]` argument to method-name strings,
+     * defaulting to `[HEAD, GET]` (the framework `Route` default) when omitted
+     * and expanding `RequestMethod.ANY` to every request method.
+     */
+    protected extractMethodNamesFromArg(node: ts.Expression | undefined): string[] {
+        if (node === undefined || !ts.isArrayLiteralExpression(node)) {
+            return [RequestMethod.HEAD, RequestMethod.GET];
+        }
+
+        const methods: string[] = [];
+
+        for (const element of node.elements) {
+            if (!ts.isPropertyAccessExpression(element)) {
+                continue;
+            }
+
+            const method = element.name.text;
+
+            if (method === 'ANY') {
+                return allRequestMethods();
+            }
+
+            methods.push(method);
+        }
+
+        return methods;
+    }
+
+    protected getImperativeRoutesContent(metas: readonly ImperativeRouteMeta[]): string {
+        if (metas.length === 0) {
+            return '{}';
+        }
+
+        const lines: string[] = [];
+
+        for (const meta of metas) {
+            // Imperative route expressions come parsed from a provider's `getRoutes()`
+            // body, so they are emitted verbatim via their original source text.
+            lines.push(`            ['${meta.name}']: (): RouteContract => ${meta.expr.getText()},`);
+        }
+
+        return ['{', ...lines, '        }'].join('\n        ');
+    }
+
+    protected buildImperativePaths(
+        metas: readonly ImperativeRouteMeta[],
+        dynamic: boolean,
+    ): Record<string, Record<string, string>> {
+        const paths: Record<string, Record<string, string>> = {};
+
+        for (const meta of metas) {
+            if (meta.isDynamic !== dynamic) {
+                continue;
+            }
+
+            for (const method of meta.methods) {
+                (paths[method] ??= {})[meta.path] = meta.name;
+            }
+        }
+
+        return paths;
+    }
+
+    protected buildImperativeRegexes(metas: readonly ImperativeRouteMeta[]): Record<string, Record<string, string>> {
+        const regexes: Record<string, Record<string, string>> = {};
+
+        for (const meta of metas) {
+            if (!meta.isDynamic || meta.regex === '') {
+                continue;
+            }
+
+            for (const method of meta.methods) {
+                (regexes[method] ??= {})[meta.regex] = meta.name;
+            }
+        }
+
+        return regexes;
+    }
 }

package/src/Sindri/Generator/Cli/Contract/CliDataFileGeneratorContract.ts

@@ -12,6 +12,9 @@ import type { ts } from 'ts-morph';
 import type { GenerateStatus } from '../../Enum/GenerateStatus.ts';
 
 export interface CliDataFileGeneratorContract {
+    /** Map of class name → module specifier for the provider imports the data cache references. */
+    classImportMap: Record<string, string>;
+
     generateFile(
         directory: string,
         className: string,
@@ -19,5 +22,12 @@ export interface CliDataFileGeneratorContract {
         routes: Record<string, ts.Expression>,
     ): GenerateStatus;
 
+    generateFileFromRoutes(
+        directory: string,
+        className: string,
+        namespace: string,
+        routeExprs: readonly ts.Expression[],
+    ): GenerateStatus;
+
     generateClassContents(routes: Record<string, ts.Expression>): string;
 }

package/src/Sindri/Generator/Container/Contract/ContainerDataFileGeneratorContract.ts

@@ -10,6 +10,9 @@
 import type { GenerateStatus } from '../../Enum/GenerateStatus.ts';
 
 export interface ContainerDataFileGeneratorContract {
+    /** Map of class name → module specifier for the provider imports the data cache references. */
+    classImportMap: Record<string, string>;
+
     generateFile(
         directory: string,
         className: string,

package/src/Sindri/Generator/Http/Contract/HttpDataFileGeneratorContract.ts

@@ -13,6 +13,9 @@ import type { HttpRouteData } from '../../../Ast/Data/HttpRouteData.ts';
 import type { GenerateStatus } from '../../Enum/GenerateStatus.ts';
 
 export interface HttpDataFileGeneratorContract {
+    /** Map of class name → module specifier for the provider imports the data cache references. */
+    classImportMap: Record<string, string>;
+
     generateFile(
         directory: string,
         className: string,
@@ -21,5 +24,12 @@ export interface HttpDataFileGeneratorContract {
         routeData: Record<string, HttpRouteData>,
     ): GenerateStatus;
 
+    generateFileFromRoutes(
+        directory: string,
+        className: string,
+        namespace: string,
+        routeExprs: readonly ts.Expression[],
+    ): GenerateStatus;
+
     generateClassContents(routes: Record<string, ts.Expression>, routeData: Record<string, HttpRouteData>): string;
 }