proteum 2.1.3-1 → 2.1.7

package/cli/compiler/artifacts/services.ts

@@ -6,25 +6,28 @@ 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 TImportedBinding =
+    | {
+          kind: 'default' | 'named';
+          importPath: string;
+          localName: string;
+          exportedName: string;
+      }
+    | {
+          kind: 'namespace';
+          importPath: string;
+          localName: string;
+      };
 
 type TParsedService = {
-    registeredName: string;
+    className: string;
+    importPath: string;
     priority: number;
-    meta: TServiceMetas;
+    registeredName: string;
+    scope: TProteumManifestScope;
+    sourceFilepath?: string;
 };
 
 type TParsedAppBootstrap = {
@@ -32,51 +35,28 @@ type TParsedAppBootstrap = {
     routerPlugins: TParsedService[];
 };
 
-type TServicesAvailable = Record<string, TServiceMetas>;
 type TCommandServiceStubSource = {
     aliasImportPath: string;
     filepath: string;
 };
+
 type TGeneratedCommandServiceStubs = {
     declarations: string;
     typeNamesByAliasImportPath: Map<string, string>;
 };
 
-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') },
-    ];
+type TResolvedImportSource = {
+    scope?: TProteumManifestScope;
+    sourceFilepath?: string;
+};
 
-    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,
-            };
-        }
-    }
+const coreServicesRoot = normalizeAbsolutePath(path.join(cli.paths.core.root, 'server', 'services'));
+const appServicesRoot = normalizeAbsolutePath(path.join(app.paths.root, 'server', 'services'));
+const coreServerRoot = normalizeAbsolutePath(path.join(cli.paths.core.root, 'server'));
+const appServerRoot = normalizeAbsolutePath(path.join(app.paths.root, 'server'));
 
-    return servicesAvailable;
-};
+const moduleSourceCache = new Map<string, ts.SourceFile>();
+const exportExpressionCache = new Map<string, ts.Expression | undefined>();
 
 const getAppServerEntryFilepath = () => {
     const filepath = app.paths.server.entry;
@@ -88,15 +68,23 @@ const getAppServerEntryFilepath = () => {
     return filepath;
 };
 
-const createSourceFile = (filepath: string) =>
-    ts.createSourceFile(
-        filepath,
-        fs.readFileSync(filepath, 'utf8'),
+const createSourceFile = (filepath: string) => {
+    const normalizedFilepath = normalizeAbsolutePath(filepath);
+    const existing = moduleSourceCache.get(normalizedFilepath);
+    if (existing) return existing;
+
+    const sourceFile = ts.createSourceFile(
+        normalizedFilepath,
+        fs.readFileSync(normalizedFilepath, 'utf8'),
         ts.ScriptTarget.Latest,
         true,
-        filepath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+        normalizedFilepath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
     );
 
+    moduleSourceCache.set(normalizedFilepath, sourceFile);
+    return sourceFile;
+};
+
 const hasModifier = (node: ts.Node, kind: ts.SyntaxKind) => {
     const modifiers = (node as ts.Node & { modifiers?: ts.NodeArray<ts.Modifier> }).modifiers;
 
@@ -141,7 +129,7 @@ const getDefaultExportClassDeclaration = (sourceFile: ts.SourceFile) => {
 };
 
 const buildImportIndex = (sourceFile: ts.SourceFile) => {
-    const imports = new Map<string, string>();
+    const imports = new Map<string, TImportedBinding>();
 
     for (const statement of sourceFile.statements) {
         if (!ts.isImportDeclaration(statement)) continue;
@@ -152,14 +140,35 @@ const buildImportIndex = (sourceFile: ts.SourceFile) => {
         const { importClause } = statement;
 
         if (importClause.name) {
-            imports.set(importClause.name.text, importPath);
+            imports.set(importClause.name.text, {
+                kind: 'default',
+                importPath,
+                localName: importClause.name.text,
+                exportedName: 'default',
+            });
         }
 
         const namedBindings = importClause.namedBindings;
-        if (!namedBindings || !ts.isNamedImports(namedBindings)) continue;
+        if (!namedBindings) continue;
+
+        if (ts.isNamespaceImport(namedBindings)) {
+            imports.set(namedBindings.name.text, {
+                kind: 'namespace',
+                importPath,
+                localName: namedBindings.name.text,
+            });
+            continue;
+        }
+
+        if (!ts.isNamedImports(namedBindings)) continue;
 
         for (const element of namedBindings.elements) {
-            imports.set(element.name.text, importPath);
+            imports.set(element.name.text, {
+                kind: 'named',
+                importPath,
+                localName: element.name.text,
+                exportedName: element.propertyName?.text || element.name.text,
+            });
         }
     }
 
@@ -183,26 +192,180 @@ const getPropertyNameText = (propertyName: ts.PropertyName | undefined): string
     return undefined;
 };
 
-const extractPriorityFromConfig = (configExpression?: ts.Expression) => {
-    if (!configExpression) return 0;
+const resolveExistingModuleFilepath = (importPath: string) => {
+    const candidates = [
+        importPath,
+        `${importPath}.ts`,
+        `${importPath}.tsx`,
+        path.join(importPath, 'index.ts'),
+        path.join(importPath, 'index.tsx'),
+    ];
 
-    const expression = unwrapExpression(configExpression);
-    if (!ts.isObjectLiteralExpression(expression)) return 0;
+    for (const candidate of candidates) {
+        if (!fs.existsSync(candidate)) continue;
+        if (!fs.statSync(candidate).isFile()) continue;
 
-    const priorityProperty = expression.properties.find((property) => {
+        return normalizeAbsolutePath(candidate);
+    }
+
+    return undefined;
+};
+
+const resolveImportSource = (importPath: string, fromFilepath: string): TResolvedImportSource => {
+    if (importPath.startsWith('@server/')) {
+        return {
+            scope: 'framework',
+            sourceFilepath: resolveExistingModuleFilepath(path.join(cli.paths.core.root, importPath.slice(1))),
+        };
+    }
+
+    if (importPath.startsWith('@/')) {
+        return {
+            scope: 'app',
+            sourceFilepath: resolveExistingModuleFilepath(path.join(app.paths.root, importPath.slice(2))),
+        };
+    }
+
+    if (importPath.startsWith('./') || importPath.startsWith('../')) {
+        const sourceFilepath = resolveExistingModuleFilepath(path.resolve(path.dirname(fromFilepath), importPath));
+        if (!sourceFilepath) return {};
+
+        if (sourceFilepath === appServerRoot || sourceFilepath.startsWith(`${appServerRoot}/`)) {
+            return { scope: 'app', sourceFilepath };
+        }
+
+        if (sourceFilepath === coreServerRoot || sourceFilepath.startsWith(`${coreServerRoot}/`)) {
+            return { scope: 'framework', sourceFilepath };
+        }
+
+        return { sourceFilepath };
+    }
+
+    return {};
+};
+
+const getObjectLiteralProperty = (expression: ts.ObjectLiteralExpression, propertyName: string) =>
+    expression.properties.find((property) => {
         if (!ts.isPropertyAssignment(property)) return false;
 
-        return getPropertyNameText(property.name) === 'priority';
+        return getPropertyNameText(property.name) === propertyName;
     });
 
-    if (!priorityProperty || !ts.isPropertyAssignment(priorityProperty)) return 0;
+const readNumericLiteral = (expression: ts.Expression) => {
+    const unwrappedExpression = unwrapExpression(expression);
+
+    if (ts.isNumericLiteral(unwrappedExpression)) return Number(unwrappedExpression.text);
+
+    if (
+        ts.isPrefixUnaryExpression(unwrappedExpression) &&
+        unwrappedExpression.operator === ts.SyntaxKind.MinusToken &&
+        ts.isNumericLiteral(unwrapExpression(unwrappedExpression.operand))
+    ) {
+        return -Number((unwrapExpression(unwrappedExpression.operand) as ts.NumericLiteral).text);
+    }
+
+    return undefined;
+};
+
+const getExportedExpression = (moduleFilepath: string, exportName: string): ts.Expression | undefined => {
+    const cacheKey = `${normalizeAbsolutePath(moduleFilepath)}::${exportName}`;
+    if (exportExpressionCache.has(cacheKey)) return exportExpressionCache.get(cacheKey);
+
+    const sourceFile = createSourceFile(moduleFilepath);
+    const namedExports = new Map<string, string>();
+
+    for (const statement of sourceFile.statements) {
+        if (!ts.isExportDeclaration(statement) || !statement.exportClause || !ts.isNamedExports(statement.exportClause)) continue;
+
+        for (const element of statement.exportClause.elements) {
+            const exportedName = element.name.text;
+            const localName = element.propertyName?.text || element.name.text;
+            namedExports.set(exportedName, localName);
+        }
+    }
+
+    const localName = namedExports.get(exportName) || exportName;
+
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement) || !hasModifier(statement, ts.SyntaxKind.ExportKeyword)) continue;
+
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name) || declaration.name.text !== localName || !declaration.initializer) continue;
+
+            exportExpressionCache.set(cacheKey, declaration.initializer);
+            return declaration.initializer;
+        }
+    }
+
+    exportExpressionCache.set(cacheKey, undefined);
+    return undefined;
+};
+
+const extractPriorityFromConfigExpression = (
+    configExpression: ts.Expression | undefined,
+    imports: Map<string, TImportedBinding>,
+    sourceFilepath: string,
+    seen = new Set<string>(),
+): number => {
+    if (!configExpression) return 0;
+
+    const expression = unwrapExpression(configExpression);
 
-    const priorityExpression = unwrapExpression(priorityProperty.initializer);
-    if (ts.isNumericLiteral(priorityExpression)) return Number(priorityExpression.text);
+    if (ts.isObjectLiteralExpression(expression)) {
+        const priorityProperty = getObjectLiteralProperty(expression, 'priority');
+        if (!priorityProperty || !ts.isPropertyAssignment(priorityProperty)) return 0;
+        return readNumericLiteral(priorityProperty.initializer) || 0;
+    }
+
+    if (ts.isCallExpression(expression) && ts.isPropertyAccessExpression(expression.expression)) {
+        const callee = expression.expression;
 
-    if (ts.isPrefixUnaryExpression(priorityExpression) && priorityExpression.operator === ts.SyntaxKind.MinusToken) {
-        const operand = unwrapExpression(priorityExpression.operand);
-        if (ts.isNumericLiteral(operand)) return -Number(operand.text);
+        if (
+            ts.isIdentifier(callee.expression) &&
+            callee.expression.text === 'Services' &&
+            callee.name.text === 'config'
+        ) {
+            return extractPriorityFromConfigExpression(expression.arguments[1], imports, sourceFilepath, seen);
+        }
+    }
+
+    if (ts.isIdentifier(expression)) {
+        const imported = imports.get(expression.text);
+        if (!imported || imported.kind === 'namespace') return 0;
+
+        const resolved = resolveImportSource(imported.importPath, sourceFilepath);
+        if (!resolved.sourceFilepath) return 0;
+
+        const cacheKey = `${resolved.sourceFilepath}::${imported.exportedName}`;
+        if (seen.has(cacheKey)) return 0;
+
+        seen.add(cacheKey);
+        return extractPriorityFromConfigExpression(
+            getExportedExpression(resolved.sourceFilepath, imported.exportedName),
+            buildImportIndex(createSourceFile(resolved.sourceFilepath)),
+            resolved.sourceFilepath,
+            seen,
+        );
+    }
+
+    if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.expression)) {
+        const imported = imports.get(expression.expression.text);
+        if (!imported || imported.kind !== 'namespace') return 0;
+
+        const resolved = resolveImportSource(imported.importPath, sourceFilepath);
+        if (!resolved.sourceFilepath) return 0;
+
+        const exportName = expression.name.text;
+        const cacheKey = `${resolved.sourceFilepath}::${exportName}`;
+        if (seen.has(cacheKey)) return 0;
+
+        seen.add(cacheKey);
+        return extractPriorityFromConfigExpression(
+            getExportedExpression(resolved.sourceFilepath, exportName),
+            buildImportIndex(createSourceFile(resolved.sourceFilepath)),
+            resolved.sourceFilepath,
+            seen,
+        );
     }
 
     return 0;
@@ -210,50 +373,51 @@ const extractPriorityFromConfig = (configExpression?: ts.Expression) => {
 
 const resolveImportedService = (
     expression: ts.LeftHandSideExpression,
-    imports: Map<string, string>,
-    servicesAvailable: TServicesAvailable,
+    imports: Map<string, TImportedBinding>,
+    sourceFilepath: string,
 ) => {
     if (!ts.isIdentifier(expression)) return undefined;
 
-    const importPath = imports.get(expression.text);
-    if (!importPath) return undefined;
+    const imported = imports.get(expression.text);
+    if (!imported || imported.kind === 'namespace') return undefined;
+
+    const resolved = resolveImportSource(imported.importPath, sourceFilepath);
+    if (!resolved.scope) return undefined;
 
-    return Object.values(servicesAvailable).find((serviceMeta) => serviceMeta.importationPath === importPath);
+    return {
+        className: expression.text,
+        importPath: imported.importPath,
+        scope: resolved.scope,
+        sourceFilepath: resolved.sourceFilepath,
+    };
 };
 
 const parseServiceInstantiation = (
     registeredName: string,
     expression: ts.Expression,
-    imports: Map<string, string>,
-    servicesAvailable: TServicesAvailable,
+    imports: Map<string, TImportedBinding>,
+    sourceFilepath: string,
     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 resolvedService = resolveImportedService(unwrappedExpression.expression, imports, sourceFilepath);
+    if (!resolvedService) return undefined;
 
     const configExpression = unwrappedExpression.arguments?.[configArgIndex];
 
     return {
+        ...resolvedService,
         registeredName,
-        priority: extractPriorityFromConfig(configExpression),
-        meta,
+        priority: extractPriorityFromConfigExpression(configExpression, imports, sourceFilepath),
     };
 };
 
-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,
+    imports: Map<string, TImportedBinding>,
+    sourceFilepath: string,
 ) => {
     if (!routerConfigExpression) return [];
 
@@ -274,7 +438,7 @@ const extractRouterPlugins = (
         const registeredName = getPropertyNameText(property.name);
         if (!registeredName) continue;
 
-        const routerPlugin = parseServiceInstantiation(registeredName, property.initializer, imports, servicesAvailable, 0);
+        const routerPlugin = parseServiceInstantiation(registeredName, property.initializer, imports, sourceFilepath, 0);
         if (!routerPlugin) continue;
 
         routerPlugins.push(routerPlugin);
@@ -283,7 +447,7 @@ const extractRouterPlugins = (
     return routerPlugins;
 };
 
-const parseAppBootstrap = (servicesAvailable: TServicesAvailable): TParsedAppBootstrap => {
+const parseAppBootstrap = (): TParsedAppBootstrap => {
     const sourceFile = createSourceFile(getAppServerEntryFilepath());
     const imports = buildImportIndex(sourceFile);
     const appClass = getDefaultExportClassDeclaration(sourceFile);
@@ -297,16 +461,16 @@ const parseAppBootstrap = (servicesAvailable: TServicesAvailable): TParsedAppBoo
         const registeredName = getPropertyNameText(member.name);
         if (!registeredName) continue;
 
-        const rootService = parseServiceInstantiation(registeredName, member.initializer, imports, servicesAvailable, 1);
+        const rootService = parseServiceInstantiation(registeredName, member.initializer, imports, sourceFile.fileName, 1);
         if (!rootService) continue;
 
         rootServices.push(rootService);
 
-        if (rootService.meta.id === 'Core/Router') {
+        if (rootService.importPath === '@server/services/router') {
             const initializer = unwrapExpression(member.initializer);
             if (!ts.isNewExpression(initializer)) continue;
 
-            routerPlugins = extractRouterPlugins(initializer.arguments?.[1], imports, servicesAvailable);
+            routerPlugins = extractRouterPlugins(initializer.arguments?.[1], imports, sourceFile.fileName);
         }
     }
 
@@ -318,23 +482,10 @@ const parseAppBootstrap = (servicesAvailable: TServicesAvailable): TParsedAppBoo
 };
 
 const commandServiceSearchRoots = [
-    { root: normalizeAbsolutePath(path.join(cli.paths.core.root, 'server', 'services')), prefix: '@server/services/' },
-    { root: normalizeAbsolutePath(path.join(app.paths.root, 'server', 'services')), prefix: '@/server/services/' },
+    { root: coreServicesRoot, prefix: '@server/services/' },
+    { root: appServicesRoot, prefix: '@/server/services/' },
 ];
 
-const resolveExistingModuleFilepath = (importPath: string) => {
-    const candidates = [importPath, `${importPath}.ts`, `${importPath}.tsx`, path.join(importPath, 'index.ts'), path.join(importPath, 'index.tsx')];
-
-    for (const candidate of candidates) {
-        if (!fs.existsSync(candidate)) continue;
-        if (!fs.statSync(candidate).isFile()) continue;
-
-        return normalizeAbsolutePath(candidate);
-    }
-
-    return undefined;
-};
-
 const getCommandServiceAliasFromFilepath = (filepath: string) => {
     const normalizedFilepath = normalizeAbsolutePath(filepath);
 
@@ -389,23 +540,21 @@ const isPrivateOrProtectedInstanceMember = (member: ts.ClassElement) =>
 
 const getPropertyDeclarationType = (
     property: ts.PropertyDeclaration,
-    imports: Map<string, string>,
+    imports: Map<string, TImportedBinding>,
     sourceFilepath: string,
     getStubTypeName: (source: TCommandServiceStubSource) => string,
     enqueueStub: (source: TCommandServiceStubSource) => void,
 ) => {
     const initializer = property.initializer ? unwrapExpression(property.initializer) : undefined;
 
-    if (initializer && ts.isNewExpression(initializer)) {
-        if (ts.isIdentifier(initializer.expression)) {
-            const nestedImportPath = imports.get(initializer.expression.text);
-            if (nestedImportPath) {
-                const nestedSource = resolveCommandServiceStubSource(nestedImportPath, sourceFilepath);
+    if (initializer && ts.isNewExpression(initializer) && ts.isIdentifier(initializer.expression)) {
+        const nestedImport = imports.get(initializer.expression.text);
+        if (nestedImport && nestedImport.kind !== 'namespace') {
+            const nestedSource = resolveCommandServiceStubSource(nestedImport.importPath, sourceFilepath);
 
-                if (nestedSource) {
-                    enqueueStub(nestedSource);
-                    return getStubTypeName(nestedSource);
-                }
+            if (nestedSource) {
+                enqueueStub(nestedSource);
+                return getStubTypeName(nestedSource);
             }
         }
     }
@@ -483,7 +632,7 @@ const createCommandServiceStubDeclarations = (rootServices: TParsedService[]): T
     };
 
     for (const rootService of rootServices) {
-        const source = resolveCommandServiceStubSource(rootService.meta.importationPath);
+        const source = resolveCommandServiceStubSource(rootService.importPath, rootService.sourceFilepath);
         if (source) enqueueStub(source);
     }
 
@@ -564,20 +713,17 @@ ${classMembers.join('\n')}
 
 const resolveManifestService = (service: TParsedService, parent: string): TProteumManifestService => ({
     kind: 'service',
-    id: service.meta.id,
     registeredName: service.registeredName,
-    metaName: service.meta.name,
+    className: service.className,
     parent,
-    priority: service.priority || service.meta.priority || 0,
-    importPath: service.meta.importationPath,
-    sourceDir: service.meta.sourceDir,
-    metasFilepath: service.meta.metasFilepath,
-    scope: service.meta.scope,
+    priority: service.priority,
+    importPath: service.importPath,
+    sourceFilepath: service.sourceFilepath,
+    scope: service.scope,
 });
 
 export const generateServiceArtifacts = () => {
-    const servicesAvailable = buildServicesAvailable();
-    const { rootServices, routerPlugins } = parseAppBootstrap(servicesAvailable);
+    const { rootServices, routerPlugins } = parseAppBootstrap();
     const appClassIdentifier = app.identity.identifier;
     const containerServices = app.containerServices.map((serviceName) => "'" + serviceName + "'").join('|');
     const appServices = rootServices.map((service) => resolveManifestService(service, 'app'));
@@ -699,7 +845,8 @@ declare class ${appClassIdentifier} implements import("@server/app/commands").TC
     Models?: import("@server/app/commands").TCommandApplication["Models"];
 ${rootServices
     .map((service) => {
-        const typeName = commandServiceStubs.typeNamesByAliasImportPath.get(service.meta.importationPath) || 'any';
+        const source = resolveCommandServiceStubSource(service.importPath, service.sourceFilepath);
+        const typeName = source ? commandServiceStubs.typeNamesByAliasImportPath.get(source.aliasImportPath) || 'any' : 'any';
 
         return `    ${service.registeredName}: ${typeName};`;
     })

package/cli/compiler/client/index.ts

@@ -78,6 +78,7 @@ export default function createCompiler(
     const outputPath = app.outputPath(outputTarget);
     const installedCoreRoot = path.join(app.paths.root, 'node_modules', 'proteum');
     const frameworkRoots = [cli.paths.core.root, installedCoreRoot];
+    const transpileModuleDirectories = app.transpileModuleDirectories;
 
     const commonConfig = createCommonConfig(app, 'client', mode, outputTarget);
 
@@ -164,6 +165,7 @@ export default function createCompiler(
                         ...frameworkRoots.map((rootPath) => rootPath + '/client'),
                         ...frameworkRoots.map((rootPath) => rootPath + '/common'),
                         ...frameworkRoots.map((rootPath) => rootPath + '/server'),
+                        ...transpileModuleDirectories,
                     ],
                     loader: path.join(
                         cli.paths.core.root,
@@ -190,6 +192,7 @@ export default function createCompiler(
                         ...frameworkRoots.map((rootPath) => rootPath + '/client'),
                         ...frameworkRoots.map((rootPath) => rootPath + '/common'),
                         ...frameworkRoots.map((rootPath) => rootPath + '/server'),
+                        ...transpileModuleDirectories,
                     ],
                     rules: require('../common/scripts')({ app, side: 'client', dev }),
                 },

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

@@ -1,10 +1,58 @@
+import path from 'path';
+
 // Plugons
 import { rspack } from '@rspack/core';
+import type { Root } from 'postcss';
 
 import type { App } from '../../../app';
 
+const normalizePath = (value: string) => path.resolve(value).replace(/\\/g, '/');
+
+const isPathInsideDirectory = (filepath: string, directory: string) =>
+    filepath === directory || filepath.startsWith(directory + '/');
+
+const createTailwindTranspileSourcesPlugin = (app: App) => {
+    const appRoot = normalizePath(app.paths.root);
+    const transpileSourceDirectories = Array.from(
+        new Set(app.transpileModuleDirectories.map((directory) => normalizePath(directory))),
+    );
+
+    if (transpileSourceDirectories.length === 0) return null;
+
+    return {
+        postcssPlugin: 'proteum-tailwind-transpile-sources',
+        Once(root: Root) {
+            const sourceFile = root.source?.input?.file ? normalizePath(root.source.input.file) : '';
+            if (!sourceFile || !isPathInsideDirectory(sourceFile, appRoot)) return;
+
+            const sourceDirectory = path.dirname(sourceFile);
+            const existingSourceParams = new Set<string>();
+
+            root.walkAtRules('source', (rule) => {
+                existingSourceParams.add(String(rule.params).trim());
+            });
+
+            for (const transpileDirectory of [...transpileSourceDirectories].reverse()) {
+                const relativeSourceDirectory = path.relative(sourceDirectory, transpileDirectory).split(path.sep).join('/');
+                const sourceParam = JSON.stringify(
+                    relativeSourceDirectory.startsWith('.') ? relativeSourceDirectory : `./${relativeSourceDirectory}`,
+                );
+
+                if (existingSourceParams.has(sourceParam)) continue;
+
+                root.prepend({
+                    name: 'source',
+                    params: sourceParam,
+                    type: 'atrule',
+                });
+            }
+        },
+    };
+};
+
 module.exports = (app: App, dev: boolean, _client: boolean) => {
     const enableSourceMaps = dev;
+    const tailwindTranspileSourcesPlugin = createTailwindTranspileSourcesPlugin(app);
 
     return [
         // Keep CSS delivery identical in dev and prod: extract files so SSR links stylesheets in both modes.
@@ -29,6 +77,10 @@ module.exports = (app: App, dev: boolean, _client: boolean) => {
             options: {
                 postcssOptions: {
                     plugins: [
+                        // Tailwind v4 only scans files that it knows about. When app code imports
+                        // transpiled local packages, register those package roots explicitly so
+                        // shared utility classes survive app splits and workspace extraction.
+                        ...(tailwindTranspileSourcesPlugin ? [tailwindTranspileSourcesPlugin] : []),
                         /* Tailwind V4 */ require('@tailwindcss/postcss')({
                             // Ensure Tailwind scans the application sources even if the build
                             // process is launched from another working directory (e.g. Docker).