@specific.dev/spectest 0.109.0 → 0.109.1

package/dist/helper-tracking.js

@@ -83,9 +83,11 @@ function invokeHelper(kind, name, member, fn, receiver, callArgs) {
     };
     let result;
     try {
+        // Reading a callable proxy's `.apply` can bind directly to its raw client
+        // and bypass instrumentation (SQL does this). Invoke the proxy itself.
         result = recording.run(() => kind === "fake"
-            ? runUninstrumented(() => fn.apply(receiver, args))
-            : fn.apply(receiver, args));
+            ? runUninstrumented(() => Reflect.apply(fn, receiver, args))
+            : Reflect.apply(fn, receiver, args));
     }
     catch (error) {
         return fail(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.109.0",
+  "version": "0.109.1",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",

package/src/helper-tracking.test.ts

@@ -3,6 +3,7 @@ import { annotate } from "./annotate.js";
 import { expect as assertValue, type ServiceHandlesFor, type Wrapped } from "./index.js";
 import { readRaw, readTag, wrap } from "./inspect.js";
 import { trackHelpers } from "./helper-tracking.js";
+import { SQL } from "./sql.js";
 import {
   recordHttp, recordWait, recorderEventCount, recorderMarkChildren, recorderTruncate,
   startRecording, stopRecording,
@@ -175,6 +176,41 @@ test("live objects, callable clients, function properties and receivers survive"
   expect<unknown>(readRaw(helper.latest.call({...raw, subject: "Other"}))).toEqual({subject: "Other"});
 });
 
+test("a tracked SQL client keeps tagged queries and attached methods instrumented", async () => {
+  const client = new SQL("sqlite://:memory:", { label: "db" });
+  const helper = trackHelpers("service", "db", { client });
+  startRecording();
+  try {
+    const rows = await helper.client<{ id: number }>`SELECT ${7} AS id`;
+    assertValue(rows.transform("ids", (rows) => Array.from(rows, (row) => row.id))).toEqual([7]);
+    const other = await helper.client.unsafe<{ id: number }>("SELECT ? AS id", [8]);
+    assertValue(other[0]!.id).toBe(8);
+    const events = stopRecording();
+    expect(events.map((event) => event.kind)).toEqual(["db", "assertion", "db", "assertion"]);
+    expect(events[0]).toMatchObject({ service: "db", query: "SELECT $1 AS id", params: [7], rows: [{ id: 7 }] });
+    expect(events[1]).toMatchObject({ sourceSeq: events[0]!.seq, path: ["<ids>"] });
+    expect(events[2]).toMatchObject({ service: "db", query: "SELECT ? AS id", params: [8], rows: [{ id: 8 }] });
+    expect(events[3]).toMatchObject({ sourceSeq: events[2]!.seq, path: ["0", "id"] });
+  } finally {
+    await helper.client.close!();
+  }
+});
+
+test("a tracked SQL client preserves query failure diagnostics", async () => {
+  const client = new SQL("sqlite://:memory:", { label: "db" });
+  const helper = trackHelpers("service", "db", { client });
+  startRecording();
+  try {
+    await expect(helper.client`SELECT * FROM missing_table`).rejects.toThrow("no such table");
+    const events = stopRecording();
+    expect(events).toHaveLength(1);
+    expect(events[0]).toMatchObject({ kind: "db", service: "db", query: "SELECT * FROM missing_table",
+      error: expect.stringContaining("no such table") });
+  } finally {
+    await helper.client.close!();
+  }
+});
+
 test("setup/eval unwrap annotated returns without recording", async () => {
   const scope = createInstrumentationScope(false);
   const helper = trackHelpers("service", "mail", { latest: () => annotate({subject: "Invoice"}, "email") });

package/src/helper-tracking.ts

@@ -93,9 +93,11 @@ function invokeHelper(
   };
   let result: unknown;
   try {
+    // Reading a callable proxy's `.apply` can bind directly to its raw client
+    // and bypass instrumentation (SQL does this). Invoke the proxy itself.
     result = recording.run(() => kind === "fake"
-      ? runUninstrumented(() => fn.apply(receiver, args))
-      : fn.apply(receiver, args));
+      ? runUninstrumented(() => Reflect.apply(fn, receiver, args))
+      : Reflect.apply(fn, receiver, args));
   } catch (error) {
     return fail(error);
   }