@ultimat3/storage 31.1.0 → 31.2.0

package/README.md

@@ -58,7 +58,7 @@ const stored = [...sessions.objects().values()].map((bytes) => new TextDecoder()
 
 Server-side only, like both other drivers: nothing an island imports reaches it.
 
-Every call on a disk `defineStorage` resolves is a `storage.<verb>` event on `@ultimat3/core`'s instrumentation bus (`put`, `get`, `stat`, `copy`, `delete`, `list`; `{ disk, key, bytes?, durationMs, error? }`) inside a `storage.<verb>` client span. `disk()` hands out that instrumented view, so it is not `===` the driver you declared — compare `.name`. A driver you hold directly reports nothing.
+Every call on a disk `defineStorage` resolves is a `storage.<verb>` event on `@ultimat3/core`'s instrumentation bus (`put`, `get`, `stat`, `copy`, `delete`, `list`; `{ disk, key, bytes?, durationMs, error? }`) inside a `storage.<verb>` client span. `disk()` hands out that instrumented view, so it is not `===` the driver you declared — compare `.name`. A driver you hold directly reports nothing. A method patched in a test — assigned on the disk, or `spyOn(driver, 'put')` on the driver you declared — runs on the next call and is still reported. `spyOn(disk, …)` does nothing: Bun's `spyOn` never writes through a Proxy (as of bun 1.4.4), so spy on the driver.
 
 `region` is what requests are signed for; unset, that is `auto`. An endpoint that expects another
 region refuses the first write, list or delete with `X_CONFIG_INVALID`, and the fix names the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultimat3/storage",
-  "version": "31.1.0",
+  "version": "31.2.0",
   "description": "Named disks over Bun.file and Bun.s3: safe keys, signed URLs, sniffed uploads",
   "keywords": [
     "ultimate",
@@ -43,6 +43,6 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ultimat3/core": "31.1.0"
+    "@ultimat3/core": "31.2.0"
   }
 }

package/src/storage-instrument.ts

@@ -51,15 +51,38 @@ function report(name: `storage.${StorageVerb}`, event: StorageEvent): void {
  * The driver, every contract method wrapped and every other member (a test disk's `objects()`,
  * `multipart`, `registerAs`) passed through bound to the driver. The driver's calls to its OWN
  * methods stay unwrapped: one caller's call is one event.
+ *
+ * A wrapper is reused only while the driver still holds the method it wraps. A cache keyed on the
+ * name alone kept answering the original after a test patched `put` to simulate an outage; keyed
+ * on the method, a patch — written through the disk or onto the declared driver — runs on the next
+ * call, still reported. Writing back a wrapper this disk handed out writes the method it wraps, so
+ * `const put = disk.put; …; disk.put = put` restores one event per call, never two.
  */
 export function instrumentedDisk(disk: string, driver: StorageDriver): StorageDriver {
-  const wrapped = new Map<PropertyKey, unknown>();
-  return new Proxy(driver, {
+  const wrapped = new Map<PropertyKey, { readonly method: unknown; readonly bound: unknown }>();
+  /** Each wrapper handed out, to the method it wraps: what a restore writes back. */
+  const unwrapped = new WeakMap<object, unknown>();
+  const raw = (value: unknown): unknown =>
+    typeof value === 'function' ? (unwrapped.get(value) ?? value) : value;
+  const view: StorageDriver = new Proxy(driver, {
+    // Only a write ON the disk patches the driver. An object inheriting from the disk
+    // (`Object.create(disk)`) reaches this trap as `receiver` and keeps the member as its own;
+    // written onto the driver, a child's `stat` calling `disk.stat` called itself.
+    set: (target, property, value, receiver) =>
+      receiver === view
+        ? Reflect.set(target, property, raw(value), target)
+        : Reflect.set(target, property, value, receiver),
+    defineProperty: (target, property, descriptor) =>
+      Reflect.defineProperty(
+        target,
+        property,
+        'value' in descriptor ? { ...descriptor, value: raw(descriptor.value) } : descriptor,
+      ),
     get(target, property) {
-      const known = wrapped.get(property);
-      if (known !== undefined) return known;
       const value: unknown = Reflect.get(target, property, target);
       if (typeof value !== 'function') return value;
+      const known = wrapped.get(property);
+      if (known?.method === value) return known.bound;
       // A Proxy `get` is handed every name, `constructor` included: an own key or no verb.
       const verb =
         typeof property === 'string' && Object.hasOwn(VERB_OF, property)
@@ -73,10 +96,12 @@ export function instrumentedDisk(disk: string, driver: StorageDriver): StorageDr
               call(disk, verb, keyOf(property as string, args), driver.name, () =>
                 Promise.resolve(method.apply(target, args)),
               );
-      wrapped.set(property, bound);
+      wrapped.set(property, { method: value, bound });
+      unwrapped.set(bound, value);
       return bound;
     },
   });
+  return view;
 }
 
 async function call(