proteum 2.2.9 → 2.4.1

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

@@ -5,7 +5,6 @@ const net = require('node:net');
 const os = require('node:os');
 const path = require('node:path');
 const { spawn } = require('node:child_process');
-const test = require('node:test');
 
 const coreRoot = path.resolve(__dirname, '..');
 const cliBin = path.join(coreRoot, 'cli', 'bin.js');
@@ -65,6 +64,33 @@ const findAssetContaining = (appRoot, extension, marker) => {
     return candidates.find((filepath) => fs.readFileSync(filepath, 'utf8').includes(marker));
 };
 
+const toPublicAssetUrl = (appRoot, filepath) => {
+    const publicRoot = path.join(appRoot, 'dev', 'public');
+    const relativePath = path.relative(publicRoot, filepath).split(path.sep).join('/');
+
+    return `/public/${relativePath}`;
+};
+
+const request = async (port, urlPath, headers = {}) => {
+    const response = await fetch(`http://127.0.0.1:${port}${urlPath}`, { headers });
+    const body = await response.text();
+
+    return { response, body };
+};
+
+const waitForHeader = async (port, urlPath, headerName, expectedValue, timeoutMs = 60000) => {
+    const deadline = Date.now() + timeoutMs;
+
+    while (Date.now() < deadline) {
+        const { response } = await request(port, urlPath, { Accept: 'text/html' });
+        if (response.headers.get(headerName) === expectedValue) return response;
+
+        await sleep(250);
+    }
+
+    throw new Error(`Timed out waiting for ${urlPath} header ${headerName}=${expectedValue}.`);
+};
+
 const waitForAssetContaining = async (appRoot, extension, marker, timeoutMs = 60000) => {
     const deadline = Date.now() + timeoutMs;
 
@@ -172,9 +198,10 @@ const createSharedStyleSource = (marker) => `.shared-style-marker {
 }
 `;
 
-const createFixture = (root, port) => {
+const createFixture = (root, port, options = {}) => {
     const appRoot = path.join(root, 'app');
     const sharedRoot = path.join(root, 'shared');
+    const cacheConfigSource = options.routerCache ? `        cache: ${options.routerCache},\n` : '';
 
     fs.mkdirSync(path.join(appRoot, 'public'), { recursive: true });
     fs.mkdirSync(path.join(appRoot, 'client', 'assets', 'identity'), { recursive: true });
@@ -332,6 +359,7 @@ export const routerBaseConfig = {
         upload: {
             maxSize: '10mb',
         },
+${cacheConfigSource}
         csp: {
             scripts: [],
         },
@@ -403,6 +431,31 @@ Router.page(
 );
 `,
     );
+    if (options.staticPage) {
+        writeFile(
+            path.join(appRoot, 'client', 'pages', 'static-cache.tsx'),
+            `import Router from '@/client/router';
+import { SharedMarker } from '@test/shared';
+
+Router.page(
+    '/static-cache',
+    {
+        auth: false,
+        layout: false,
+        static: { urls: ['/static-cache'] },
+    },
+    null,
+    () => {
+        return (
+            <main>
+                <SharedMarker />
+            </main>
+        );
+    },
+);
+`,
+        );
+    }
 
     writeFile(
         path.join(sharedRoot, 'package.json'),
@@ -448,13 +501,8 @@ const stopDevServer = async (child) => {
     });
 };
 
-test('proteum dev invalidates client assets and reloads for transpiled package scripts and styles', { timeout: 180000 }, async () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-transpile-watch-'));
-    const port = await resolvePortPair();
-    const { appRoot, sharedRoot } = createFixture(root, port);
-    const sessionFile = path.join(appRoot, 'var', 'run', 'proteum', 'dev', 'transpile-watch-test.json');
+const startDevServer = (appRoot, port, sessionFile) => {
     let output = '';
-
     const child = spawn(
         process.execPath,
         [cliBin, 'dev', '--cwd', appRoot, '--port', String(port), '--session-file', sessionFile, '--no-cache', '--verbose'],
@@ -476,8 +524,21 @@ test('proteum dev invalidates client assets and reloads for transpiled package s
         output += chunk.toString();
     });
 
+    return {
+        child,
+        getOutput: () => output,
+    };
+};
+
+test('proteum dev invalidates client assets and reloads for transpiled package scripts and styles', { timeout: 180000 }, async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-transpile-watch-'));
+    const port = await resolvePortPair();
+    const { appRoot, sharedRoot } = createFixture(root, port);
+    const sessionFile = path.join(appRoot, 'var', 'run', 'proteum', 'dev', 'transpile-watch-test.json');
+    const { child, getOutput } = startDevServer(appRoot, port, sessionFile);
+
     try {
-        await waitForSessionReady(sessionFile, child, () => output);
+        await waitForSessionReady(sessionFile, child, getOutput);
 
         const initialScriptAsset = await waitForAssetContaining(appRoot, '.js', 'SCRIPT_MARKER_INITIAL');
         const initialScriptContent = fs.readFileSync(initialScriptAsset, 'utf8');
@@ -511,3 +572,50 @@ test('proteum dev invalidates client assets and reloads for transpiled package s
         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();
+    const dynamicHtmlCacheControl = 'private, max-age=7';
+    const staticHtmlCacheControl = 'private, max-age=13';
+    const publicAssetCacheControl = 'private, max-age=17';
+    const { appRoot } = createFixture(root, port, {
+        staticPage: true,
+        routerCache: `{
+            html: {
+                dynamic: { cacheControl: '${dynamicHtmlCacheControl}', surrogateControl: 'dynamic-surrogate' },
+                static: { cacheControl: '${staticHtmlCacheControl}', surrogateControl: 'static-surrogate' },
+            },
+            publicAssets: {
+                dev: '${publicAssetCacheControl}',
+                versioned: '${publicAssetCacheControl}',
+                unversioned: '${publicAssetCacheControl}',
+                etag: false,
+                lastModified: false,
+            },
+        }`,
+    });
+    const sessionFile = path.join(appRoot, 'var', 'run', 'proteum', 'dev', 'router-cache-test.json');
+    const { child, getOutput } = startDevServer(appRoot, port, sessionFile);
+
+    try {
+        await waitForSessionReady(sessionFile, child, getOutput);
+
+        const { response: dynamicResponse } = await request(port, '/', { Accept: 'text/html' });
+        assert.equal(dynamicResponse.headers.get('cache-control'), dynamicHtmlCacheControl);
+        assert.equal(dynamicResponse.headers.get('surrogate-control'), 'dynamic-surrogate');
+
+        const staticResponse = await waitForHeader(port, '/static-cache', 'cache-control', staticHtmlCacheControl);
+        assert.equal(staticResponse.headers.get('surrogate-control'), 'static-surrogate');
+
+        const asset = await waitForAssetContaining(appRoot, '.js', 'SCRIPT_MARKER_INITIAL');
+        const { response: assetResponse } = await request(port, toPublicAssetUrl(appRoot, asset));
+
+        assert.equal(assetResponse.headers.get('cache-control'), publicAssetCacheControl);
+        assert.equal(assetResponse.headers.get('etag'), null);
+        assert.equal(assetResponse.headers.get('last-modified'), null);
+    } finally {
+        await stopDevServer(child);
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+});

package/tests/eslint-rules.test.cjs

@@ -1,5 +1,4 @@
 const assert = require('node:assert/strict');
-const test = require('node:test');
 const { Linter } = require('eslint');
 
 const { createProteumEslintConfig } = require('../eslint.js');

package/tests/inspection.test.cjs

@@ -0,0 +1,66 @@
+const assert = require('node:assert/strict');
+const path = require('node:path');
+
+const coreRoot = path.resolve(__dirname, '..');
+process.env.TS_NODE_PROJECT = path.join(coreRoot, 'cli', 'tsconfig.json');
+process.env.TS_NODE_TRANSPILE_ONLY = '1';
+require('ts-node/register/transpile-only');
+
+const { explainOwner } = require('../common/dev/inspection.ts');
+
+const createRoute = (routePath, filepath) => ({
+    chunkFilepath: filepath,
+    chunkId: filepath.replace(/[^A-Za-z0-9]+/g, '_'),
+    codeRaw: routePath,
+    filepath,
+    hasData: false,
+    kind: 'page',
+    methodName: 'page',
+    normalizedOptionKeys: [],
+    path: routePath,
+    pathRaw: routePath,
+    scope: 'app',
+    sourceLocation: { line: 1, column: 1 },
+    targetResolution: 'literal',
+});
+
+const createManifest = (routes) => ({
+    app: {
+        coreRoot,
+        root: '/tmp/proteum-app',
+    },
+    commands: [],
+    connectedProjects: [],
+    controllers: [],
+    diagnostics: [],
+    layouts: [],
+    routes: {
+        client: routes,
+        server: [],
+    },
+    services: {
+        app: [],
+        routerPlugins: [],
+    },
+});
+
+test('root owner lookup does not match every dynamic route containing a slash', () => {
+    const manifest = createManifest([
+        createRoute('/domains/:slug((?!tlds$|tld$|sector$)[^/]+)', '/tmp/proteum-app/client/pages/domains/slug.tsx'),
+        createRoute('/admin/data/:tab([^/]+)', '/tmp/proteum-app/client/pages/admin/data.tsx'),
+    ]);
+
+    assert.deepEqual(explainOwner(manifest, '/').matches, []);
+});
+
+test('root owner lookup returns only the literal root route when present', () => {
+    const manifest = createManifest([
+        createRoute('/domains/:slug((?!tlds$|tld$|sector$)[^/]+)', '/tmp/proteum-app/client/pages/domains/slug.tsx'),
+        createRoute('/', '/tmp/proteum-app/client/pages/home.tsx'),
+    ]);
+
+    const matches = explainOwner(manifest, '/').matches;
+
+    assert.equal(matches.length, 1);
+    assert.equal(matches[0].label, '/');
+});