@bleedingdev/modern-js-create 3.5.0-ultramodern.9 → 3.5.0-ultramodern.90

package/templates/workspace-scripts/ultramodern-cloudflare-proof.mjs

@@ -20,8 +20,8 @@ function resolveModuleFederationPublicPath(publicPath, manifestUrl) {
   }
 }
 
-async function fetchText(url) {
-  const response = await fetch(url);
+async function fetchText(url, init) {
+  const response = await fetch(url, init);
   return {
     ok: response.ok,
     status: response.status,
@@ -48,6 +48,52 @@ function parseMaybeJson(body) {
   }
 }
 
+function jsonPathValue(value, path) {
+  const segments = String(path ?? '')
+    .split('.')
+    .filter(Boolean);
+  let current = value;
+
+  for (const segment of segments) {
+    if (current === null || current === undefined) {
+      return undefined;
+    }
+
+    if (Array.isArray(current) && /^\d+$/u.test(segment)) {
+      current = current[Number(segment)];
+      continue;
+    }
+
+    if (typeof current === 'object' && Object.hasOwn(current, segment)) {
+      current = current[segment];
+      continue;
+    }
+
+    return undefined;
+  }
+
+  return current;
+}
+
+function jsonValuesEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+function normalizeJsonSmokeExpectations(check) {
+  if (Array.isArray(check.expectations)) {
+    return check.expectations;
+  }
+
+  if (check.expect && typeof check.expect === 'object') {
+    return Object.entries(check.expect).map(([path, equals]) => ({
+      path,
+      equals,
+    }));
+  }
+
+  return [];
+}
+
 function markerFromJson(value) {
   if (!value || typeof value !== 'object') {
     return undefined;
@@ -687,6 +733,27 @@ function validateUiMarkerEvidence(evidence, app, ssr) {
     status: uiMarker === app.marker?.build ? 'pass' : 'fail',
   });
   assert(uiMarker === app.marker?.build, `${app.id} UI marker mismatch`);
+
+  if (app.deliveryUnit) {
+    evidence.assertions.push({
+      type: 'delivery-unit-ui-marker',
+      unitId: app.deliveryUnit.unitId,
+      expected: app.deliveryUnit.surfaces?.ui?.buildMarker ?? app.deliveryUnit.buildMarker,
+      actual: uiMarker,
+      status:
+        uiMarker === (app.deliveryUnit.surfaces?.ui?.buildMarker ?? app.deliveryUnit.buildMarker)
+          ? 'pass'
+          : 'fail',
+    });
+    assert(
+      uiMarker !== undefined,
+      `${app.id} delivery unit ${app.deliveryUnit.unitId} is declared but SSR response is missing its build marker`,
+    );
+    assert(
+      uiMarker === (app.deliveryUnit.surfaces?.ui?.buildMarker ?? app.deliveryUnit.buildMarker),
+      `${app.id} delivery unit ${app.deliveryUnit.unitId} UI surface build marker mismatch`,
+    );
+  }
 }
 
 function validateCssRootMarkerEvidence(evidence, app, ssr) {
@@ -857,6 +924,123 @@ async function validateReadinessEvidence(evidence, app, publicUrl, routes) {
       `${app.id} Effect readiness returned HTTP ${readiness.status}`,
     );
     assert(apiMarker === app.marker?.build, `${app.id} API marker mismatch`);
+
+    if (app.deliveryUnit) {
+      evidence.assertions.push({
+        type: 'delivery-unit-api-marker',
+        route: routes.apiReadiness,
+        unitId: app.deliveryUnit.unitId,
+        expected: app.deliveryUnit.buildMarker,
+        actual: apiMarker,
+        status: apiMarker === app.deliveryUnit.buildMarker ? 'pass' : 'fail',
+      });
+      assert(
+        apiMarker !== undefined,
+        `${app.id} delivery unit ${app.deliveryUnit.unitId} is declared but readiness response is missing its build marker`,
+      );
+      assert(
+        apiMarker === app.deliveryUnit.buildMarker,
+        `${app.id} delivery unit ${app.deliveryUnit.unitId} API surface build marker mismatch`,
+      );
+    }
+  }
+}
+
+async function validateServiceBindingEvidence(evidence, app, publicUrl) {
+  const serviceBindings = app.deploy?.cloudflare?.serviceBindings ?? [];
+
+  for (const binding of serviceBindings) {
+    const response = await fetchText(joinUrl(publicUrl, binding.route));
+    const responseJson = parseMaybeJson(response.body);
+    const apiMarker = markerFromJson(responseJson);
+    const passed = response.ok && apiMarker === binding.expectedMarker;
+
+    evidence.assertions.push({
+      type: 'service-binding-api-marker',
+      appId: binding.appId,
+      binding: binding.binding,
+      route: binding.route,
+      expected: binding.expectedMarker,
+      actual: apiMarker,
+      status: passed ? 'pass' : 'fail',
+      statusCode: response.status,
+    });
+    assert(
+      response.ok,
+      `${app.id} service binding ${binding.binding} returned HTTP ${response.status}`,
+    );
+    assert(
+      apiMarker === binding.expectedMarker,
+      `${app.id} service binding ${binding.binding} API marker mismatch`,
+    );
+  }
+}
+
+async function validateJsonSmokeEvidence(evidence, app, publicUrl) {
+  const checks = app.deploy?.cloudflare?.jsonSmokeChecks ?? [];
+
+  for (const check of checks) {
+    const route = check.route;
+    assert(
+      typeof route === 'string' && route.length > 0,
+      `${app.id} JSON smoke check is missing a route`,
+    );
+
+    const method = String(check.method ?? 'GET').toUpperCase();
+    const requestBody =
+      check.body ?? check.payload ?? check.requestBody ?? undefined;
+    const response = await fetchText(joinUrl(publicUrl, route), {
+      method,
+      headers: {
+        accept: 'application/json',
+        ...(requestBody === undefined
+          ? {}
+          : { 'content-type': 'application/json' }),
+      },
+      ...(requestBody === undefined
+        ? {}
+        : { body: JSON.stringify(requestBody) }),
+    });
+    const responseJson = parseMaybeJson(response.body);
+    const checkId = check.id ?? route;
+
+    evidence.assertions.push({
+      type: 'json-smoke-http',
+      id: checkId,
+      method,
+      route,
+      status: response.ok && responseJson !== undefined ? 'pass' : 'fail',
+      statusCode: response.status,
+    });
+    assert(
+      response.ok,
+      `${app.id} JSON smoke ${checkId} returned HTTP ${response.status}`,
+    );
+    assert(
+      responseJson !== undefined,
+      `${app.id} JSON smoke ${checkId} did not return JSON`,
+    );
+
+    for (const expectation of normalizeJsonSmokeExpectations(check)) {
+      const actual = jsonPathValue(responseJson, expectation.path);
+      const passed = jsonValuesEqual(actual, expectation.equals);
+
+      evidence.assertions.push({
+        type: 'json-smoke-value',
+        id: checkId,
+        route,
+        path: expectation.path,
+        expected: expectation.equals,
+        actual,
+        status: passed ? 'pass' : 'fail',
+      });
+      assert(
+        passed,
+        `${app.id} JSON smoke ${checkId} expected ${expectation.path} to equal ${JSON.stringify(
+          expectation.equals,
+        )}`,
+      );
+    }
   }
 }
 
@@ -869,6 +1053,8 @@ async function validateApp(app, publicUrl) {
   await validateModuleFederationManifestEvidence(evidence, app, publicUrl, routes);
   await validateI18nEvidence(evidence, app, publicUrl, routes);
   await validateReadinessEvidence(evidence, app, publicUrl, routes);
+  await validateServiceBindingEvidence(evidence, app, publicUrl);
+  await validateJsonSmokeEvidence(evidence, app, publicUrl);
 
   return evidence;
 }

package/templates/workspace-scripts/ultramodern-typecheck.mjs

@@ -1,16 +1,11 @@
 #!/usr/bin/env node
 
 import { spawnSync } from 'node:child_process';
-import {
-  accessSync,
-  chmodSync,
-  constants,
-  existsSync,
-  mkdirSync,
-} from 'node:fs';
+import { mkdirSync } from 'node:fs';
 import os from 'node:os';
 import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { resolveEffectTsgoCompiler } from '@modern-js/app-tools/config';
 
 const args = process.argv.slice(2);
 const workspaceRoot = process.env.ULTRAMODERN_WORKSPACE_ROOT
@@ -108,33 +103,6 @@ function readArgs() {
   };
 }
 
-function resolveTsgoBinary() {
-  const explicitBinary = process.env.EFFECT_TSGO_BIN || process.env.TSGO_BIN;
-  if (explicitBinary) {
-    return explicitBinary;
-  }
-
-  const cli = process.env.EFFECT_TSGO_CLI || 'effect-tsgo';
-  const result = spawnSync(cli, ['get-exe-path'], {
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  if (result.error) {
-    fail(
-      `Unable to run ${cli}. Run pnpm install or set EFFECT_TSGO_BIN to the native-preview tsgo binary.`,
-    );
-  }
-  if (result.status !== 0) {
-    fail(
-      result.stderr?.trim() ||
-        `${cli} get-exe-path exited with status ${result.status}.`,
-    );
-  }
-
-  return result.stdout.trim() || cli;
-}
-
 const parsed = readArgs();
 const defaultBuilders = Math.min(8, Math.max(1, Math.floor(cpuCount / 2)));
 const builders =
@@ -147,17 +115,9 @@ const defaultCheckers =
 const checkers =
   parsed.checkers ??
   envPositiveInt('ULTRAMODERN_TSGO_CHECKERS', defaultCheckers);
-const tsgoBin = resolveTsgoBinary();
-
-if (!existsSync(tsgoBin)) {
-  fail(`TS-Go binary not found at ${tsgoBin}. Run pnpm install.`);
-}
-
-try {
-  accessSync(tsgoBin, constants.X_OK);
-} catch {
-  chmodSync(tsgoBin, 0o755);
-}
+const tsgoBin = resolveEffectTsgoCompiler({
+  from: pathToFileURL(join(workspaceRoot, 'package.json')),
+});
 
 mkdirSync(join(workspaceRoot, 'node_modules/.cache/tsgo'), {
   recursive: true,