proteum 2.0.0 → 2.1.0

package/cli/compiler/artifacts/services.ts

@@ -0,0 +1,480 @@
+import path from 'path';
+import fs from 'fs-extra';
+import ts from 'typescript';
+
+import app from '../../app';
+import cli from '../..';
+import { TProteumManifestScope, TProteumManifestService } from '../common/proteumManifest';
+import writeIfChanged from '../writeIfChanged';
+import { findServiceDirectories } from './discovery';
+import { normalizeAbsolutePath } from './shared';
+
+type TServiceMetas = {
+    id: string;
+    name: string;
+    parent: string;
+    dependences: string[];
+    importationPath: string;
+    priority: number;
+    sourceDir: string;
+    metasFilepath: string;
+    scope: TProteumManifestScope;
+};
+
+type TParsedService = {
+    registeredName: string;
+    priority: number;
+    meta: TServiceMetas;
+};
+
+type TParsedAppBootstrap = {
+    rootServices: TParsedService[];
+    routerPlugins: TParsedService[];
+};
+
+type TServicesAvailable = Record<string, TServiceMetas>;
+
+const buildServicesAvailable = (): TServicesAvailable => {
+    const searchDirs = [
+        { path: '@server/services/', priority: -1, root: path.join(cli.paths.core.root, 'server', 'services') },
+        { path: '@/server/services/', priority: 0, root: path.join(app.paths.root, 'server', 'services') },
+    ];
+
+    const servicesAvailable: TServicesAvailable = {};
+
+    for (const searchDir of searchDirs) {
+        const services = findServiceDirectories(searchDir.root);
+
+        for (const serviceDir of services) {
+            const metasFile = path.join(serviceDir, 'service.json');
+            const importationPath = searchDir.path + serviceDir.substring(searchDir.root.length + 1);
+            const serviceMetas = fs.readJsonSync(metasFile) as {
+                id: string;
+                name: string;
+                parent: string;
+                dependences: string[];
+                priority?: number;
+            };
+
+            servicesAvailable[serviceMetas.id] = {
+                importationPath,
+                priority: searchDir.priority,
+                sourceDir: normalizeAbsolutePath(serviceDir),
+                metasFilepath: normalizeAbsolutePath(metasFile),
+                scope: searchDir.path.startsWith('@server/services/') ? 'framework' : 'app',
+                ...serviceMetas,
+            };
+        }
+    }
+
+    return servicesAvailable;
+};
+
+const getAppServerEntryFilepath = () => {
+    const filepath = app.paths.server.entry;
+
+    if (!fs.existsSync(filepath)) {
+        throw new Error(`Expected an explicit server application entrypoint at ${filepath}.`);
+    }
+
+    return filepath;
+};
+
+const createSourceFile = (filepath: string) =>
+    ts.createSourceFile(
+        filepath,
+        fs.readFileSync(filepath, 'utf8'),
+        ts.ScriptTarget.Latest,
+        true,
+        filepath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+    );
+
+const hasModifier = (node: ts.Node, kind: ts.SyntaxKind) => {
+    const modifiers = (node as ts.Node & { modifiers?: ts.NodeArray<ts.Modifier> }).modifiers;
+
+    return modifiers?.some((modifier) => modifier.kind === kind) ?? false;
+};
+
+const getDefaultExportClassDeclaration = (sourceFile: ts.SourceFile) => {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isClassDeclaration(statement)) continue;
+        if (!hasModifier(statement, ts.SyntaxKind.ExportKeyword)) continue;
+        if (!hasModifier(statement, ts.SyntaxKind.DefaultKeyword)) continue;
+
+        return statement;
+    }
+
+    let defaultExportIdentifier: string | undefined;
+
+    for (const statement of sourceFile.statements) {
+        if (!ts.isExportAssignment(statement)) continue;
+        if (!ts.isIdentifier(statement.expression)) continue;
+
+        defaultExportIdentifier = statement.expression.text;
+        break;
+    }
+
+    if (!defaultExportIdentifier) {
+        throw new Error(`Expected ${sourceFile.fileName} to default-export an Application subclass.`);
+    }
+
+    const declaration = sourceFile.statements.find(
+        (statement): statement is ts.ClassDeclaration =>
+            ts.isClassDeclaration(statement) && statement.name?.text === defaultExportIdentifier,
+    );
+
+    if (!declaration) {
+        throw new Error(
+            `Unable to resolve the default-exported Application class "${defaultExportIdentifier}" in ${sourceFile.fileName}.`,
+        );
+    }
+
+    return declaration;
+};
+
+const buildImportIndex = (sourceFile: ts.SourceFile) => {
+    const imports = new Map<string, string>();
+
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement)) continue;
+        if (!statement.importClause) continue;
+        if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+
+        const importPath = statement.moduleSpecifier.text;
+        const { importClause } = statement;
+
+        if (importClause.name) {
+            imports.set(importClause.name.text, importPath);
+        }
+
+        const namedBindings = importClause.namedBindings;
+        if (!namedBindings || !ts.isNamedImports(namedBindings)) continue;
+
+        for (const element of namedBindings.elements) {
+            imports.set(element.name.text, importPath);
+        }
+    }
+
+    return imports;
+};
+
+const unwrapExpression = (expression: ts.Expression): ts.Expression => {
+    if (ts.isParenthesizedExpression(expression)) return unwrapExpression(expression.expression);
+    if (ts.isAsExpression(expression)) return unwrapExpression(expression.expression);
+    if (ts.isSatisfiesExpression(expression)) return unwrapExpression(expression.expression);
+    if (ts.isNonNullExpression(expression)) return unwrapExpression(expression.expression);
+
+    return expression;
+};
+
+const getPropertyNameText = (propertyName: ts.PropertyName | undefined): string | undefined => {
+    if (!propertyName) return undefined;
+    if (ts.isIdentifier(propertyName) || ts.isStringLiteral(propertyName) || ts.isNumericLiteral(propertyName))
+        return propertyName.text;
+
+    return undefined;
+};
+
+const extractPriorityFromConfig = (configExpression?: ts.Expression) => {
+    if (!configExpression) return 0;
+
+    const expression = unwrapExpression(configExpression);
+    if (!ts.isObjectLiteralExpression(expression)) return 0;
+
+    const priorityProperty = expression.properties.find((property) => {
+        if (!ts.isPropertyAssignment(property)) return false;
+
+        return getPropertyNameText(property.name) === 'priority';
+    });
+
+    if (!priorityProperty || !ts.isPropertyAssignment(priorityProperty)) return 0;
+
+    const priorityExpression = unwrapExpression(priorityProperty.initializer);
+    if (ts.isNumericLiteral(priorityExpression)) return Number(priorityExpression.text);
+
+    if (ts.isPrefixUnaryExpression(priorityExpression) && priorityExpression.operator === ts.SyntaxKind.MinusToken) {
+        const operand = unwrapExpression(priorityExpression.operand);
+        if (ts.isNumericLiteral(operand)) return -Number(operand.text);
+    }
+
+    return 0;
+};
+
+const resolveImportedService = (
+    expression: ts.LeftHandSideExpression,
+    imports: Map<string, string>,
+    servicesAvailable: TServicesAvailable,
+) => {
+    if (!ts.isIdentifier(expression)) return undefined;
+
+    const importPath = imports.get(expression.text);
+    if (!importPath) return undefined;
+
+    return Object.values(servicesAvailable).find((serviceMeta) => serviceMeta.importationPath === importPath);
+};
+
+const parseServiceInstantiation = (
+    registeredName: string,
+    expression: ts.Expression,
+    imports: Map<string, string>,
+    servicesAvailable: TServicesAvailable,
+    configArgIndex: number,
+): TParsedService | undefined => {
+    const unwrappedExpression = unwrapExpression(expression);
+    if (!ts.isNewExpression(unwrappedExpression)) return undefined;
+
+    const meta = resolveImportedService(unwrappedExpression.expression, imports, servicesAvailable);
+    if (!meta) return undefined;
+
+    const configExpression = unwrappedExpression.arguments?.[configArgIndex];
+
+    return {
+        registeredName,
+        priority: extractPriorityFromConfig(configExpression),
+        meta,
+    };
+};
+
+const getObjectLiteralProperty = (expression: ts.ObjectLiteralExpression, propertyName: string) =>
+    expression.properties.find((property) => {
+        if (!ts.isPropertyAssignment(property)) return false;
+
+        return getPropertyNameText(property.name) === propertyName;
+    });
+
+const extractRouterPlugins = (
+    routerConfigExpression: ts.Expression | undefined,
+    imports: Map<string, string>,
+    servicesAvailable: TServicesAvailable,
+) => {
+    if (!routerConfigExpression) return [];
+
+    const configExpression = unwrapExpression(routerConfigExpression);
+    if (!ts.isObjectLiteralExpression(configExpression)) return [];
+
+    const pluginsProperty = getObjectLiteralProperty(configExpression, 'plugins');
+    if (!pluginsProperty || !ts.isPropertyAssignment(pluginsProperty)) return [];
+
+    const pluginsExpression = unwrapExpression(pluginsProperty.initializer);
+    if (!ts.isObjectLiteralExpression(pluginsExpression)) return [];
+
+    const routerPlugins: TParsedService[] = [];
+
+    for (const property of pluginsExpression.properties) {
+        if (!ts.isPropertyAssignment(property)) continue;
+
+        const registeredName = getPropertyNameText(property.name);
+        if (!registeredName) continue;
+
+        const routerPlugin = parseServiceInstantiation(registeredName, property.initializer, imports, servicesAvailable, 0);
+        if (!routerPlugin) continue;
+
+        routerPlugins.push(routerPlugin);
+    }
+
+    return routerPlugins;
+};
+
+const parseAppBootstrap = (servicesAvailable: TServicesAvailable): TParsedAppBootstrap => {
+    const sourceFile = createSourceFile(getAppServerEntryFilepath());
+    const imports = buildImportIndex(sourceFile);
+    const appClass = getDefaultExportClassDeclaration(sourceFile);
+
+    const rootServices: TParsedService[] = [];
+    let routerPlugins: TParsedService[] = [];
+
+    for (const member of appClass.members) {
+        if (!ts.isPropertyDeclaration(member) || !member.initializer) continue;
+
+        const registeredName = getPropertyNameText(member.name);
+        if (!registeredName) continue;
+
+        const rootService = parseServiceInstantiation(registeredName, member.initializer, imports, servicesAvailable, 1);
+        if (!rootService) continue;
+
+        rootServices.push(rootService);
+
+        if (rootService.meta.id === 'Core/Router') {
+            const initializer = unwrapExpression(member.initializer);
+            if (!ts.isNewExpression(initializer)) continue;
+
+            routerPlugins = extractRouterPlugins(initializer.arguments?.[1], imports, servicesAvailable);
+        }
+    }
+
+    if (rootServices.length === 0) {
+        throw new Error(`No root services were found in ${sourceFile.fileName}.`);
+    }
+
+    return { rootServices, routerPlugins };
+};
+
+const resolveManifestService = (service: TParsedService, parent: string): TProteumManifestService => ({
+    kind: 'service',
+    id: service.meta.id,
+    registeredName: service.registeredName,
+    metaName: service.meta.name,
+    parent,
+    priority: service.priority || service.meta.priority || 0,
+    importPath: service.meta.importationPath,
+    sourceDir: service.meta.sourceDir,
+    metasFilepath: service.meta.metasFilepath,
+    scope: service.meta.scope,
+});
+
+export const generateServiceArtifacts = () => {
+    const servicesAvailable = buildServicesAvailable();
+    const { rootServices, routerPlugins } = parseAppBootstrap(servicesAvailable);
+    const appClassIdentifier = app.identity.identifier;
+    const containerServices = app.containerServices.map((serviceName) => "'" + serviceName + "'").join('|');
+    const appServices = rootServices.map((service) => resolveManifestService(service, 'app'));
+    const routerPluginServices = routerPlugins.map((service) => resolveManifestService(service, 'Router.plugins'));
+
+    writeIfChanged(
+        path.join(app.paths.client.generated, 'services.d.ts'),
+        `declare type ${appClassIdentifier} = import("@/server/index").default;
+
+declare module "@app" {
+
+    import { ${appClassIdentifier} as ${appClassIdentifier}Client } from "@/client";
+    import ${appClassIdentifier}Server from "@/server/index";
+  
+    export const Router: ${appClassIdentifier}Client['Router'];
+
+    ${rootServices
+        .map((service) =>
+            service.registeredName !== 'Router'
+                ? `export const ${service.registeredName}: ${appClassIdentifier}Server["${service.registeredName}"];`
+                : '',
+        )
+        .join('\n')}
+
+}
+    
+declare module '@models/types' {
+    export * from '@generated/client/models';
+}
+
+declare module '@common/errors' {
+            
+    export * from '@common/errors/index';
+    export { default } from '@common/errors/index';
+
+    export const AuthRequired: typeof import('@common/errors/index').AuthRequired<FeatureKeys>;
+    export type AuthRequired = import('@common/errors/index').AuthRequired<FeatureKeys>;
+
+    export const UpgradeRequired: typeof import('@common/errors/index').UpgradeRequired<FeatureKeys>;
+    export type UpgradeRequired = import('@common/errors/index').UpgradeRequired<FeatureKeys>;
+}
+
+declare namespace preact.JSX {
+    interface HTMLAttributes {
+        src?: string;
+    }
+}
+`,
+    );
+
+    writeIfChanged(
+        path.join(app.paths.client.generated, 'models.ts'),
+        `export * from '@/var/prisma/browser';
+`,
+    );
+
+    writeIfChanged(
+        path.join(app.paths.client.generated, 'context.ts'),
+        `// TODO: move it into core (but how to make sure usecontext returns ${appClassIdentifier}'s context ?)
+import React from 'react';
+
+import type ${appClassIdentifier}Client from '@/client/index';
+
+export type ClientContext = ${appClassIdentifier}Client["Router"]["context"];
+
+export const ReactClientContext = React.createContext<ClientContext>({} as ClientContext);
+export default (): ClientContext => React.useContext<ClientContext>(ReactClientContext);`,
+    );
+
+    writeIfChanged(
+        path.join(app.paths.common.generated, 'services.d.ts'),
+        `declare type ${appClassIdentifier} = import("@/server/index").default;
+
+declare module '@models/types' {
+    export * from '@generated/common/models';
+}`,
+    );
+
+    writeIfChanged(
+        path.join(app.paths.common.generated, 'models.ts'),
+        `export * from '@/var/prisma/browser';
+`,
+    );
+
+    fs.removeSync(path.join(app.paths.server.generated, 'app.ts'));
+
+    writeIfChanged(
+        path.join(app.paths.server.generated, 'models.ts'),
+        `export * from '@/var/prisma/client';
+`,
+    );
+
+    writeIfChanged(
+        path.join(app.paths.server.generated, 'services.d.ts'),
+        `type InstalledServices = import("@server/app").RootServicesOf<import("@/server/index").default>;
+
+declare type ${appClassIdentifier} = import("@/server/index").default;
+
+declare module "@app" {
+
+    import { ApplicationContainer } from '@server/app/container';
+
+    const ServerServices: (
+        Pick< 
+            ApplicationContainer<InstalledServices>, 
+            ${containerServices}
+        >
+        & 
+        ${appClassIdentifier}
+    )
+
+    export = ServerServices
+}
+
+declare module '@server/app' {
+
+    import { Application } from "@server/app";
+    import { Environment } from "@server/app";
+    import { ServicesContainer } from "@server/app/service/container";
+
+    abstract class ApplicationWithServices extends Application<
+        ServicesContainer<InstalledServices>
+    > {}
+
+    export interface Exported {
+        Application: typeof ApplicationWithServices,
+        Environment: Environment,
+    }
+
+    const foo: Exported;
+
+    export = foo;
+}
+
+declare module '@common/errors' {
+        
+    export * from '@common/errors/index';
+    export { default } from '@common/errors/index';
+
+    export const AuthRequired: typeof import('@common/errors/index').AuthRequired<FeatureKeys>;
+    export type AuthRequired = import('@common/errors/index').AuthRequired<FeatureKeys>;
+
+    export const UpgradeRequired: typeof import('@common/errors/index').UpgradeRequired<FeatureKeys>;
+    export type UpgradeRequired = import('@common/errors/index').UpgradeRequired<FeatureKeys>;
+}
+    
+declare module '@models/types' {
+    export * from '@generated/server/models';
+}`,
+    );
+
+    return { app: appServices, routerPlugins: routerPluginServices };
+};

package/cli/compiler/artifacts/shared.ts

@@ -0,0 +1,12 @@
+import path from 'path';
+
+export const normalizePath = (value: string) => value.replace(/\\/g, '/');
+
+export const normalizeAbsolutePath = (value: string) => normalizePath(path.resolve(value));
+
+export const getGeneratedImportPath = (fromDir: string, targetFile: string) => {
+    const relativeImportPath = path.relative(fromDir, targetFile).replace(/\\/g, '/');
+    const normalizedImportPath = relativeImportPath.startsWith('.') ? relativeImportPath : './' + relativeImportPath;
+
+    return normalizedImportPath.replace(/\.(ts|tsx|js|jsx)$/, '');
+};

package/cli/compiler/client/identite.ts

@@ -6,6 +6,7 @@ import fs from 'fs-extra';
 
 // Type
 import type { App } from '../../app';
+import { logVerbose } from '../../runtime/verbose';
 
 export default async (app: App, outputDir: string, enabled: boolean = true) => {
     if (!enabled) return;
@@ -23,7 +24,7 @@ export default async (app: App, outputDir: string, enabled: boolean = true) => {
     )
         return;
 
-    console.info(`Generating identity assets ...`);
+    logVerbose(`Generating identity assets ...`);
     fs.emptyDirSync(outputDir);
 
     const response = await favicons(logoPath, options);

package/cli/compiler/client/index.ts

@@ -14,6 +14,7 @@ import { createClientBundleAnalysisPlugins } from '../common/bundleAnalysis';
 import { toRspackAliases } from '../common/rspackAliases';
 import identityAssets from './identite';
 import cli from '../..';
+import { logVerbose } from '../../runtime/verbose';
 
 // Type
 import type { App } from '../../app';
@@ -54,7 +55,7 @@ export default function createCompiler(
     mode: TCompileMode,
     outputTarget: TCompileOutputTarget = mode === 'dev' ? 'dev' : 'bin',
 ): Configuration {
-    console.info(`Creating compiler for client (${mode}).`);
+    logVerbose(`Creating compiler for client (${mode}).`);
     const dev = mode === 'dev';
     const outputPath = app.outputPath(outputTarget);
 
@@ -133,12 +134,15 @@ export default function createCompiler(
                     include: [
                         app.paths.root + '/client',
                         cli.paths.core.root + '/client',
+                        app.paths.client.generated,
 
                         app.paths.root + '/common',
                         cli.paths.core.root + '/common',
+                        app.paths.common.generated,
 
                         app.paths.root + '/server',
                         cli.paths.core.root + '/server',
+                        app.paths.server.generated,
                     ],
                     loader: path.join(
                         cli.paths.core.root,
@@ -154,11 +158,16 @@ export default function createCompiler(
                     include: [
                         app.paths.root + '/client',
                         cli.paths.core.root + '/client',
+                        app.paths.client.generated,
 
                         app.paths.root + '/common',
                         cli.paths.core.root + '/common',
+                        app.paths.common.generated,
 
-                        app.paths.root + '/server/.generated/models.ts',
+                        // Prisma 7 generates browser-safe TypeScript entrypoints under var/prisma.
+                        app.paths.root + '/var/prisma',
+
+                        app.paths.server.generated + '/models.ts',
                     ],
                     rules: require('../common/scripts')({ app, side: 'client', dev }),
                 },
@@ -190,7 +199,8 @@ export default function createCompiler(
         plugins: [
             ...(commonConfig.plugins || []),
 
-            ...(dev ? [] : [new rspack.CssExtractRspackPlugin({})]),
+            // Extract CSS in dev too so SSR emits the same stylesheet links as production.
+            new rspack.CssExtractRspackPlugin({}),
 
             ...createClientBundleAnalysisPlugins(app, outputTarget),
         ],

package/cli/compiler/common/controllers.ts

@@ -11,7 +11,14 @@ import ts from 'typescript';
 - TYPES
 ----------------------------------*/
 
-export type TControllerMethodMeta = { name: string; inputCallsCount: number; routePath: string };
+export type TControllerSourceLocation = { line: number; column: number };
+
+export type TControllerMethodMeta = {
+    name: string;
+    inputCallsCount: number;
+    routePath: string;
+    sourceLocation: TControllerSourceLocation;
+};
 
 export type TControllerFileMeta = {
     importPath: string;
@@ -21,9 +28,7 @@ export type TControllerFileMeta = {
     methods: TControllerMethodMeta[];
 };
 
-export type TControllerServiceRoot = { alias: string; dir: string };
-
-type TControllerSearchDir = { importPrefix: string; root: string; serviceRoots?: TControllerServiceRoot[] };
+type TControllerSearchDir = { importPrefix: string; root: string };
 
 /*----------------------------------
 - HELPERS
@@ -31,35 +36,19 @@ type TControllerSearchDir = { importPrefix: string; root: string; serviceRoots?:
 
 const getControllerSegments = (relativePath: string) => {
     const segments = relativePath
-        .replace(/\.controller\.ts$/, '')
+        .replace(/\.ts$/, '')
         .split('/')
         .filter(Boolean);
 
-    if (segments.length > 1 && segments[segments.length - 1] === segments[segments.length - 2]) {
+    if (segments[segments.length - 1] === 'index') {
         segments.pop();
     }
 
     return segments;
 };
 
-const getControllerBasePathFromFilepath = (filepath: string, root: string, serviceRoots: TControllerServiceRoot[] = []) => {
-    const normalizedFilepath = filepath.replace(/\\/g, '/');
-    const serviceRoot = serviceRoots
-        .filter((candidate) => normalizedFilepath.startsWith(candidate.dir.replace(/\\/g, '/') + '/'))
-        .sort((a, b) => b.dir.length - a.dir.length)[0];
-
-    if (!serviceRoot) {
-        return getControllerSegments(path.relative(root, filepath).replace(/\\/g, '/')).join('/');
-    }
-
-    const segments = getControllerSegments(path.relative(serviceRoot.dir, filepath).replace(/\\/g, '/'));
-
-    if (segments[0]?.toLowerCase() === serviceRoot.alias.toLowerCase()) {
-        segments.shift();
-    }
-
-    return [serviceRoot.alias, ...segments].filter(Boolean).join('/');
-};
+const getControllerBasePathFromFilepath = (filepath: string, root: string) =>
+    getControllerSegments(path.relative(root, filepath).replace(/\\/g, '/')).join('/');
 
 const getGeneratedClassName = (filepath: string) => {
     const filename = path.basename(filepath, '.ts').replace(/[^A-Za-z0-9_$]+/g, '_');
@@ -85,7 +74,8 @@ const findControllerFiles = (dir: string): string[] => {
         }
 
         if (!dirent.isFile()) continue;
-        if (!dirent.name.endsWith('.controller.ts')) continue;
+        if (!dirent.name.endsWith('.ts')) continue;
+        if (dirent.name.endsWith('.d.ts')) continue;
 
         files.push(filepath);
     }
@@ -102,6 +92,12 @@ const parseSourceFile = (filepath: string, code: string) =>
         filepath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
     );
 
+const getNodeLocation = (sourceFile: ts.SourceFile, node: ts.Node): TControllerSourceLocation => {
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+
+    return { line: line + 1, column: character + 1 };
+};
+
 const hasModifier = (node: ts.Node, kind: ts.SyntaxKind) =>
     !!node.modifiers?.some((modifier) => modifier.kind === kind);
 
@@ -187,9 +183,7 @@ export const indexControllers = (searchDirs: TControllerSearchDir[]) => {
             if (!defaultClass) continue;
 
             const className = defaultClass.name?.text || getGeneratedClassName(filepath);
-            const routeBasePath =
-                controllerPathOverride ||
-                getControllerBasePathFromFilepath(filepath, searchDir.root, searchDir.serviceRoots || []);
+            const routeBasePath = controllerPathOverride || getControllerBasePathFromFilepath(filepath, searchDir.root);
             const methods: TControllerMethodMeta[] = [];
 
             for (const member of defaultClass.members) {
@@ -208,6 +202,7 @@ export const indexControllers = (searchDirs: TControllerSearchDir[]) => {
                     name: methodName,
                     inputCallsCount,
                     routePath: [routeBasePath, methodName].filter(Boolean).join('/'),
+                    sourceLocation: getNodeLocation(sourceFile, member.name),
                 });
             }
 

package/cli/compiler/common/files/style.ts

@@ -3,13 +3,12 @@ import { rspack } from '@rspack/core';
 
 import type { App } from '../../../app';
 
-module.exports = (app: App, dev: boolean, client: boolean) => {
+module.exports = (app: App, dev: boolean, _client: boolean) => {
     const enableSourceMaps = dev;
-    const useStyleLoader = client && dev;
 
     return [
-        // Apply PostCSS plugins including autoprefixer
-        useStyleLoader ? { loader: 'style-loader' } : { loader: rspack.CssExtractRspackPlugin.loader },
+        // Keep CSS delivery identical in dev and prod: extract files so SSR links stylesheets in both modes.
+        { loader: rspack.CssExtractRspackPlugin.loader },
 
         // Process external/third-party styles
         { exclude: [app.paths.root], loader: 'css-loader', options: { sourceMap: enableSourceMaps } },