@valkyrjaio/sindri 26.5.1 → 26.6.0

package/src/Sindri/Generate/Abstract/GenerateDataFromAst.ts

@@ -344,20 +344,20 @@ export abstract class GenerateDataFromAst extends GenerateFromAst {
                 const attrResult = this.cliRouteAttributeReader.readFile(controllerPath);
 
                 Object.assign(allRoutes, attrResult.routes);
+                this.mergeReaderImports(importMap, attrResult.importMap, config);
             }
         }
 
         this.cliGenerator.classImportMap = importMap;
 
-        const status =
-            imperativeRoutes.length > 0
-                ? this.cliGenerator.generateFileFromRoutes(
-                      config.dataPath,
-                      'AppCliRoutingData',
-                      config.dataNamespace,
-                      imperativeRoutes,
-                  )
-                : this.cliGenerator.generateFile(config.dataPath, 'AppCliRoutingData', config.dataNamespace, allRoutes);
+        // Merge attribute-scanned command routes with imperative getRoutes() routes.
+        const status = this.cliGenerator.generateMergedFile(
+            config.dataPath,
+            'AppCliRoutingData',
+            config.dataNamespace,
+            allRoutes,
+            imperativeRoutes,
+        );
 
         return this.addMessagesForGenerateStatus(output, status).withAddedMessages(new NewLine()).writeMessages();
     }
@@ -409,30 +409,43 @@ export abstract class GenerateDataFromAst extends GenerateFromAst {
 
                 Object.assign(allRoutes, attrResult.routes);
                 Object.assign(allRouteData, attrResult.routeData);
+                this.mergeReaderImports(importMap, attrResult.importMap, config);
             }
         }
 
         this.httpGenerator.classImportMap = importMap;
 
-        const status =
-            imperativeRoutes.length > 0
-                ? this.httpGenerator.generateFileFromRoutes(
-                      config.dataPath,
-                      'AppHttpRoutingData',
-                      config.dataNamespace,
-                      imperativeRoutes,
-                  )
-                : this.httpGenerator.generateFile(
-                      config.dataPath,
-                      'AppHttpRoutingData',
-                      config.dataNamespace,
-                      allRoutes,
-                      allRouteData,
-                  );
+        // Merge attribute-scanned routes with imperative getRoutes() routes.
+        const status = this.httpGenerator.generateMergedFile(
+            config.dataPath,
+            'AppHttpRoutingData',
+            config.dataNamespace,
+            allRoutes,
+            allRouteData,
+            imperativeRoutes,
+        );
 
         return this.addMessagesForGenerateStatus(output, status).withAddedMessages(new NewLine()).writeMessages();
     }
 
+    /**
+     * Merge the class-name → absolute-file-path imports a route attribute reader
+     * resolved (handler/help-text/middleware classes) into the generated data
+     * file's import map, converting each absolute path to the specifier the
+     * generated file imports it by — relative to the output directory for
+     * application source, or the owning package's own specifier for a class an
+     * installed package exposes.
+     */
+    protected mergeReaderImports(
+        importMap: Record<string, string>,
+        readerImportMap: Record<string, string>,
+        config: ConfigResult,
+    ): void {
+        for (const [name, absolutePath] of Object.entries(readerImportMap)) {
+            importMap[name] = this.importSpecifier(config.dataPath, absolutePath);
+        }
+    }
+
     protected addMessagesForGenerateStatus(output: OutputContract, status: GenerateStatus): OutputContract {
         let text = 'Failed';
         let formatter = new ErrorFormatter();

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

@@ -84,7 +84,23 @@ export class AstCliDataFileGenerator extends AstFileGenerator implements CliData
         namespace: string,
         routeExprs: readonly ts.Expression[],
     ): GenerateStatus {
-        const routes: Record<string, ts.Expression> = {};
+        return this.generateMergedFile(directory, className, namespace, {}, routeExprs);
+    }
+
+    /**
+     * Generate the CLI routing data file by MERGING attribute-scanned command
+     * routes with imperative `getRoutes()` route objects — both are keyed by
+     * command name into a single routes map. Attribute entries come first;
+     * imperative entries override on a name collision.
+     */
+    public generateMergedFile(
+        directory: string,
+        className: string,
+        namespace: string,
+        routes: Record<string, ts.Expression>,
+        routeExprs: readonly ts.Expression[],
+    ): GenerateStatus {
+        const merged: Record<string, ts.Expression> = { ...routes };
 
         for (const expr of routeExprs) {
             if (!ts.isNewExpression(expr)) {
@@ -97,10 +113,10 @@ export class AstCliDataFileGenerator extends AstFileGenerator implements CliData
                 continue;
             }
 
-            routes[key] = expr;
+            merged[key] = expr;
         }
 
-        return this.generateFile(directory, className, namespace, routes);
+        return this.generateFile(directory, className, namespace, merged);
     }
 
     /**

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

@@ -75,19 +75,7 @@ export class AstHttpDataFileGenerator extends AstFileGenerator implements HttpDa
         routes: Record<string, ts.Expression>,
         routeData: Record<string, HttpRouteData>,
     ): GenerateStatus {
-        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 = this.assembleFile(className, userImportsBlock, routesContent, paths, dynamicPaths, regexes);
-
-        return this.writeFile(directory, className, data);
+        return this.generateMergedFile(directory, className, namespace, routes, routeData, []);
     }
 
     /**
@@ -100,9 +88,26 @@ export class AstHttpDataFileGenerator extends AstFileGenerator implements HttpDa
      * (literal path and regex, request methods defaulting to `[HEAD, GET]`).
      */
     public generateFileFromRoutes(
+        directory: string,
+        className: string,
+        namespace: string,
+        routeExprs: readonly ts.Expression[],
+    ): GenerateStatus {
+        return this.generateMergedFile(directory, className, namespace, {}, {}, routeExprs);
+    }
+
+    /**
+     * Generate the routing data file by MERGING attribute-scanned routes with
+     * imperative `getRoutes()` route objects — the four lookup maps (routes,
+     * paths, dynamicPaths, regexes) are built from both sources and combined.
+     * Attribute entries are emitted first, then imperative ones.
+     */
+    public generateMergedFile(
         directory: string,
         className: string,
         _namespace: string,
+        routes: Record<string, ts.Expression>,
+        routeData: Record<string, HttpRouteData>,
         routeExprs: readonly ts.Expression[],
     ): GenerateStatus {
         const userImportsBlock = this.buildUserImportsBlock(this.classImportMap, [
@@ -114,16 +119,39 @@ export class AstHttpDataFileGenerator extends AstFileGenerator implements HttpDa
             .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 routesContent = this.wrapRoutes([
+            ...this.getRouteLines(routes, routeData),
+            ...this.getImperativeRouteLines(metas),
+        ]);
+        const paths = this.printNestedObject(
+            this.mergeNested(this.buildPaths(routeData), this.buildImperativePaths(metas, false)),
+        );
+        const dynamicPaths = this.printNestedObject(
+            this.mergeNested(this.buildDynamicPaths(routeData), this.buildImperativePaths(metas, true)),
+        );
+        const regexes = this.printNestedObject(
+            this.mergeNested(this.buildRegexes(routeData), this.buildImperativeRegexes(metas)),
+        );
 
         const data = this.assembleFile(className, userImportsBlock, routesContent, paths, dynamicPaths, regexes);
 
         return this.writeFile(directory, className, data);
     }
 
+    /** Deep-merge two `method → key → name` maps; entries in `b` override `a`. */
+    protected mergeNested(
+        a: Record<string, Record<string, string>>,
+        b: Record<string, Record<string, string>>,
+    ): Record<string, Record<string, string>> {
+        const merged: Record<string, Record<string, string>> = {};
+
+        for (const [outerKey, innerMap] of [...Object.entries(a), ...Object.entries(b)]) {
+            merged[outerKey] = { ...(merged[outerKey] ?? {}), ...innerMap };
+        }
+
+        return merged;
+    }
+
     protected assembleFile(
         className: string,
         userImportsBlock: string,
@@ -339,23 +367,25 @@ export class AstHttpDataFileGenerator extends AstFileGenerator implements HttpDa
         routes: Record<string, ts.Expression>,
         routeData: Record<string, HttpRouteData>,
     ): string {
-        const entries = Object.entries(routes);
+        return this.wrapRoutes(this.getRouteLines(routes, routeData));
+    }
 
-        if (entries.length === 0) {
+    /** Wrap route closure lines in the `{ ... }` object-literal body (or `{}`). */
+    protected wrapRoutes(lines: readonly string[]): string {
+        if (lines.length === 0) {
             return '{}';
         }
 
+        return ['{', ...lines, '        }'].join('\n        ');
+    }
+
+    /** Build the per-route closure lines for attribute-scanned routes. */
+    protected getRouteLines(routes: Record<string, ts.Expression>, routeData: Record<string, HttpRouteData>): string[] {
         const lines: string[] = [];
 
-        for (const [key, routeExpr] of entries) {
+        for (const [key, routeExpr] of Object.entries(routes)) {
             const data = routeData[key] ?? null;
-            let expr = routeExpr;
-
-            if (data !== null && data.isDynamic && ts.isNewExpression(expr)) {
-                const computedRegex = data.parameters.length > 0 ? this.computeRegex(data) : '';
-                const args = [...(expr.arguments ?? []), ts.factory.createStringLiteral(computedRegex)];
-                expr = ts.factory.createNewExpression(expr.expression, expr.typeArguments, args);
-            }
+            const expr = data !== null ? this.injectRegex(routeExpr, data) : routeExpr;
 
             const printedRoute = this.printer.printNode(ts.EmitHint.Unspecified, expr, this.dummySourceFile);
             const formattedKey = key.includes('::')
@@ -365,7 +395,25 @@ export class AstHttpDataFileGenerator extends AstFileGenerator implements HttpDa
             lines.push(`            ${formattedKey}: (): RouteContract => ${printedRoute},`);
         }
 
-        return ['{', ...lines, '        }'].join('\n        ');
+        return lines;
+    }
+
+    /**
+     * Replace the regex argument (slot 2) of a dynamic `new DynamicRoute(...)`
+     * expression with the regex computed from the route's parameters. The reader
+     * emits an empty-string placeholder there; the generator owns the routing
+     * `Processor` and computes the real value here.
+     */
+    protected injectRegex(expr: ts.Expression, data: HttpRouteData): ts.Expression {
+        if (!(data.isDynamic && ts.isNewExpression(expr))) {
+            return expr;
+        }
+
+        const computedRegex = data.parameters.length > 0 ? this.computeRegex(data) : '';
+        const original = expr.arguments ?? ts.factory.createNodeArray<ts.Expression>();
+        const args = original.map((arg, index) => (index === 2 ? ts.factory.createStringLiteral(computedRegex) : arg));
+
+        return ts.factory.createNewExpression(expr.expression, expr.typeArguments, args);
     }
 
     // -------------------------------------------------------------------------
@@ -433,20 +481,11 @@ export class AstHttpDataFileGenerator extends AstFileGenerator implements HttpDa
         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        ');
+    /** Build the per-route closure lines for imperative `getRoutes()` routes. */
+    protected getImperativeRouteLines(metas: readonly ImperativeRouteMeta[]): string[] {
+        // Imperative route expressions come parsed from a provider's `getRoutes()`
+        // body, so they are emitted verbatim via their original source text.
+        return metas.map((meta) => `            ['${meta.name}']: (): RouteContract => ${meta.expr.getText()},`);
     }
 
     protected buildImperativePaths(

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

@@ -29,5 +29,13 @@ export interface CliDataFileGeneratorContract {
         routeExprs: readonly ts.Expression[],
     ): GenerateStatus;
 
+    generateMergedFile(
+        directory: string,
+        className: string,
+        namespace: string,
+        routes: Record<string, ts.Expression>,
+        routeExprs: readonly ts.Expression[],
+    ): GenerateStatus;
+
     generateClassContents(routes: Record<string, ts.Expression>): string;
 }

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

@@ -31,5 +31,14 @@ export interface HttpDataFileGeneratorContract {
         routeExprs: readonly ts.Expression[],
     ): GenerateStatus;
 
+    generateMergedFile(
+        directory: string,
+        className: string,
+        namespace: string,
+        routes: Record<string, ts.Expression>,
+        routeData: Record<string, HttpRouteData>,
+        routeExprs: readonly ts.Expression[],
+    ): GenerateStatus;
+
     generateClassContents(routes: Record<string, ts.Expression>, routeData: Record<string, HttpRouteData>): string;
 }