@valkyrjaio/sindri 26.2.0 → 26.4.0

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

@@ -211,6 +211,157 @@ export abstract class GenerateDataFromAst {
         return '';
     }
 
+    /**
+     * Build the `import { X } from '...'` specifier for a class file, relative
+     * to the generated data file's output directory. Used to import the
+     * provider/handler classes referenced by the generated data caches.
+     */
+    protected relativeSpecifier(fromDir: string, toFile: string): string {
+        const relative = path.relative(fromDir, toFile).split(path.sep).join('/');
+
+        return relative.startsWith('.') ? relative : `./${relative}`;
+    }
+
+    /**
+     * Build the specifier a generated data file should import a class file by.
+     *
+     * Application source is imported by a path relative to the data directory;
+     * a file belonging to an installed package is imported by that package's
+     * own public specifier — so the framework classes the cache references are
+     * written exactly as hand-written application code writes them
+     * (`@valkyrjaio/valkyrja/Cli/Routing/Data/Route.ts`), never as a brittle
+     * reach into `node_modules`.
+     */
+    protected importSpecifier(fromDir: string, toFile: string): string {
+        return this.packageSpecifier(toFile) ?? this.relativeSpecifier(fromDir, toFile);
+    }
+
+    /**
+     * Map an absolute path inside an installed package back to the specifier
+     * that package publicly exposes it as, or undefined when the file is not
+     * part of one.
+     *
+     * The package's `exports` map is inverted: for `"./*.ts": "./src/*.ts"` a
+     * file at `<package>/src/Foo.ts` maps back to `<name>/Foo.ts`. Packages
+     * with no matching pattern fall back to the path as written under the
+     * package root, which is what a package without an `exports` map exposes.
+     */
+    protected packageSpecifier(filePath: string): string | undefined {
+        const normalized = filePath.split(path.sep).join('/');
+        const marker = normalized.lastIndexOf('/node_modules/');
+
+        if (marker === -1) {
+            return undefined;
+        }
+
+        const subject = normalized.substring(marker + '/node_modules/'.length);
+        const segments = subject.split('/');
+        const nameLength = subject.startsWith('@') ? 2 : 1;
+
+        if (segments.length <= nameLength) {
+            return undefined;
+        }
+
+        const packageName = segments.slice(0, nameLength).join('/');
+        const packageDir = normalized.substring(0, marker + '/node_modules/'.length) + packageName;
+        const relative = segments.slice(nameLength).join('/');
+
+        return `${packageName}/${this.exportedSubpath(packageDir, relative) ?? relative}`;
+    }
+
+    /**
+     * Invert a package's `exports` patterns to find the subpath a file inside
+     * it is exposed as, or undefined when no pattern matches it.
+     */
+    protected exportedSubpath(packageDir: string, relative: string): string | undefined {
+        for (const [key, target] of Object.entries(this.readPackageExports(packageDir))) {
+            const star = key.indexOf('*');
+            const targetStar = target.indexOf('*');
+
+            if (star === -1 || targetStar === -1) {
+                continue;
+            }
+
+            const prefix = target.substring(0, targetStar).replace(/^\.\//, '');
+            const suffix = target.substring(targetStar + 1);
+
+            if (!relative.startsWith(prefix) || !relative.endsWith(suffix)) {
+                continue;
+            }
+
+            const value = relative.substring(prefix.length, relative.length - suffix.length);
+
+            return (key.substring(0, star) + value + key.substring(star + 1)).replace(/^\.\//, '');
+        }
+
+        return undefined;
+    }
+
+    /**
+     * Read a package's `exports` map, flattened to subpath → file target.
+     *
+     * Conditional targets are collapsed to their first string value; every
+     * condition a package declares for a subpath points at the same source
+     * file in the layouts sindri generates for.
+     */
+    protected readPackageExports(packageDir: string): Record<string, string> {
+        const manifestPath = path.join(packageDir, 'package.json');
+
+        if (!fs.existsSync(manifestPath)) {
+            return {};
+        }
+
+        let manifest: { exports?: unknown };
+
+        try {
+            manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8')) as { exports?: unknown };
+        } catch {
+            return {};
+        }
+
+        const exports = manifest.exports;
+
+        if (typeof exports !== 'object' || exports === null) {
+            return {};
+        }
+
+        const flattened: Record<string, string> = {};
+
+        for (const [subpath, target] of Object.entries(exports as Record<string, unknown>)) {
+            const resolved = this.firstStringTarget(target);
+
+            if (resolved !== undefined) {
+                flattened[subpath] = resolved;
+            }
+        }
+
+        return flattened;
+    }
+
+    /**
+     * Reduce an `exports` target — a string, or a nested map of conditions — to
+     * the first file path it names.
+     */
+    protected firstStringTarget(target: unknown): string | undefined {
+        if (typeof target === 'string') {
+            return target;
+        }
+
+        if (typeof target !== 'object' || target === null) {
+            return undefined;
+        }
+
+        for (const value of Object.values(target as Record<string, unknown>)) {
+            const resolved = this.firstStringTarget(value);
+
+            if (resolved !== undefined) {
+                return resolved;
+            }
+        }
+
+        return undefined;
+    }
+
     protected generateContainerData(
         serviceProviders: readonly string[],
         config: ConfigResult,
@@ -221,6 +372,7 @@ export abstract class GenerateDataFromAst {
             .writeMessages();
 
         const publishers: Record<string, readonly [string, string]> = {};
+        const importMap: Record<string, string> = {};
 
         for (const providerClass of serviceProviders) {
             const filePath = this.fqnToFilePath(providerClass, config.namespace, config.dir);
@@ -231,9 +383,17 @@ export abstract class GenerateDataFromAst {
 
             const result = this.serviceProviderReader.readFile(filePath);
 
+            if (Object.keys(result.publishers).length > 0) {
+                // The publisher callbacks reference the provider's static methods,
+                // so the generated data cache must import the provider class.
+                importMap[path.basename(filePath, '.ts')] = this.importSpecifier(config.dataPath, filePath);
+            }
+
             Object.assign(publishers, result.publishers);
         }
 
+        this.containerGenerator.classImportMap = importMap;
+
         const status = this.containerGenerator.generateFile(
             config.dataPath,
             'AppContainerData',
@@ -297,6 +457,8 @@ export abstract class GenerateDataFromAst {
             .writeMessages();
 
         const allRoutes: Record<string, ts.Expression> = {};
+        const imperativeRoutes: ts.Expression[] = [];
+        const importMap: Record<string, string> = {};
 
         for (const providerClass of cliRouteProviders) {
             const filePath = this.fqnToFilePath(providerClass, config.namespace, config.dir);
@@ -307,6 +469,19 @@ export abstract class GenerateDataFromAst {
 
             const providerResult = this.routeProviderReader.readFile(filePath);
 
+            if (providerResult.routes.length > 0) {
+                // Imperative routes reference the provider's static handlers,
+                // so the generated data cache must import the provider class —
+                // along with every parameter/constant class the route arguments
+                // themselves name, since those are emitted verbatim.
+                imperativeRoutes.push(...providerResult.routes);
+                importMap[path.basename(filePath, '.ts')] = this.importSpecifier(config.dataPath, filePath);
+
+                for (const [name, importPath] of Object.entries(providerResult.routeImports)) {
+                    importMap[name] = this.importSpecifier(config.dataPath, importPath);
+                }
+            }
+
             for (const controllerClass of providerResult.controllerClasses) {
                 const controllerPath = this.fqnToFilePath(controllerClass, config.namespace, config.dir);
 
@@ -320,12 +495,17 @@ export abstract class GenerateDataFromAst {
             }
         }
 
-        const status = this.cliGenerator.generateFile(
-            config.dataPath,
-            'AppCliRoutingData',
-            config.dataNamespace,
-            allRoutes,
-        );
+        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);
 
         return this.addMessagesForGenerateStatus(output, status).withAddedMessages(new NewLine()).writeMessages();
     }
@@ -341,6 +521,8 @@ export abstract class GenerateDataFromAst {
 
         const allRoutes: Record<string, ts.Expression> = {};
         const allRouteData: Record<string, HttpRouteData> = {};
+        const imperativeRoutes: ts.Expression[] = [];
+        const importMap: Record<string, string> = {};
 
         for (const providerClass of httpRouteProviders) {
             const filePath = this.fqnToFilePath(providerClass, config.namespace, config.dir);
@@ -351,6 +533,19 @@ export abstract class GenerateDataFromAst {
 
             const providerResult = this.routeProviderReader.readFile(filePath);
 
+            if (providerResult.routes.length > 0) {
+                // Imperative routes reference the provider's static handlers,
+                // so the generated data cache must import the provider class —
+                // along with every parameter/constant class the route arguments
+                // themselves name, since those are emitted verbatim.
+                imperativeRoutes.push(...providerResult.routes);
+                importMap[path.basename(filePath, '.ts')] = this.importSpecifier(config.dataPath, filePath);
+
+                for (const [name, importPath] of Object.entries(providerResult.routeImports)) {
+                    importMap[name] = this.importSpecifier(config.dataPath, importPath);
+                }
+            }
+
             for (const controllerClass of providerResult.controllerClasses) {
                 const controllerPath = this.fqnToFilePath(controllerClass, config.namespace, config.dir);
 
@@ -365,13 +560,23 @@ export abstract class GenerateDataFromAst {
             }
         }
 
-        const status = this.httpGenerator.generateFile(
-            config.dataPath,
-            'AppHttpRoutingData',
-            config.dataNamespace,
-            allRoutes,
-            allRouteData,
-        );
+        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,
+                  );
 
         return this.addMessagesForGenerateStatus(output, status).withAddedMessages(new NewLine()).writeMessages();
     }

package/src/Sindri/Generator/Abstract/AstFileGenerator.ts

@@ -31,6 +31,33 @@ export abstract class AstFileGenerator {
         return ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(className), caseName);
     }
 
+    /**
+     * Build the `import { X } from '...';` block for the provider/handler classes
+     * a generated data cache references, followed by a trailing newline (or an
+     * empty string when there are no such imports).
+     *
+     * Names the generated file's fixed framework header already binds are
+     * dropped: those are the same framework classes under the same names, and
+     * emitting them twice is a duplicate-identifier error.
+     */
+    protected buildUserImportsBlock(classImportMap: Record<string, string>, reservedNames: readonly string[]): string {
+        const userImports = Object.entries(classImportMap)
+            .filter(([name]) => !reservedNames.includes(name))
+            .map(([name, specifier]) => `import { ${name} } from '${specifier}';`)
+            .join('\n');
+
+        return userImports ? `${userImports}\n` : '';
+    }
+
+    /**
+     * Render the fixed framework imports a generated data file always carries.
+     */
+    protected buildFrameworkImportLines(imports: Readonly<Record<string, string>>, isType: boolean = false): string[] {
+        const keyword = isType ? 'import type' : 'import';
+
+        return Object.entries(imports).map(([name, specifier]) => `${keyword} { ${name} } from '${specifier}';`);
+    }
+
     protected writeFile(directory: string, className: string, data: string): GenerateStatus {
         const filePath = directory.replace(/\/$/, '') + `/${className}.ts`;
 

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

@@ -14,6 +14,23 @@ import type { CliDataFileGeneratorContract } from '../../Cli/Contract/CliDataFil
 import type { GenerateStatus } from '../../Enum/GenerateStatus.ts';
 
 export class AstCliDataFileGenerator extends AstFileGenerator implements CliDataFileGeneratorContract {
+    /** The framework classes every generated CLI data file imports as values. */
+    protected static readonly FRAMEWORK_IMPORTS: Readonly<Record<string, string>> = {
+        CliRoutingData: '@valkyrjaio/valkyrja/Cli/Routing/Data/CliRoutingData.ts',
+        Route: '@valkyrjaio/valkyrja/Cli/Routing/Data/Route.ts',
+        ArgumentParameter: '@valkyrjaio/valkyrja/Cli/Routing/Data/ArgumentParameter.ts',
+        OptionParameter: '@valkyrjaio/valkyrja/Cli/Routing/Data/OptionParameter.ts',
+        ArgumentMode: '@valkyrjaio/valkyrja/Cli/Routing/Enum/ArgumentMode.ts',
+        ArgumentValueMode: '@valkyrjaio/valkyrja/Cli/Routing/Enum/ArgumentValueMode.ts',
+        OptionMode: '@valkyrjaio/valkyrja/Cli/Routing/Enum/OptionMode.ts',
+        OptionValueMode: '@valkyrjaio/valkyrja/Cli/Routing/Enum/OptionValueMode.ts',
+    };
+
+    /** The framework types every generated CLI data file imports. */
+    protected static readonly FRAMEWORK_TYPE_IMPORTS: Readonly<Record<string, string>> = {
+        RouteContract: '@valkyrjaio/valkyrja/Cli/Routing/Data/Contract/RouteContract.ts',
+    };
+
     public classImportMap: Record<string, string> = {};
 
     private readonly printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
@@ -32,26 +49,18 @@ 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, [
+            ...Object.keys(AstCliDataFileGenerator.FRAMEWORK_IMPORTS),
+            ...Object.keys(AstCliDataFileGenerator.FRAMEWORK_TYPE_IMPORTS),
+        ]);
 
         const contents = this.generateClassContents(routes);
 
         const data = [
             '// This file was automatically generated by Sindri.',
             '',
-            `import { CliRoutingData } from '@valkyrjaio/valkyrja/Cli/Routing/Data/CliRoutingData.ts';`,
-            `import { Route } from '@valkyrjaio/valkyrja/Cli/Routing/Data/Route.ts';`,
-            `import { ArgumentParameter } from '@valkyrjaio/valkyrja/Cli/Routing/Data/ArgumentParameter.ts';`,
-            `import { OptionParameter } from '@valkyrjaio/valkyrja/Cli/Routing/Data/OptionParameter.ts';`,
-            `import { ArgumentMode } from '@valkyrjaio/valkyrja/Cli/Routing/Enum/ArgumentMode.ts';`,
-            `import { ArgumentValueMode } from '@valkyrjaio/valkyrja/Cli/Routing/Enum/ArgumentValueMode.ts';`,
-            `import { OptionMode } from '@valkyrjaio/valkyrja/Cli/Routing/Enum/OptionMode.ts';`,
-            `import { OptionValueMode } from '@valkyrjaio/valkyrja/Cli/Routing/Enum/OptionValueMode.ts';`,
-            `import type { RouteContract } from '@valkyrjaio/valkyrja/Cli/Routing/Data/Contract/RouteContract.ts';`,
+            ...this.buildFrameworkImportLines(AstCliDataFileGenerator.FRAMEWORK_IMPORTS),
+            ...this.buildFrameworkImportLines(AstCliDataFileGenerator.FRAMEWORK_TYPE_IMPORTS, true),
             userImportsBlock,
             `export class ${className} extends CliRoutingData {`,
             `    constructor() {`,
@@ -64,6 +73,61 @@ 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 key = this.routeKey((expr.arguments ?? [])[0]);
+
+            if (key === undefined) {
+                continue;
+            }
+
+            routes[key] = expr;
+        }
+
+        return this.generateFile(directory, className, namespace, routes);
+    }
+
+    /**
+     * Derive the map key for a route from its name argument.
+     *
+     * A literal name keys the map by its own text. A constant reference
+     * (`CliCommandName.LIST` — how the framework's own commands name
+     * themselves) is kept as a `Class::CASE` marker, so the generated file
+     * emits the constant reference as a computed key rather than baking in the
+     * value it happens to hold today.
+     */
+    protected routeKey(nameArg: ts.Expression | undefined): string | undefined {
+        if (nameArg === undefined) {
+            return undefined;
+        }
+
+        if (ts.isStringLiteral(nameArg)) {
+            return nameArg.text;
+        }
+
+        if (ts.isPropertyAccessExpression(nameArg) && ts.isIdentifier(nameArg.expression)) {
+            return `${nameArg.expression.text}::${nameArg.name.text}`;
+        }
+
+        return undefined;
+    }
+
     public generateClassContents(routes: Record<string, ts.Expression>): string {
         const entries = Object.entries(routes);
 
@@ -74,15 +138,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

@@ -14,6 +14,16 @@ import type { ContainerDataFileGeneratorContract } from '../../Container/Contrac
 import type { GenerateStatus } from '../../Enum/GenerateStatus.ts';
 
 export class AstContainerDataFileGenerator extends AstFileGenerator implements ContainerDataFileGeneratorContract {
+    /** The framework class every generated container data file imports as a value. */
+    protected static readonly FRAMEWORK_IMPORTS: Readonly<Record<string, string>> = {
+        ContainerData: '@valkyrjaio/valkyrja/Container/Data/ContainerData.ts',
+    };
+
+    /** The framework type every generated container data file imports. */
+    protected static readonly FRAMEWORK_TYPE_IMPORTS: Readonly<Record<string, string>> = {
+        ContainerContract: '@valkyrjaio/valkyrja/Container/Manager/Contract/ContainerContract.ts',
+    };
+
     public classImportMap: Record<string, string> = {};
 
     private readonly printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
@@ -32,19 +42,18 @@ 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, [
+            ...Object.keys(AstContainerDataFileGenerator.FRAMEWORK_IMPORTS),
+            ...Object.keys(AstContainerDataFileGenerator.FRAMEWORK_TYPE_IMPORTS),
+        ]);
 
         const contents = this.generateClassContents(publishers);
 
         const data = [
             '// This file was automatically generated by Sindri.',
             '',
-            `import { ContainerData } from '@valkyrjaio/valkyrja/Container/Data/ContainerData.ts';`,
-            `import type { ContainerContract } from '@valkyrjaio/valkyrja/Container/Manager/Contract/ContainerContract.ts';`,
+            ...this.buildFrameworkImportLines(AstContainerDataFileGenerator.FRAMEWORK_IMPORTS),
+            ...this.buildFrameworkImportLines(AstContainerDataFileGenerator.FRAMEWORK_TYPE_IMPORTS, true),
             userImportsBlock,
             `export class ${className} extends ContainerData {`,
             `    constructor() {`,
@@ -67,12 +76,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

@@ -14,6 +14,21 @@ import type { EventDataFileGeneratorContract } from '../../Event/Contract/EventD
 import type { GenerateStatus } from '../../Enum/GenerateStatus.ts';
 
 export class AstEventDataFileGenerator extends AstFileGenerator implements EventDataFileGeneratorContract {
+    /** The framework class every generated event data file imports as a value. */
+    protected static readonly FRAMEWORK_IMPORTS: Readonly<Record<string, string>> = {
+        EventData: '@valkyrjaio/valkyrja/Event/Data/EventData.ts',
+    };
+
+    /** The framework classes a generated event data file imports only when it holds listeners. */
+    protected static readonly LISTENER_IMPORTS: Readonly<Record<string, string>> = {
+        Listener: '@valkyrjaio/valkyrja/Event/Data/Listener.ts',
+    };
+
+    /** The framework types a generated event data file imports only when it holds listeners. */
+    protected static readonly LISTENER_TYPE_IMPORTS: Readonly<Record<string, string>> = {
+        ListenerContract: '@valkyrjaio/valkyrja/Event/Data/Contract/ListenerContract.ts',
+    };
+
     public classImportMap: Record<string, string> = {};
 
     private readonly printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
@@ -32,20 +47,30 @@ 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, [
+            ...Object.keys(AstEventDataFileGenerator.FRAMEWORK_IMPORTS),
+            ...Object.keys(AstEventDataFileGenerator.LISTENER_IMPORTS),
+            ...Object.keys(AstEventDataFileGenerator.LISTENER_TYPE_IMPORTS),
+        ]);
 
         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
+                ? [
+                      ...this.buildFrameworkImportLines(AstEventDataFileGenerator.LISTENER_IMPORTS),
+                      ...this.buildFrameworkImportLines(AstEventDataFileGenerator.LISTENER_TYPE_IMPORTS, true),
+                  ]
+                : [];
+
         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';`,
+            ...this.buildFrameworkImportLines(AstEventDataFileGenerator.FRAMEWORK_IMPORTS),
+            ...listenerImports,
             userImportsBlock,
             `export class ${className} extends EventData {`,
             `    constructor() {`,