@valkyrjaio/sindri 26.1.3 → 26.3.0

package/src/Sindri/Generator/Ast/Cli/AstCliDataFileGenerator.ts

@@ -32,11 +32,7 @@ export class AstCliDataFileGenerator extends AstFileGenerator implements CliData
         namespace: string,
         routes: Record<string, ts.Expression>,
     ): 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);
 
         const contents = this.generateClassContents(routes);
 
@@ -64,6 +60,36 @@ export class AstCliDataFileGenerator extends AstFileGenerator implements CliData
         return this.writeFile(directory, className, data);
     }
 
+    /**
+     * Generate the CLI routing data file from imperative `getRoutes()` route
+     * objects — each `new Route(name, description, handler, ...)` is keyed by
+     * its command name (the first constructor argument) and emitted verbatim.
+     */
+    public generateFileFromRoutes(
+        directory: string,
+        className: string,
+        namespace: string,
+        routeExprs: readonly ts.Expression[],
+    ): GenerateStatus {
+        const routes: Record<string, ts.Expression> = {};
+
+        for (const expr of routeExprs) {
+            if (!ts.isNewExpression(expr)) {
+                continue;
+            }
+
+            const nameArg = (expr.arguments ?? [])[0];
+
+            if (nameArg === undefined || !ts.isStringLiteral(nameArg)) {
+                continue;
+            }
+
+            routes[nameArg.text] = expr;
+        }
+
+        return this.generateFile(directory, className, namespace, routes);
+    }
+
     public generateClassContents(routes: Record<string, ts.Expression>): string {
         const entries = Object.entries(routes);
 
@@ -74,15 +100,25 @@ export class AstCliDataFileGenerator extends AstFileGenerator implements CliData
         const lines: string[] = [];
 
         for (const [key, valueExpr] of entries) {
-            const keyExpr = this.buildEnumCaseExpr(key);
-            const printedKey = this.printer.printNode(ts.EmitHint.Unspecified, keyExpr, this.dummySourceFile);
-            const printedValue = this.printer.printNode(ts.EmitHint.Unspecified, valueExpr, this.dummySourceFile);
-
-            const formattedKey = key.includes('::') ? `[${printedKey}]` : `['${printedKey}']`;
+            const printedValue = this.printExpr(valueExpr);
+            const formattedKey = key.includes('::')
+                ? `[${this.printer.printNode(ts.EmitHint.Unspecified, this.buildEnumCaseExpr(key), this.dummySourceFile)}]`
+                : `['${key}']`;
 
             lines.push(`            ${formattedKey}: (): RouteContract => ${printedValue},`);
         }
 
-        return ['super({', '            routes: {', ...lines, '            },', '        });'].join('\n        ');
+        return ['super({', ...lines, '        });'].join('\n        ');
+    }
+
+    /**
+     * Print an expression to source. Parsed nodes (from a `getRoutes()` body)
+     * are emitted via their original source text; synthesized nodes (which
+     * carry no source positions) are emitted through the printer.
+     */
+    protected printExpr(expr: ts.Expression): string {
+        return expr.pos >= 0
+            ? expr.getText()
+            : this.printer.printNode(ts.EmitHint.Unspecified, expr, this.dummySourceFile);
     }
 }

package/src/Sindri/Generator/Ast/Container/AstContainerDataFileGenerator.ts

@@ -32,11 +32,7 @@ export class AstContainerDataFileGenerator extends AstFileGenerator implements C
         namespace: string,
         publishers: Readonly<Record<string, readonly [string, string]>>,
     ): 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);
 
         const contents = this.generateClassContents(publishers);
 
@@ -67,12 +63,11 @@ export class AstContainerDataFileGenerator extends AstFileGenerator implements C
         const lines: string[] = [];
 
         for (const [serviceId, [providerClass, methodName]] of entries) {
-            const keyExpr = this.buildEnumCaseExpr(serviceId);
-            const printedKey = this.printer.printNode(ts.EmitHint.Unspecified, keyExpr, this.dummySourceFile);
-
             const shortProviderClass = providerClass.slice(providerClass.lastIndexOf('\\') + 1);
 
-            const formattedKey = serviceId.includes('::') ? `[${printedKey}]` : `['${printedKey}']`;
+            const formattedKey = serviceId.includes('::')
+                ? `[${this.printer.printNode(ts.EmitHint.Unspecified, this.buildEnumCaseExpr(serviceId), this.dummySourceFile)}]`
+                : `['${serviceId}']`;
 
             lines.push(
                 `            ${formattedKey}: (container: ContainerContract) => ${shortProviderClass}.${methodName}(container),`,

package/src/Sindri/Generator/Ast/Event/AstEventDataFileGenerator.ts

@@ -32,20 +32,26 @@ export class AstEventDataFileGenerator extends AstFileGenerator implements Event
         namespace: string,
         listeners: Record<string, ts.Expression>,
     ): 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);
 
         const contents = this.generateClassContents(listeners);
 
+        // The Listener / ListenerContract imports are only referenced by the
+        // generated listener closures — omit them when there are no listeners
+        // so empty event data does not carry unused (and unresolved) imports.
+        const listenerImports =
+            Object.keys(listeners).length > 0
+                ? [
+                      `import { Listener } from '@valkyrjaio/valkyrja/Event/Data/Listener.ts';`,
+                      `import type { ListenerContract } from '@valkyrjaio/valkyrja/Event/Data/Contract/ListenerContract.ts';`,
+                  ]
+                : [];
+
         const data = [
             '// This file was automatically generated by Sindri.',
             '',
             `import { EventData } from '@valkyrjaio/valkyrja/Event/Data/EventData.ts';`,
-            `import { Listener } from '@valkyrjaio/valkyrja/Event/Data/Listener.ts';`,
-            `import type { ListenerContract } from '@valkyrjaio/valkyrja/Event/Data/Contract/ListenerContract.ts';`,
+            ...listenerImports,
             userImportsBlock,
             `export class ${className} extends EventData {`,
             `    constructor() {`,

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,6 +23,16 @@ 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 {
     public classImportMap: Record<string, string> = {};
 
@@ -49,18 +60,58 @@ 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);
 
         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);
+
+        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';`,
@@ -83,8 +134,6 @@ export class AstHttpDataFileGenerator extends AstFileGenerator implements HttpDa
             `}`,
             '',
         ].join('\n');
-
-        return this.writeFile(directory, className, data);
     }
 
     public generateClassContents(
@@ -292,15 +341,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;
 }