@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

package/src/cloudflare/index.ts

@@ -1,4 +1,9 @@
 import path from 'node:path';
+import {
+  BACKEND_FEDERATION_MANIFEST_FILE,
+  BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
+  ULTRAMODERN_BUILD_ARTIFACT_FILE,
+} from '@modern-js/backend-federation-contracts';
 import { fs as fse } from '@modern-js/utils';
 import { createCloudflareOutputPlan } from '../cloudflare-output-plan';
 import { assertCloudflareOutput } from '../cloudflare-output-verifier/index';
@@ -22,9 +27,6 @@ import {
   ROUTE_SPEC_FILE,
   ROUTE_SPEC_OUTPUT,
   WORKER_BUNDLE_DIRECTORY,
-  WORKER_ENTRY,
-  WORKER_MANIFEST,
-  WRANGLER_CONFIG_FILE,
 } from './constants';
 import {
   resolveTopologyDeliveryUnit,
@@ -87,18 +89,14 @@ export const createCloudflarePreset: CreateCloudflarePreset = ({
     '@modern-js/ultramodern-release-envelope',
   );
   let hasReleaseEnvelope = false;
+  let declaredPublicAssets: string[] = [];
 
   return {
     async prepare() {
       await fse.remove(outputDirectory);
     },
     async writeOutput() {
-      if (
-        releaseEnvelopeEnabled &&
-        (await fse.pathExists(
-          path.join(distDirectory, MICROVERTICAL_RELEASE_ENVELOPE_PATH),
-        ))
-      ) {
+      if (releaseEnvelopeEnabled) {
         await emitFrameworkMicroVerticalReleaseEnvelope({
           apiOnly,
           distDirectory,
@@ -113,6 +111,20 @@ export const createCloudflarePreset: CreateCloudflarePreset = ({
           const relativePath = path
             .relative(distDirectory, src)
             .replace(/\\/gu, '/');
+          // API-only builds emit server modules at arbitrary paths under dist,
+          // including transitive imports outside api/. Only the framework's
+          // published backend contract belongs beside the explicit public tree.
+          if (
+            apiOnly &&
+            relativePath !== '' &&
+            ![
+              BACKEND_FEDERATION_MANIFEST_FILE,
+              BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
+              ULTRAMODERN_BUILD_ARTIFACT_FILE,
+            ].includes(relativePath)
+          ) {
+            return false;
+          }
           return (
             relativePath !== 'release' &&
             !relativePath.startsWith('release/') &&
@@ -173,9 +185,9 @@ export const createCloudflarePreset: CreateCloudflarePreset = ({
         outputDirectory,
         cloudflareArtifacts,
       );
-      await copyCloudflarePublicAssets(
+      declaredPublicAssets = await copyCloudflarePublicAssets(
         appDirectory,
-        publicDirectory,
+        outputDirectory,
         getCloudflarePublicAssets(modernConfig),
       );
       await copyCloudflareD1Migrations(
@@ -241,6 +253,7 @@ export const createCloudflarePreset: CreateCloudflarePreset = ({
       });
       if (hasReleaseEnvelope) {
         await emitCloudflareStagedReleaseEnvelope({
+          declaredPublicAssets,
           distDirectory,
           outputDirectory,
         });

package/src/cloudflare/worker-manifest.ts

@@ -1,5 +1,7 @@
 import path from 'node:path';
+import type {} from '@modern-js/server-runtime-extensions/server-config';
 import { fs as fse } from '@modern-js/utils';
+import { getCloudflareWorkerRouteDataEntryName } from '../cloudflare-output-contract';
 import { readRouteSpec } from './artifacts';
 import {
   ASSETS_BINDING,
@@ -131,6 +133,15 @@ export const createWorkerManifest = async (
     routeSpec.routes.map(async (route: Record<string, any>) => {
       const worker =
         typeof route.worker === 'string' ? route.worker : undefined;
+      const routeDataWorker =
+        route.isSSR && typeof route.entryName === 'string'
+          ? `${WORKER_BUNDLE_DIRECTORY}/${getCloudflareWorkerRouteDataEntryName(
+              route.entryName,
+            )}.js`
+          : undefined;
+      const hasRouteDataWorker = routeDataWorker
+        ? await fse.pathExists(path.join(outputDirectory, routeDataWorker))
+        : false;
 
       return {
         urlPath: route.urlPath,
@@ -141,6 +152,7 @@ export const createWorkerManifest = async (
         workerExists: worker
           ? await fse.pathExists(path.join(outputDirectory, worker))
           : false,
+        ...(hasRouteDataWorker ? { routeDataWorker } : {}),
       };
     }),
   );
@@ -217,9 +229,14 @@ export const createWorkerModuleLoaders = (manifest: any) => {
   const imports = new Map<string, string>();
 
   for (const route of manifest.routeSpec.routes) {
-    if (route.worker && route.workerExists) {
-      const importPath = `../${String(route.worker).replace(/^\/+/u, '')}`;
-      imports.set(route.worker, `() => import(${JSON.stringify(importPath)})`);
+    for (const worker of [
+      route.workerExists ? route.worker : undefined,
+      route.routeDataWorker,
+    ]) {
+      if (worker) {
+        const importPath = `../${String(worker).replace(/^\/+/u, '')}`;
+        imports.set(worker, `() => import(${JSON.stringify(importPath)})`);
+      }
     }
   }
 

package/src/cloudflare/wrangler-config.ts

@@ -15,21 +15,51 @@ import {
 import type { CloudflareModernConfig } from './types';
 import { isJsonRecord, normalizeRelativePath } from './utils';
 
-const getCompatibilityDate = (modernConfig: CloudflareModernConfig) => {
-  const configuredDate = modernConfig.deploy?.worker?.compatibilityDate?.trim();
-  const compatibilityDate = configuredDate || DEFAULT_COMPATIBILITY_DATE;
-
+// Workers only add Node.js built-ins at later dates, and the bundler
+// externalizes the set probed at DEFAULT_COMPATIBILITY_DATE; an earlier date
+// could leave an externalized built-in unresolvable at deploy time.
+const assertSupportedCompatibilityDate = (
+  compatibilityDate: JsonValue | undefined,
+  label: string,
+) => {
+  if (typeof compatibilityDate !== 'string') {
+    throw new Error(`${label} must be a YYYY-MM-DD string.`);
+  }
   if (!COMPATIBILITY_DATE_PATTERN.test(compatibilityDate)) {
     throw new Error(
-      `deploy.worker.compatibilityDate must use YYYY-MM-DD, received ${JSON.stringify(
+      `${label} must use YYYY-MM-DD, received ${JSON.stringify(
+        compatibilityDate,
+      )}.`,
+    );
+  }
+  if (compatibilityDate < DEFAULT_COMPATIBILITY_DATE) {
+    throw new Error(
+      `${label} must be ${DEFAULT_COMPATIBILITY_DATE} or later, the date the Cloudflare worker Node.js built-in contract is verified against; received ${JSON.stringify(
         compatibilityDate,
       )}.`,
     );
   }
-
   return compatibilityDate;
 };
 
+const getCompatibilityDate = (
+  modernConfig: CloudflareModernConfig,
+  wranglerCompatibilityDate: JsonValue | undefined,
+) => {
+  if (wranglerCompatibilityDate !== undefined) {
+    // A raw Wrangler override is the effective date, so it is validated too.
+    return assertSupportedCompatibilityDate(
+      wranglerCompatibilityDate,
+      'deploy.worker.wrangler.compatibility_date',
+    );
+  }
+  return assertSupportedCompatibilityDate(
+    modernConfig.deploy?.worker?.compatibilityDate?.trim() ||
+      DEFAULT_COMPATIBILITY_DATE,
+    'deploy.worker.compatibilityDate',
+  );
+};
+
 const getWorkerName = (appDirectory: string) => {
   const basename = path.basename(appDirectory);
   return basename.replace(/[^a-zA-Z0-9-_]/g, '-') || 'modern-cloudflare-worker';
@@ -59,6 +89,7 @@ const getConfiguredWrangler = (modernConfig: CloudflareModernConfig) => {
 
 const createWranglerCompatibilityFlags = (
   configuredFlags: JsonValue | undefined,
+  label = 'deploy.worker.wrangler.compatibility_flags',
 ) => {
   if (configuredFlags === undefined) {
     return [...REQUIRED_COMPATIBILITY_FLAGS];
@@ -68,14 +99,54 @@ const createWranglerCompatibilityFlags = (
     !Array.isArray(configuredFlags) ||
     configuredFlags.some(flag => typeof flag !== 'string')
   ) {
-    throw new Error(
-      'deploy.worker.wrangler.compatibility_flags must be an array of strings.',
-    );
+    throw new Error(`${label} must be an array of strings.`);
   }
 
   return [...new Set([...configuredFlags, ...REQUIRED_COMPATIBILITY_FLAGS])];
 };
 
+// `wrangler deploy --env <name>` uses an environment's own compatibility_date
+// and compatibility_flags instead of the top-level values, so each override
+// is held to the same verified date floor and required flags.
+const createWranglerEnvironments = (wranglerEnv: JsonValue | undefined) => {
+  if (wranglerEnv === undefined) {
+    return undefined;
+  }
+  if (!isJsonRecord(wranglerEnv)) {
+    throw new Error('deploy.worker.wrangler.env must be an object.');
+  }
+  return Object.fromEntries(
+    Object.entries(wranglerEnv).map(([name, environment]) => {
+      const label = `deploy.worker.wrangler.env.${name}`;
+      if (!isJsonRecord(environment)) {
+        throw new Error(`${label} must be an object.`);
+      }
+      return [
+        name,
+        {
+          ...environment,
+          ...(environment.compatibility_date === undefined
+            ? {}
+            : {
+                compatibility_date: assertSupportedCompatibilityDate(
+                  environment.compatibility_date,
+                  `${label}.compatibility_date`,
+                ),
+              }),
+          ...(environment.compatibility_flags === undefined
+            ? {}
+            : {
+                compatibility_flags: createWranglerCompatibilityFlags(
+                  environment.compatibility_flags,
+                  `${label}.compatibility_flags`,
+                ),
+              }),
+        },
+      ];
+    }),
+  );
+};
+
 const createWranglerAssetsConfig = (
   configuredAssets: JsonValue | undefined,
 ) => {
@@ -312,6 +383,7 @@ export const createWranglerConfig = (
   modernConfig: CloudflareModernConfig,
 ) => {
   const wrangler = getConfiguredWrangler(modernConfig);
+  const environments = createWranglerEnvironments(wrangler.env);
   const d1Databases = createWranglerD1Databases(
     modernConfig,
     wrangler.d1_databases,
@@ -325,13 +397,17 @@ export const createWranglerConfig = (
   return {
     $schema: 'node_modules/wrangler/config-schema.json',
     name: getConfiguredWorkerName(appDirectory, modernConfig),
-    compatibility_date: getCompatibilityDate(modernConfig),
     ...wrangler,
+    compatibility_date: getCompatibilityDate(
+      modernConfig,
+      wrangler.compatibility_date,
+    ),
     main: WORKER_ENTRY,
     compatibility_flags: createWranglerCompatibilityFlags(
       wrangler.compatibility_flags,
     ),
     assets: createWranglerAssetsConfig(wrangler.assets),
+    ...(environments === undefined ? {} : { env: environments }),
     ...(d1Databases === undefined ? {} : { d1_databases: d1Databases }),
     ...(wranglerServices === undefined ? {} : { services: wranglerServices }),
   };