proteum 2.5.7 → 2.5.8

package/cli/commands/dev.ts

@@ -6,7 +6,7 @@
 import path from 'path';
 import { spawn, ChildProcess } from 'child_process';
 import fs from 'fs-extra';
-import type { FSWatcher } from 'fs';
+import { realpathSync, watch, type FSWatcher } from 'fs';
 import prompts from 'prompts';
 import { UsageError } from 'clipanion';
 
@@ -677,6 +677,16 @@ function normalizeWatchPath(watchPath: string) {
     return path.resolve(watchPath).replace(/\\/g, '/').replace(/\/$/, '');
 }
 
+const resolveWatchPathAliases = (watchPath: string) => {
+    const aliases = new Set([normalizeWatchPath(watchPath)]);
+
+    try {
+        aliases.add(normalizeWatchPath(realpathSync(watchPath)));
+    } catch {}
+
+    return [...aliases];
+};
+
 type TIndexedSourceWatchEvent = 'change' | 'rename';
 type TIndexedSourceWatchCompilerName = 'server' | 'client';
 type TIndexedSourceWatchInvalidateTarget = 'all' | TIndexedSourceWatchCompilerName;
@@ -692,14 +702,7 @@ type TMultiWatchingLike = TDevWatching & { watchings?: TNamedWatching[] };
 
 const resolveIndexedSourceWatchRules = (): TIndexedSourceWatchRule[] => {
     const transpileWatchRoots = app.transpileModuleDirectories
-        .map((rootPath) => {
-            try {
-                return fs.realpathSync(rootPath);
-            } catch {
-                return rootPath;
-            }
-        })
-        .map(normalizeWatchPath)
+        .flatMap((rootPath) => resolveWatchPathAliases(rootPath))
         .filter((rootPath, index, list) => list.indexOf(rootPath) === index);
 
     return [
@@ -723,7 +726,7 @@ const resolveIndexedSourceWatchRules = (): TIndexedSourceWatchRule[] => {
                 rootPath,
                 relativePathPattern: transpileSourceWatchPattern,
                 eventTypes: ['change', 'rename'],
-                invalidateTargets: ['client', 'server'],
+                invalidateTargets: ['all'],
             }),
         ),
     ];
@@ -848,7 +851,7 @@ const createIndexedSourceWatching = ({
         if (!fs.existsSync(rootPath)) continue;
 
         watchers.push(
-            fs.watch(rootPath, { recursive: true }, (eventType, filename) => {
+            watch(rootPath, { recursive: true }, (eventType, filename) => {
                 const relativePath = typeof filename === 'string' ? filename.replace(/\\/g, '/').replace(/^\.\//, '') : '';
                 const normalizedEventType: TIndexedSourceWatchEvent = eventType === 'change' ? 'change' : 'rename';
 

package/cli/compiler/common/index.ts

@@ -44,10 +44,12 @@ export default function createCommonConfig(
     outputTarget: TCompileOutputTarget = mode === 'dev' ? 'dev' : 'bin',
 ): Configuration {
     const dev = mode === 'dev';
-    const enableFilesystemCache = dev ? cli.args.cache !== false : cli.args.cache === true;
     const transpileModuleDirectories = app.transpileModuleDirectories;
+    const hasTranspileModuleDirectories = transpileModuleDirectories.length > 0;
+    // Persistent cache can restore stale modules from mutable workspace packages even after manual invalidation.
+    const enableFilesystemCache = dev ? cli.args.cache !== false && !hasTranspileModuleDirectories : cli.args.cache === true;
     const transpileModuleSnapshot =
-        dev && transpileModuleDirectories.length > 0
+        dev && hasTranspileModuleDirectories
             ? {
                   // Transpiled local packages can resolve through node_modules symlinks,
                   // but they still need live invalidation like mutable app sources in dev.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "proteum",
 	"description": "LLM-first Opinionated Typescript Framework for web applications.",
-	"version": "2.5.7",
+	"version": "2.5.8",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/proteum.git",
 	"license": "MIT",

package/tests/dev-transpile-watch.test.cjs

@@ -103,6 +103,21 @@ const waitForAssetContaining = async (appRoot, extension, marker, timeoutMs = 60
     throw new Error(`Timed out waiting for ${extension} asset containing ${marker}.`);
 };
 
+const waitForBodyContaining = async (port, urlPath, marker, timeoutMs = 60000) => {
+    const deadline = Date.now() + timeoutMs;
+
+    while (Date.now() < deadline) {
+        try {
+            const { body } = await request(port, urlPath, { Accept: 'text/html' });
+            if (body.includes(marker)) return body;
+        } catch {}
+
+        await sleep(250);
+    }
+
+    throw new Error(`Timed out waiting for ${urlPath} body containing ${marker}.`);
+};
+
 const waitForSessionReady = async (sessionFile, child, getOutput, timeoutMs = 90000) => {
     const deadline = Date.now() + timeoutMs;
 
@@ -199,8 +214,13 @@ const createSharedStyleSource = (marker) => `.shared-style-marker {
 `;
 
 const createFixture = (root, port, options = {}) => {
-    const appRoot = path.join(root, 'app');
-    const sharedRoot = path.join(root, 'shared');
+    const monorepoRootInstall = options.monorepoRootInstall === true;
+    const appRoot = monorepoRootInstall ? path.join(root, 'apps', 'app') : path.join(root, 'app');
+    const sharedRoot = monorepoRootInstall ? path.join(root, 'packages', 'shared') : path.join(root, 'shared');
+    const sharedDependency = monorepoRootInstall ? 'file:../../packages/shared' : 'file:../shared';
+    const sharedInstallRoot = monorepoRootInstall
+        ? path.join(root, 'node_modules', '@test', 'shared')
+        : path.join(appRoot, 'node_modules', '@test', 'shared');
     const cacheConfigSource = options.routerCache ? `        cache: ${options.routerCache},\n` : '';
 
     fs.mkdirSync(path.join(appRoot, 'public'), { recursive: true });
@@ -217,7 +237,7 @@ const createFixture = (root, port, options = {}) => {
                 private: true,
                 version: '0.0.0',
                 dependencies: {
-                    '@test/shared': 'file:../shared',
+                    '@test/shared': sharedDependency,
                     proteum: `file:${coreRoot}`,
                 },
             },
@@ -474,7 +494,7 @@ export default definePageRoute({
     writeFile(path.join(sharedRoot, 'styles.css'), createSharedStyleSource('STYLE_MARKER_INITIAL'));
 
     createSymlink(coreRoot, path.join(appRoot, 'node_modules', 'proteum'));
-    createSymlink(sharedRoot, path.join(appRoot, 'node_modules', '@test', 'shared'));
+    createSymlink(sharedRoot, sharedInstallRoot);
 
     return {
         appRoot,
@@ -500,11 +520,14 @@ const stopDevServer = async (child) => {
     });
 };
 
-const startDevServer = (appRoot, port, sessionFile) => {
+const startDevServer = (appRoot, port, sessionFile, options = {}) => {
     let output = '';
+    const args = [cliBin, 'dev', '--cwd', appRoot, '--port', String(port), '--session-file', sessionFile];
+    if (options.noCache !== false) args.push('--no-cache');
+    args.push('--verbose');
     const child = spawn(
         process.execPath,
-        [cliBin, 'dev', '--cwd', appRoot, '--port', String(port), '--session-file', sessionFile, '--no-cache', '--verbose'],
+        args,
         {
             cwd: appRoot,
             env: {
@@ -577,6 +600,41 @@ test('proteum dev invalidates client assets and reloads for transpiled package s
     }
 });
 
+test(
+    'proteum dev invalidates SSR and client assets for monorepo-root transpiled package installs',
+    { timeout: 180000 },
+    async () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-monorepo-transpile-watch-'));
+        const port = await resolvePortPair();
+        const { appRoot, sharedRoot } = createFixture(root, port, { monorepoRootInstall: true });
+        const sessionFile = path.join(appRoot, 'var', 'run', 'proteum', 'dev', 'monorepo-transpile-watch-test.json');
+        const { child, getOutput } = startDevServer(appRoot, port, sessionFile, { noCache: false });
+
+        try {
+            await waitForSessionReady(sessionFile, child, getOutput);
+            await waitForBodyContaining(port, '/', 'SCRIPT_MARKER_INITIAL').catch((error) => {
+                throw new Error(`${error.message}\n${getOutput()}`);
+            });
+            await waitForAssetContaining(appRoot, '.js', 'SCRIPT_MARKER_INITIAL').catch((error) => {
+                throw new Error(`${error.message}\n${getOutput()}`);
+            });
+
+            const reloadStream = await connectToReloadStream(port + 1);
+            writeFile(path.join(sharedRoot, 'index.tsx'), createSharedIndexSource('SCRIPT_MARKER_MONOREPO_UPDATED'));
+
+            await waitForAssetContaining(appRoot, '.js', 'SCRIPT_MARKER_MONOREPO_UPDATED');
+            await waitForBodyContaining(port, '/', 'SCRIPT_MARKER_MONOREPO_UPDATED');
+            const reloadEvent = await reloadStream.waitForReload();
+            reloadStream.close();
+
+            assert.equal(reloadEvent.type, 'reload');
+        } finally {
+            await stopDevServer(child);
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    },
+);
+
 test('proteum dev applies router HTTP cache config to HTML and public assets', { timeout: 180000 }, async () => {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-router-cache-'));
     const port = await resolvePortPair();