expose preventEviction as unsafePreventEviction for Durable Objects

packages/miniflare/src/index.ts

@@ -269,6 +269,7 @@ function getDurableObjectClassNames(
  // Fallback to current worker service if name not defined
  serviceName = workerServiceName,
  unsafeUniqueKey,
+ unsafePreventEviction,
  } = normaliseDurableObject(designator);
  // Get or create `Map` mapping class name to optional unsafe unique key
  let classNames = serviceClassNames.get(serviceName);
@@ -278,19 +279,27 @@ function getDurableObjectClassNames(
  }
  if (classNames.has(className)) {
  // If we've already seen this class in this service, make sure the
- // unsafe unique keys match
- const existingUnsafeUniqueKey = classNames.get(className);
- if (existingUnsafeUniqueKey !== unsafeUniqueKey) {
+ // unsafe unique keys and unsafe prevent eviction values match
+ const existingInfo = classNames.get(className);
+ if (existingInfo?.unsafeUniqueKey !== unsafeUniqueKey) {
  throw new MiniflareCoreError(
  "ERR_DIFFERENT_UNIQUE_KEYS",
  `Multiple unsafe unique keys defined for Durable Object "${className}" in "${serviceName}": ${JSON.stringify(
  unsafeUniqueKey
- )} and ${JSON.stringify(existingUnsafeUniqueKey)}`
+ )} and ${JSON.stringify(existingInfo?.unsafeUniqueKey)}`
+ );
+ }
+ if (existingInfo?.unsafePreventEviction !== unsafePreventEviction) {
+ throw new MiniflareCoreError(
+ "ERR_DIFFERENT_PREVENT_EVICTION",
+ `Multiple unsafe prevent eviction values defined for Durable Object "${className}" in "${serviceName}": ${JSON.stringify(
+ unsafePreventEviction
+ )} and ${JSON.stringify(existingInfo?.unsafePreventEviction)}`
  );
  }
  } else {
  // Otherwise, just add it
- classNames.set(className, unsafeUniqueKey);
+ classNames.set(className, { unsafeUniqueKey, unsafePreventEviction });
  }
  }
  }

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

@@ -424,14 +424,15 @@ export const CORE_PLUGIN: Plugin<
  compatibilityFlags: options.compatibilityFlags,
  bindings: workerBindings,
  durableObjectNamespaces: classNamesEntries.map(
- ([className, unsafeUniqueKey]) => {
+ ([className, { unsafeUniqueKey, unsafePreventEviction }]) => {
  return {
  className,
  // This `uniqueKey` will (among other things) be used as part of the
  // path when persisting to the file-system. `-` is invalid in
  // JavaScript class names, but safe on filesystems (incl. Windows).
  uniqueKey:
  unsafeUniqueKey ?? `${options.name ?? ""}-${className}`,
+ preventEviction: unsafePreventEviction,
  };
  }
  ),

packages/miniflare/src/plugins/do/index.ts

@@ -22,6 +22,8 @@ export const DurableObjectsOptionsSchema = z.object({
  // another `workerd` process, to ensure the IDs created by the stub
  // object can be used by the real object too.
  unsafeUniqueKey: z.string().optional(),
+ // Prevents the Durable Object being evicted.
+ unsafePreventEviction: z.boolean().optional(),
  }),
  ])
  )
@@ -35,15 +37,23 @@ export function normaliseDurableObject(
  designator: NonNullable<
  z.infer<typeof DurableObjectsOptionsSchema>["durableObjects"]
  >[string]
-): { className: string; serviceName?: string; unsafeUniqueKey?: string } {
+): {
+ className: string;
+ serviceName?: string;
+ unsafeUniqueKey?: string;
+ unsafePreventEviction?: boolean;
+} {
  const isObject = typeof designator === "object";
  const className = isObject ? designator.className : designator;
  const serviceName =
  isObject && designator.scriptName !== undefined
  ? getUserServiceName(designator.scriptName)
  : undefined;
  const unsafeUniqueKey = isObject ? designator.unsafeUniqueKey : undefined;
- return { className, serviceName, unsafeUniqueKey };
+ const unsafePreventEviction = isObject
+ ? designator.unsafePreventEviction
+ : undefined;
+ return { className, serviceName, unsafeUniqueKey, unsafePreventEviction };
 }
 
 export const DURABLE_OBJECTS_PLUGIN_NAME = "do";

packages/miniflare/src/plugins/shared/index.ts

@@ -16,7 +16,13 @@ export type Persistence = z.infer<typeof PersistenceSchema>;
 // Maps **service** names to the Durable Object class names exported by them
 export type DurableObjectClassNames = Map<
  string,
- Map</* className */ string, /* unsafeUniqueKey */ string | undefined>
+ Map<
+ /* className */ string,
+ {
+ unsafeUniqueKey?: string;
+ unsafePreventEviction?: boolean;
+ }
+ >
 >;
 
 // Maps queue names to the Worker that wishes to consume it. Note each queue

packages/miniflare/src/shared/error.ts

@@ -25,5 +25,6 @@ export type MiniflareCoreErrorCode =
  | "ERR_VALIDATION" // Options failed to parse
  | "ERR_DUPLICATE_NAME" // Multiple workers defined with same name
  | "ERR_DIFFERENT_UNIQUE_KEYS" // Multiple Durable Object bindings declared for same class with different unsafe unique keys
+ | "ERR_DIFFERENT_PREVENT_EVICTION" // Multiple Durable Object bindings declared for same class with different unsafe prevent eviction values
  | "ERR_MULTIPLE_OUTBOUNDS"; // Both `outboundService` and `fetchMock` specified
 export class MiniflareCoreError extends MiniflareError<MiniflareCoreErrorCode> {}

packages/miniflare/test/plugins/do/index.spec.ts

@@ -1,6 +1,7 @@
 import assert from "assert";
 import fs from "fs/promises";
 import path from "path";
+import { setTimeout } from "timers/promises";
 import test from "ava";
 import {
  DeferredPromise,
@@ -33,6 +34,24 @@ export default {
  },
 };`;
 
+const STATEFUL_SCRIPT = (responsePrefix = "") => `
+ export class DurableObject {
+ constructor() {
+ this.uuid = crypto.randomUUID();
+ }
+ fetch() {
+ return new Response(${JSON.stringify(responsePrefix)} + this.uuid);
+ }
+ }
+ export default {
+ fetch(req, env, ctx) {
+ const singleton = env.DURABLE_OBJECT.idFromName("");
+ const durableObject = env.DURABLE_OBJECT.get(singleton);
+ return durableObject.fetch(req);
+ }
+ }
+`;
+
 test("persists Durable Object data in-memory between options reloads", async (t) => {
  const opts: MiniflareOptions = {
  modules: true,
@@ -309,3 +328,56 @@ test("proxies Durable Object methods", async (t) => {
  const event = await eventPromise;
  t.is(event.data, "echo:hello");
 });
+
+test("Durable Object eviction", async (t) => {
+ // this test requires testing over a 10 second timeout
+ t.timeout(12_000);
+
+ // first set unsafePreventEviction to undefined
+ const mf = new Miniflare({
+ verbose: true,
+ modules: true,
+ script: STATEFUL_SCRIPT(),
+ durableObjects: {
+ DURABLE_OBJECT: "DurableObject",
+ },
+ });
+ t.teardown(() => mf.dispose());
+
+ // get uuid generated at durable object startup
+ let res = await mf.dispatchFetch("http://localhost");
+ const original = await res.text();
+
+ // after 10+ seconds, durable object should be evicted, so new uuid generated
+ await setTimeout(10_000);
+ res = await mf.dispatchFetch("http://localhost");
+ t.not(await res.text(), original);
+});
+
+test("prevent Durable Object eviction", async (t) => {
+ // this test requires testing over a 10 second timeout
+ t.timeout(12_000);
+
+ // first set unsafePreventEviction to undefined
+ const mf = new Miniflare({
+ verbose: true,
+ modules: true,
+ script: STATEFUL_SCRIPT(),
+ durableObjects: {
+ DURABLE_OBJECT: {
+ className: "DurableObject",
+ unsafePreventEviction: true,
+ },
+ },
+ });
+ t.teardown(() => mf.dispose());
+
+ // get uuid generated at durable object startup
+ let res = await mf.dispatchFetch("http://localhost");
+ const original = await res.text();
+
+ // after 10+ seconds, durable object should NOT be evicted, so same uuid
+ await setTimeout(10_000);
+ res = await mf.dispatchFetch("http://localhost");
+ t.is(await res.text(), original);
+});