@bleedingdev/modern-js-server-runtime-extensions 0.0.0-trusted-publisher-bootstrap

package/tests/contractGateAutopilot.test.ts

@@ -0,0 +1,203 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { ContractGateAutopilot } from '../src/contractGateAutopilot';
+import {
+  TelemetryCanaryOrchestrator,
+  TelemetryRegistry,
+} from '../src/telemetry';
+
+const makeTempDir = () =>
+  fs.mkdtempSync(path.join(os.tmpdir(), 'modern-contract-gate-autopilot-'));
+
+describe('contract gate autopilot', () => {
+  test('syncs gate snapshot and updates canary decisions automatically', async () => {
+    const dir = makeTempDir();
+    const snapshotPath = path.join(dir, 'contract-gates.json');
+
+    const registry = new TelemetryRegistry({
+      service: 'svc',
+      module: 'server',
+      environment: 'test',
+      flushIntervalMs: 60_000,
+    });
+    const orchestrator = new TelemetryCanaryOrchestrator({
+      registry,
+      rollbackConsecutiveFailures: 1,
+    });
+    const autopilot = new ContractGateAutopilot({
+      orchestrator,
+      gateSnapshotPath: snapshotPath,
+      pollIntervalMs: 50,
+      gateStaleAfterMs: 60_000,
+    });
+
+    try {
+      fs.writeFileSync(
+        snapshotPath,
+        JSON.stringify(
+          {
+            schemaVersion: 1,
+            updatedAt: Date.now(),
+            gates: {
+              'release-candidate-contract-gates': {
+                passed: true,
+                updatedAt: Date.now(),
+              },
+            },
+          },
+          null,
+          2,
+        ),
+      );
+
+      await autopilot.start();
+      const healthyDecision = orchestrator.evaluate();
+      expect(healthyDecision.failures).toHaveLength(0);
+
+      fs.writeFileSync(
+        snapshotPath,
+        JSON.stringify(
+          {
+            schemaVersion: 1,
+            updatedAt: Date.now(),
+            gates: {
+              'release-candidate-contract-gates': {
+                passed: false,
+                reason: 'runtime compatibility drift',
+                updatedAt: Date.now(),
+              },
+            },
+          },
+          null,
+          2,
+        ),
+      );
+
+      await autopilot.syncOnce();
+      const rollbackDecision = orchestrator.evaluate();
+      expect(rollbackDecision.action).toBe('rollback');
+      expect(
+        rollbackDecision.failures.some(
+          item =>
+            item.reason === 'contract_gate_failed' &&
+            item.gate === 'release-candidate-contract-gates',
+        ),
+      ).toBe(true);
+    } finally {
+      autopilot.stop();
+      await registry.shutdown();
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test('fails stale gate snapshots without manual intervention', async () => {
+    const dir = makeTempDir();
+    const snapshotPath = path.join(dir, 'contract-gates.json');
+
+    const registry = new TelemetryRegistry({
+      service: 'svc',
+      module: 'server',
+      environment: 'test',
+      flushIntervalMs: 60_000,
+    });
+    const orchestrator = new TelemetryCanaryOrchestrator({
+      registry,
+      rollbackConsecutiveFailures: 1,
+    });
+
+    const staleUpdatedAt = Date.now() - 10_000;
+    fs.writeFileSync(
+      snapshotPath,
+      JSON.stringify(
+        {
+          schemaVersion: 1,
+          updatedAt: staleUpdatedAt,
+          gates: {
+            'module-onboarding-certification-gates': {
+              passed: true,
+              updatedAt: staleUpdatedAt,
+            },
+          },
+        },
+        null,
+        2,
+      ),
+    );
+
+    const autopilot = new ContractGateAutopilot({
+      orchestrator,
+      gateSnapshotPath: snapshotPath,
+      gateStaleAfterMs: 1_000,
+    });
+
+    try {
+      await autopilot.syncOnce();
+      const decision = orchestrator.evaluate();
+      expect(decision.action).toBe('rollback');
+      expect(
+        decision.failures.some(
+          item =>
+            item.reason === 'contract_gate_failed' &&
+            item.gate === 'module-onboarding-certification-gates',
+        ),
+      ).toBe(true);
+    } finally {
+      autopilot.stop();
+      await registry.shutdown();
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test('auto-recovers runtime fallback gates after expiry window', async () => {
+    const dir = makeTempDir();
+    const snapshotPath = path.join(dir, 'contract-gates.json');
+
+    const registry = new TelemetryRegistry({
+      service: 'svc',
+      module: 'server',
+      environment: 'test',
+      flushIntervalMs: 60_000,
+    });
+    const orchestrator = new TelemetryCanaryOrchestrator({
+      registry,
+      rollbackConsecutiveFailures: 1,
+    });
+    const now = Date.now();
+    fs.writeFileSync(
+      snapshotPath,
+      JSON.stringify(
+        {
+          schemaVersion: 1,
+          updatedAt: now,
+          gates: {
+            'runtime-mf-fallback-health': {
+              passed: false,
+              reason: 'runtime_fallback:remote_load_failed',
+              updatedAt: now - 1_000,
+              expiresAt: now - 100,
+            },
+          },
+        },
+        null,
+        2,
+      ),
+    );
+
+    const autopilot = new ContractGateAutopilot({
+      orchestrator,
+      gateSnapshotPath: snapshotPath,
+      gateStaleAfterMs: 60_000,
+    });
+
+    try {
+      await autopilot.syncOnce();
+      const decision = orchestrator.evaluate();
+      expect(decision.failures).toHaveLength(0);
+    } finally {
+      autopilot.stop();
+      await registry.shutdown();
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/tests/contractGateSnapshotStore.test.ts

@@ -0,0 +1,223 @@
+import fs from 'fs';
+import { createServer } from 'http';
+import os from 'os';
+import path from 'path';
+import {
+  type GateSnapshot,
+  resolveContractGateSnapshotStore,
+} from '../src/contractGateSnapshotStore';
+
+const makeTempAppDir = () =>
+  fs.mkdtempSync(path.join(os.tmpdir(), 'modern-gate-store-app-'));
+
+const STORE_MODULE_SOURCE = (storeName: string) => `'use strict';
+exports.createContractGateSnapshotStore = ({ gateSnapshotPath }) => {
+  let snapshot;
+  return {
+    name: ${JSON.stringify(storeName)},
+    async readSnapshot() {
+      return snapshot;
+    },
+    async writeSnapshot(next) {
+      snapshot = next;
+    },
+  };
+};
+`;
+
+describe('contract gate snapshot store', () => {
+  test('supports built-in http stateStore adapter', async () => {
+    let snapshot: GateSnapshot | undefined;
+
+    const server = createServer((req, res) => {
+      if (!req.url || req.url !== '/snapshot') {
+        res.statusCode = 404;
+        res.end();
+        return;
+      }
+
+      if (req.method === 'GET') {
+        if (!snapshot) {
+          res.statusCode = 404;
+          res.end();
+          return;
+        }
+
+        res.statusCode = 200;
+        res.setHeader('content-type', 'application/json');
+        res.end(JSON.stringify(snapshot));
+        return;
+      }
+
+      if (req.method === 'PUT') {
+        let body = '';
+        req.on('data', chunk => {
+          body += String(chunk);
+        });
+        req.on('end', () => {
+          snapshot = JSON.parse(body);
+          res.statusCode = 204;
+          res.end();
+        });
+        return;
+      }
+
+      res.statusCode = 405;
+      res.end();
+    });
+
+    await new Promise<void>(resolve => {
+      server.listen(0, '127.0.0.1', () => resolve());
+    });
+
+    const address = server.address();
+    const port = typeof address === 'object' && address ? address.port : 0;
+    const endpoint = `http://127.0.0.1:${String(port)}/snapshot`;
+
+    try {
+      const store = await resolveContractGateSnapshotStore({
+        appDirectory: process.cwd(),
+        gateSnapshotPath: '.modern/contract-gates.json',
+        stateStore: {
+          module: 'http',
+          options: {
+            endpoint,
+          },
+        },
+      });
+
+      expect(await store.readSnapshot()).toBeUndefined();
+
+      await store.writeSnapshot({
+        schemaVersion: 1,
+        updatedAt: Date.now(),
+        gates: {
+          'runtime-mf-fallback-health': {
+            passed: false,
+          },
+        },
+      });
+
+      const loaded = await store.readSnapshot();
+      expect(loaded?.gates?.['runtime-mf-fallback-health']).toEqual({
+        passed: false,
+      });
+    } finally {
+      await new Promise<void>((resolve, reject) => {
+        server.close(error => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      });
+    }
+  });
+
+  test('resolves relative stateStore modules against the app directory', async () => {
+    const appDirectory = makeTempAppDir();
+
+    try {
+      fs.mkdirSync(path.join(appDirectory, 'stores'), { recursive: true });
+      fs.writeFileSync(
+        path.join(appDirectory, 'stores', 'gate-store.js'),
+        STORE_MODULE_SOURCE('relative-store'),
+        'utf8',
+      );
+
+      const store = await resolveContractGateSnapshotStore({
+        appDirectory,
+        gateSnapshotPath: path.join(
+          appDirectory,
+          '.modern/contract-gates.json',
+        ),
+        stateStore: {
+          module: './stores/gate-store.js',
+        },
+      });
+
+      expect(store.name).toBe('relative-store');
+    } finally {
+      fs.rmSync(appDirectory, { recursive: true, force: true });
+    }
+  });
+
+  test('resolves bare-specifier stateStore modules from the app node_modules', async () => {
+    const appDirectory = makeTempAppDir();
+
+    try {
+      // Simulate a pnpm-style strict install: the store package exists only
+      // in the app's node_modules, never next to the framework package.
+      const packageDir = path.join(appDirectory, 'node_modules', 'gate-store');
+      fs.mkdirSync(packageDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(appDirectory, 'package.json'),
+        JSON.stringify({ name: 'test-app', private: true }),
+        'utf8',
+      );
+      fs.writeFileSync(
+        path.join(packageDir, 'package.json'),
+        JSON.stringify({
+          name: 'gate-store',
+          version: '1.0.0',
+          main: 'index.js',
+        }),
+        'utf8',
+      );
+      fs.writeFileSync(
+        path.join(packageDir, 'index.js'),
+        STORE_MODULE_SOURCE('bare-specifier-store'),
+        'utf8',
+      );
+
+      const store = await resolveContractGateSnapshotStore({
+        appDirectory,
+        gateSnapshotPath: path.join(
+          appDirectory,
+          '.modern/contract-gates.json',
+        ),
+        stateStore: {
+          module: 'gate-store',
+        },
+      });
+
+      expect(store.name).toBe('bare-specifier-store');
+
+      await store.writeSnapshot({
+        schemaVersion: 1,
+        updatedAt: Date.now(),
+        gates: { 'runtime-mf-fallback-health': { passed: false } },
+      });
+      const loaded = await store.readSnapshot();
+      expect(loaded?.gates?.['runtime-mf-fallback-health']).toEqual({
+        passed: false,
+      });
+    } finally {
+      fs.rmSync(appDirectory, { recursive: true, force: true });
+    }
+  });
+
+  test('reports a clear error when the stateStore module cannot be resolved', async () => {
+    const appDirectory = makeTempAppDir();
+
+    try {
+      await expect(
+        resolveContractGateSnapshotStore({
+          appDirectory,
+          gateSnapshotPath: path.join(
+            appDirectory,
+            '.modern/contract-gates.json',
+          ),
+          stateStore: {
+            module: 'definitely-missing-gate-store',
+          },
+        }),
+      ).rejects.toThrow(
+        /Failed to load stateStore\.module "definitely-missing-gate-store"/,
+      );
+    } finally {
+      fs.rmSync(appDirectory, { recursive: true, force: true });
+    }
+  });
+});

package/tests/env.test.ts

@@ -0,0 +1,73 @@
+import {
+  DEFAULT_ENVIRONMENT_NAME,
+  parseServerRuntimeExtensionsEnv,
+} from '../src/env';
+
+describe('parseServerRuntimeExtensionsEnv', () => {
+  test('applies documented defaults for an empty environment', () => {
+    const parsed = parseServerRuntimeExtensionsEnv({});
+
+    expect(parsed).toEqual({
+      modernEnv: undefined,
+      nodeEnv: undefined,
+      environmentName: DEFAULT_ENVIRONMENT_NAME,
+      contractGatesFile: undefined,
+    });
+  });
+
+  test('parses configured values and trims whitespace', () => {
+    const parsed = parseServerRuntimeExtensionsEnv({
+      MODERN_ENV: ' staging ',
+      NODE_ENV: 'production',
+      MODERN_CONTRACT_GATES_FILE: ' /var/run/gates.json ',
+    });
+
+    expect(parsed.modernEnv).toBe('staging');
+    expect(parsed.nodeEnv).toBe('production');
+    expect(parsed.environmentName).toBe('staging');
+    expect(parsed.contractGatesFile).toBe('/var/run/gates.json');
+  });
+
+  test('falls back from MODERN_ENV to NODE_ENV to the default', () => {
+    expect(
+      parseServerRuntimeExtensionsEnv({ NODE_ENV: 'production' })
+        .environmentName,
+    ).toBe('production');
+    expect(
+      parseServerRuntimeExtensionsEnv({
+        MODERN_ENV: 'preview',
+        NODE_ENV: 'production',
+      }).environmentName,
+    ).toBe('preview');
+    expect(parseServerRuntimeExtensionsEnv({}).environmentName).toBe(
+      DEFAULT_ENVIRONMENT_NAME,
+    );
+  });
+
+  test('treats blank strings as unset', () => {
+    const parsed = parseServerRuntimeExtensionsEnv({
+      MODERN_ENV: '   ',
+      MODERN_CONTRACT_GATES_FILE: '',
+    });
+
+    expect(parsed.modernEnv).toBeUndefined();
+    expect(parsed.contractGatesFile).toBeUndefined();
+    expect(parsed.environmentName).toBe(DEFAULT_ENVIRONMENT_NAME);
+  });
+
+  test('reads from process.env by default', () => {
+    const previous = process.env.MODERN_CONTRACT_GATES_FILE;
+    process.env.MODERN_CONTRACT_GATES_FILE = '/tmp/gates.json';
+    try {
+      expect(parseServerRuntimeExtensionsEnv().contractGatesFile).toBe(
+        '/tmp/gates.json',
+      );
+    } finally {
+      if (previous === undefined) {
+        delete process.env.MODERN_CONTRACT_GATES_FILE;
+      } else {
+        process.env.MODERN_CONTRACT_GATES_FILE = previous;
+      }
+    }
+  });
+});

package/tests/helpers.ts

@@ -0,0 +1,19 @@
+export function getDefaultConfig() {
+  return {
+    html: {},
+    output: {},
+    source: {},
+    tools: {},
+    server: {},
+    bff: {},
+    dev: {},
+    security: {},
+  };
+}
+
+export function getDefaultAppContext() {
+  return {
+    apiDirectory: '',
+    lambdaDirectory: '',
+  };
+}

package/tests/mfCache.test.ts

@@ -0,0 +1,150 @@
+import {
+  createDefaultPlugins,
+  createServerBase,
+  type ServerPlugin,
+} from '@modern-js/server-core';
+import { describe, expect, test } from '@rstest/core';
+import {
+  getRequestPathname,
+  injectMfAssetCacheHeadersPlugin,
+  isMfManifestAsset,
+  isMfRemoteEntryAsset,
+  resolveMfAssetCacheHeaders,
+} from '../src/mfCache';
+import { getDefaultAppContext, getDefaultConfig } from './helpers';
+
+describe('mf cache headers', () => {
+  test('detects MF manifest assets', () => {
+    expect(isMfManifestAsset('/mf-manifest.json')).toBe(true);
+    expect(isMfManifestAsset('/mf-stats.json')).toBe(true);
+    expect(isMfManifestAsset('/foo/bar.json')).toBe(false);
+  });
+
+  test('detects remoteEntry assets', () => {
+    expect(isMfRemoteEntryAsset('/remoteEntry.js')).toBe(true);
+    expect(isMfRemoteEntryAsset('/assets/remoteEntry.abc123.js')).toBe(true);
+    expect(isMfRemoteEntryAsset('/assets/index.js')).toBe(false);
+  });
+
+  test('resolves strict no-cache headers for MF manifest endpoints', () => {
+    const headers = resolveMfAssetCacheHeaders('/mf-manifest.json');
+    expect(headers).toEqual({
+      'cache-control': 'no-cache, no-store, must-revalidate',
+      pragma: 'no-cache',
+      expires: '0',
+    });
+  });
+
+  test('resolves revalidation cache policy for non-versioned remoteEntry', () => {
+    const headers = resolveMfAssetCacheHeaders('/remoteEntry.js');
+    expect(headers).toEqual({
+      'cache-control': 'public, max-age=0, must-revalidate',
+    });
+  });
+
+  test('resolves immutable cache policy for version-pinned remoteEntry', () => {
+    const headers = resolveMfAssetCacheHeaders('/remoteEntry.js', {
+      mfv: 'remote-v1',
+    });
+    expect(headers).toEqual({
+      'cache-control': 'public, max-age=31536000, immutable',
+    });
+  });
+
+  test('extracts pathname from full request URL', () => {
+    expect(
+      getRequestPathname('https://example.com/remoteEntry.js?mfv=remote-v1'),
+    ).toBe('/remoteEntry.js');
+  });
+});
+
+describe('injectMfAssetCacheHeadersPlugin', () => {
+  const createServerWithStubAssets = async () => {
+    const stubAssetsPlugin: ServerPlugin = {
+      name: 'stub-static-assets',
+      setup(api) {
+        api.onPrepare(() => {
+          const { middlewares } = api.getServerContext();
+          middlewares.push({
+            name: 'stub-static-assets',
+            handler: async (c: any) => {
+              const pathname = c.req.path as string;
+              if (pathname === '/missing/remoteEntry.js') {
+                return c.body('not found', 404);
+              }
+              if (pathname.endsWith('.json') || pathname.endsWith('.js')) {
+                return c.body('asset-body', 200);
+              }
+              return c.json({ ok: true });
+            },
+          });
+        });
+      },
+    };
+
+    const server = createServerBase({
+      config: getDefaultConfig(),
+      pwd: process.cwd(),
+      appContext: getDefaultAppContext(),
+    });
+    server.addPlugins([
+      ...createDefaultPlugins({ logger: false }),
+      injectMfAssetCacheHeadersPlugin(),
+      stubAssetsPlugin,
+    ]);
+    await server.init();
+    return server;
+  };
+
+  test('applies no-store policy to served MF manifests', async () => {
+    const server = await createServerWithStubAssets();
+
+    const response = await server.request('/mf-manifest.json', {}, {});
+    expect(response.status).toBe(200);
+    expect(response.headers.get('cache-control')).toBe(
+      'no-cache, no-store, must-revalidate',
+    );
+    expect(response.headers.get('pragma')).toBe('no-cache');
+    expect(response.headers.get('expires')).toBe('0');
+  });
+
+  test('applies revalidation policy to non-pinned remoteEntry assets', async () => {
+    const server = await createServerWithStubAssets();
+
+    const response = await server.request('/static/remoteEntry.js', {}, {});
+    expect(response.status).toBe(200);
+    expect(response.headers.get('cache-control')).toBe(
+      'public, max-age=0, must-revalidate',
+    );
+  });
+
+  test('applies immutable policy to version-pinned remoteEntry assets', async () => {
+    const server = await createServerWithStubAssets();
+
+    const response = await server.request(
+      '/static/remoteEntry.js?mfv=remote-v1',
+      {},
+      {},
+    );
+    expect(response.status).toBe(200);
+    expect(response.headers.get('cache-control')).toBe(
+      'public, max-age=31536000, immutable',
+    );
+  });
+
+  test('does not attach cache policies to error responses', async () => {
+    const server = await createServerWithStubAssets();
+
+    const response = await server.request('/missing/remoteEntry.js', {}, {});
+    expect(response.status).toBe(404);
+    expect(response.headers.get('cache-control')).toBeNull();
+  });
+
+  test('leaves non-MF assets untouched', async () => {
+    const server = await createServerWithStubAssets();
+
+    const response = await server.request('/static/js/app.js', {}, {});
+    expect(response.status).toBe(200);
+    expect(response.headers.get('cache-control')).toBeNull();
+  });
+});