Normalise Durable Object alarm configuration keys

API: `durableObjectAlarms` -> `durableObjectsAlarms`
`wrangler.toml`: `do_alarms` -> `durable_objects_alarms`

Author: mrbbot

packages/durable-objects/src/plugin.ts

@@ -33,7 +33,7 @@ export type DurableObjectsObjectsOptions = Record<
 export interface DurableObjectsOptions {
   durableObjects?: DurableObjectsObjectsOptions;
   durableObjectsPersist?: boolean | string;
-  durableObjectAlarms?: boolean;
+  durableObjectsAlarms?: boolean;
 }
 
 interface ProcessedDurableObject {
@@ -93,9 +93,9 @@ export class DurableObjectsPlugin
     description: "Enable Durable Object alarms (enabled by default)",
     negatable: true,
     logName: "Durable Object Alarms",
-    fromWrangler: ({ miniflare }) => miniflare?.do_alarms,
+    fromWrangler: ({ miniflare }) => miniflare?.durable_objects_alarms,
   })
-  durableObjectAlarms?: boolean;
+  durableObjectsAlarms?: boolean;
 
   readonly #persist?: boolean | string;
 
@@ -199,7 +199,7 @@ export class DurableObjectsPlugin
   }
 
   async #setupAlarms(storage: StorageFactory): Promise<void> {
-    if (this.durableObjectAlarms === false) return;
+    if (this.durableObjectsAlarms === false) return;
     // if the alarm store doesn't exist yet, create
     await this.#alarmStore.setupStore(storage, this.#persist);
     await this.#alarmStore.setupAlarms(async (objectKey: string) => {

packages/durable-objects/test/namespace.spec.ts

@@ -160,13 +160,13 @@ test("DurableObjectState: kAlarm: no alarm method; setAlarm throws while getAlar
   });
 
   class TestObject implements DurableObject {
-    constructor(private readonly state: DurableObjectState) {}
+    constructor(private readonly _state: DurableObjectState) {}
 
     fetch(): Response {
       return new Response();
     }
   }
-  plugin.setup(factory);
+  await plugin.setup(factory);
   plugin.beforeReload();
   plugin.reload({}, { TestObject }, new Map());
 
@@ -246,7 +246,7 @@ test("DurableObjectStub: fetch: throws with relative urls if compatibility flag
   const factory = new MemoryStorageFactory();
   const plugin = new DurableObjectsPlugin(
     { log, compat, rootPath },
-    { durableObjects: { TEST: "TestObject" }, durableObjectAlarms: true }
+    { durableObjects: { TEST: "TestObject" }, durableObjectsAlarms: true }
   );
   plugin.beforeReload();
   plugin.reload({}, { TestObject }, new Map());
@@ -267,7 +267,7 @@ test("DurableObjectStub: fetch: throws with unknown protocols if compatibility f
   const factory = new MemoryStorageFactory();
   const plugin = new DurableObjectsPlugin(
     { log, compat, rootPath },
-    { durableObjects: { TEST: "TestObject" }, durableObjectAlarms: true }
+    { durableObjects: { TEST: "TestObject" }, durableObjectsAlarms: true }
   );
   plugin.beforeReload();
   plugin.reload({}, { TestObject }, new Map());
@@ -290,7 +290,7 @@ test("DurableObjectStub: fetch: logs warning with unknown protocol if compatibil
   const factory = new MemoryStorageFactory();
   const plugin = new DurableObjectsPlugin(
     { log, compat, rootPath },
-    { durableObjects: { TEST: "TestObject" }, durableObjectAlarms: true }
+    { durableObjects: { TEST: "TestObject" }, durableObjectsAlarms: true }
   );
   plugin.beforeReload();
   plugin.reload({}, { TestObject }, new Map());

packages/durable-objects/test/plugin.spec.ts

@@ -37,13 +37,15 @@ test("DurableObjectsPlugin: parses options from argv", (t) => {
     "OBJECT2=Object2@api",
     "--do-persist",
     "path",
+    "--no-do-alarms",
   ]);
   t.deepEqual(options, {
     durableObjects: {
       OBJECT1: "Object1",
       OBJECT2: { className: "Object2", scriptName: "api" },
     },
     durableObjectsPersist: "path",
+    durableObjectsAlarms: false,
   });
   options = parsePluginArgv(DurableObjectsPlugin, [
     "-o",
@@ -68,22 +70,25 @@ test("DurableObjectsPlugin: parses options from wrangler config", (t) => {
         { name: "OBJECT2", class_name: "Object2", script_name: "other_script" },
       ],
     },
-    miniflare: { durable_objects_persist: "path" },
+    miniflare: {
+      durable_objects_persist: "path",
+      durable_objects_alarms: false,
+    },
   });
   t.deepEqual(options, {
     durableObjects: {
       OBJECT1: { className: "Object1", scriptName: undefined },
       OBJECT2: { className: "Object2", scriptName: "other_script" },
     },
     durableObjectsPersist: "path",
-    durableObjectAlarms: undefined,
+    durableObjectsAlarms: false,
   });
 });
 test("DurableObjectsPlugin: logs options", (t) => {
   const logs = logPluginOptions(DurableObjectsPlugin, {
     durableObjects: { OBJECT1: "Object1", OBJECT2: "Object2" },
     durableObjectsPersist: true,
-    durableObjectAlarms: true,
+    durableObjectsAlarms: true,
   });
   t.deepEqual(logs, [
     "Durable Objects: OBJECT1, OBJECT2",
@@ -297,9 +302,9 @@ test("DurableObjectsPlugin: setup alarms and dispose alarms", async (t) => {
   const factory = new MemoryStorageFactory();
   const plugin = new DurableObjectsPlugin(ctx, {
     durableObjects: { TEST: "TestObject" },
-    durableObjectAlarms: false,
+    durableObjectsAlarms: false,
   });
   plugin.setup(factory);
   plugin.dispose();
-  t.false(plugin.durableObjectAlarms);
+  t.false(plugin.durableObjectsAlarms);
 });

packages/shared/src/wrangler.ts

@@ -51,7 +51,7 @@ export interface WranglerEnvironmentConfig {
     cache?: boolean;
     cache_persist?: boolean | string;
     durable_objects_persist?: boolean | string;
-    do_alarms?: boolean;
+    durable_objects_alarms?: boolean;
     env_path?: string;
     host?: string;
     port?: number;