Fallback to workerd compatibility date (#395)

* Remove `runtimeBinaryPath` parameter from `RuntimeConstructor`

This will always be the `default` export from `workerd`, so we may as
well fold it in.

* Fallback to latest supported `compatibilityDate`

...if a user selects a `compatibilityDate` that isn't supported by
the currently installed version of `workerd`, but not in the future.

Author: mrbbot

package-lock.json

@@ -44,7 +44,7 @@
     "kleur": "^4.1.5",
     "stoppable": "^1.1.0",
     "undici": "^5.10.0",
-    "workerd": "^1.20220926.0",
+    "workerd": "^1.20220926.3",
     "zod": "^3.18.0"
   },
   "devDependencies": {

packages/tre/package.json

@@ -6,7 +6,6 @@ import { bold, green, grey } from "kleur/colors";
 import stoppable from "stoppable";
 import { RequestInfo, RequestInit, fetch } from "undici";
 import { HeadersInit, Request, Response } from "undici";
-import workerd from "workerd";
 import { z } from "zod";
 import { setupCf } from "./cf";
 
@@ -217,11 +216,7 @@ export class Miniflare {
     const entryPort = await getPort({ port: this.#sharedOpts.core.port });
 
     // TODO: respect entry `host` option
-    this.#runtime = new this.#runtimeConstructor(
-      workerd,
-      entryPort,
-      loopbackPort
-    );
+    this.#runtime = new this.#runtimeConstructor(entryPort, loopbackPort);
     this.#removeRuntimeExitHook = exitHook(() => void this.#runtime?.dispose());
 
     this.#runtimeEntryURL = new URL(`http://127.0.0.1:${entryPort}`);

packages/tre/src/index.ts

@@ -1,9 +1,16 @@
 import { readFileSync } from "fs";
 import fs from "fs/promises";
+import { bold, yellow } from "kleur/colors";
 import { Request, Response } from "undici";
 import { z } from "zod";
-import { Service, Worker_Binding, Worker_Module, kVoid } from "../../runtime";
-import { Awaitable, JsonSchema } from "../../shared";
+import {
+  Service,
+  Worker_Binding,
+  Worker_Module,
+  kVoid,
+  supportedCompatibilityDate,
+} from "../../runtime";
+import { Awaitable, JsonSchema, MiniflareCoreError } from "../../shared";
 import { BINDING_SERVICE_LOOPBACK, Plugin } from "../shared";
 import {
   ModuleDefinitionSchema,
@@ -13,6 +20,8 @@ import {
   convertModuleDefinition,
 } from "./modules";
 
+const numericCompare = new Intl.Collator(undefined, { numeric: true }).compare;
+
 // (request: Request) => Awaitable<Response>
 export const ServiceFetch = z
   .function()
@@ -99,8 +108,46 @@ export const SCRIPT_CUSTOM_SERVICE = `addEventListener("fetch", (event) => {
   event.respondWith(${BINDING_SERVICE_LOOPBACK}.fetch(request));
 })`;
 
+const now = new Date();
+const CURRENT_COMPATIBILITY_DATE = [
+  now.getFullYear(),
+  (now.getMonth() + 1).toString().padStart(2, "0"),
+  now.getDate().toString().padStart(2, "0"),
+].join("-");
+
 const FALLBACK_COMPATIBILITY_DATE = "2000-01-01";
 
+function validateCompatibilityDate(compatibilityDate: string) {
+  if (numericCompare(compatibilityDate, CURRENT_COMPATIBILITY_DATE) > 0) {
+    // If this compatibility date is in the future, throw
+    throw new MiniflareCoreError(
+      "ERR_FUTURE_COMPATIBILITY_DATE",
+      `Compatibility date "${compatibilityDate}" is in the future and unsupported`
+    );
+  } else if (
+    numericCompare(compatibilityDate, supportedCompatibilityDate) > 0
+  ) {
+    // If this compatibility date is greater than the maximum supported
+    // compatibility date of the runtime, but not in the future, warn,
+    // and use the maximum supported date instead
+    console.warn(
+      yellow(
+        [
+          "The newest compatibility date supported by the installed version of the Cloudflare Workers Runtime is ",
+          bold(`"${supportedCompatibilityDate}"`),
+          ",\nbut you've requested ",
+          bold(`"${compatibilityDate}"`),
+          ". Falling back to ",
+          bold(`"${supportedCompatibilityDate}"`),
+          "...",
+        ].join("")
+      )
+    );
+    return supportedCompatibilityDate;
+  }
+  return compatibilityDate;
+}
+
 export const CORE_PLUGIN: Plugin<
   typeof CoreOptionsSchema,
   typeof CoreSharedOptionsSchema
@@ -187,13 +234,15 @@ export const CORE_PLUGIN: Plugin<
     if (workerScript !== undefined) {
       const name = getUserServiceName(options.name);
       const classNames = durableObjectClassNames.get(name) ?? [];
+      const compatibilityDate = validateCompatibilityDate(
+        options.compatibilityDate ?? FALLBACK_COMPATIBILITY_DATE
+      );
 
       services.push({
         name,
         worker: {
           ...workerScript,
-          compatibilityDate:
-            options.compatibilityDate ?? FALLBACK_COMPATIBILITY_DATE,
+          compatibilityDate,
           compatibilityFlags: options.compatibilityFlags,
           bindings: workerBindings,
           durableObjectNamespaces: classNames.map((className) => ({

packages/tre/src/plugins/core/index.ts

@@ -3,12 +3,14 @@ import crypto from "crypto";
 import fs from "fs";
 import os from "os";
 import path from "path";
+import workerdPath, {
+  compatibilityDate as supportedCompatibilityDate,
+} from "workerd";
 import { SERVICE_LOOPBACK, SOCKET_ENTRY } from "../plugins";
 import { Awaitable, MiniflareCoreError } from "../shared";
 
 export abstract class Runtime {
   constructor(
-    protected readonly runtimeBinaryPath: string,
     protected readonly entryPort: number,
     protected readonly loopbackPort: number
   ) {}
@@ -19,11 +21,7 @@ export abstract class Runtime {
 }
 
 export interface RuntimeConstructor {
-  new (
-    runtimeBinaryPath: string,
-    entryPort: number,
-    loopbackPort: number
-  ): Runtime;
+  new (entryPort: number, loopbackPort: number): Runtime;
 
   isSupported(): boolean;
   supportSuggestion: string;
@@ -77,20 +75,16 @@ class NativeRuntime extends Runtime {
   #process?: childProcess.ChildProcess;
   #processExitPromise?: Promise<void>;
 
-  constructor(
-    runtimeBinaryPath: string,
-    entryPort: number,
-    loopbackPort: number
-  ) {
-    super(runtimeBinaryPath, entryPort, loopbackPort);
+  constructor(entryPort: number, loopbackPort: number) {
+    super(entryPort, loopbackPort);
     const [command, ...args] = this.getCommand();
     this.#command = command;
     this.#args = args;
   }
 
   getCommand(): string[] {
     return [
-      this.runtimeBinaryPath,
+      workerdPath,
       ...COMMON_RUNTIME_ARGS,
       `--socket-addr=${SOCKET_ENTRY}=127.0.0.1:${this.entryPort}`,
       `--external-addr=${SERVICE_LOOPBACK}=127.0.0.1:${this.loopbackPort}`,
@@ -188,7 +182,7 @@ class DockerRuntime extends Runtime {
         "--interactive",
         "--rm",
         `--volume=${RESTART_PATH}:/restart.sh`,
-        `--volume=${this.runtimeBinaryPath}:/runtime`,
+        `--volume=${workerdPath}:/runtime`,
         `--volume=${this.#configPath}:/miniflare-config.bin`,
         `--publish=127.0.0.1:${this.entryPort}:8787`,
         "debian:bullseye-slim",
@@ -251,3 +245,4 @@ export function getSupportedRuntime(): RuntimeConstructor {
 }
 
 export * from "./config";
+export { supportedCompatibilityDate };

packages/tre/src/runtime/index.ts

@@ -18,7 +18,8 @@ export type MiniflareCoreErrorCode =
   | "ERR_MODULE_STRING_SCRIPT" // Attempt to resolve module within string script
   | "ERR_MODULE_DYNAMIC_SPEC" // Attempted to import/require a module without a literal spec
   | "ERR_MODULE_RULE" // No matching module rule for file
-  | "ERR_PERSIST_UNSUPPORTED"; // Unsupported storage persistence protocol
+  | "ERR_PERSIST_UNSUPPORTED" // Unsupported storage persistence protocol
+  | "ERR_FUTURE_COMPATIBILITY_DATE"; // Compatibility date in the future
 export class MiniflareCoreError extends MiniflareError<MiniflareCoreErrorCode> {}
 
 export class HttpError extends MiniflareError<number> {

packages/tre/src/shared/error.ts

@@ -1,4 +1,5 @@
 declare module "workerd" {
   const path: string;
   export default path;
+  export const compatibilityDate: string;
 }