akanjs 2.2.4-rc.5 → 2.2.4

package/server/systemPages.test.tsx

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "bun:test";
+import { DEFAULT_AKAN_I18N } from "akanjs/common";
+import {
+  createSystemPageFallbackText,
+  createSystemPageHeaders,
+  createSystemPageResponse,
+  getSystemPageHomeHref,
+} from "./systemPages";
+
+describe("system pages", () => {
+  test("renders a pretty not-found page with no-store headers", async () => {
+    const response = await createSystemPageResponse({
+      kind: "not-found",
+      pathname: "/ko/akanjs/missing",
+      homeHref: "/ko/akanjs",
+      lang: "ko",
+      stylesheetHref: "/_akan/styles/akanjs.css",
+    });
+    const html = await response.text();
+
+    expect(response.status).toBe(404);
+    expect(response.headers.get("Content-Type")).toBe("text/html; charset=utf-8");
+    expect(response.headers.get("Cache-Control")).toBe("no-store");
+    expect(html).toContain("Page not found");
+    expect(html).toContain("This page is off the flight path.");
+    expect(html).toContain("/ko/akanjs/missing");
+    expect(html).toContain('href="/ko/akanjs"');
+    expect(html).toContain('href="/_akan/styles/akanjs.css"');
+    expect(html).toContain('name="robots"');
+    expect(html).toContain("noindex");
+  });
+
+  test("keeps server error details dev-only", async () => {
+    const error = new Error("database password leaked in stack");
+    const productionResponse = await createSystemPageResponse({
+      kind: "error",
+      pathname: "/en/broken",
+      homeHref: "/en",
+      showDetails: false,
+      error,
+    });
+    const devResponse = await createSystemPageResponse({
+      kind: "error",
+      pathname: "/en/broken",
+      homeHref: "/en",
+      showDetails: true,
+      error,
+    });
+
+    expect(productionResponse.status).toBe(500);
+    expect(await productionResponse.text()).not.toContain("database password leaked in stack");
+    expect(await devResponse.text()).toContain("database password leaked in stack");
+  });
+
+  test("returns HEAD metadata without a body", async () => {
+    const response = await createSystemPageResponse({
+      kind: "not-found",
+      method: "HEAD",
+      pathname: "/en/missing",
+      homeHref: "/en",
+    });
+
+    expect(response.status).toBe(404);
+    expect(response.headers.get("Cache-Control")).toBe("no-store");
+    expect(await response.text()).toBe("");
+  });
+
+  test("builds locale and base-path aware home links", () => {
+    expect(
+      getSystemPageHomeHref({
+        pathname: "/ko/akanjs/docs/missing",
+        i18n: DEFAULT_AKAN_I18N,
+        basePaths: ["akanjs", "soft"],
+      }),
+    ).toBe("/ko/akanjs");
+    expect(
+      getSystemPageHomeHref({
+        pathname: "/unknown/missing",
+        i18n: DEFAULT_AKAN_I18N,
+        basePaths: ["akanjs", "soft"],
+        headerBasePath: "soft",
+      }),
+    ).toBe("/en/soft");
+  });
+
+  test("provides final fallback text and no-store headers", () => {
+    const headers = createSystemPageHeaders();
+
+    expect(createSystemPageFallbackText("error")).toBe("500 Server error");
+    expect(headers.get("Content-Type")).toBe("text/html; charset=utf-8");
+    expect(headers.get("Cache-Control")).toBe("no-store");
+  });
+});

package/server/types/react-server-dom-webpack.d.ts

@@ -1,4 +1,10 @@
-
+// Minimal ambient declarations for the `react-server-dom-webpack` subpaths we
+// use. The upstream package ships runtime code only; no types are published.
+// We only declare the surface our SSR/RSC pipeline actually touches.
+//
+// This file is intentionally a top-level ambient declaration (no `import`/
+// `export` at file scope) so that TypeScript registers the module names below
+// globally.
 
 declare module "react-server-dom-webpack/server.node" {
   export interface ClientReferenceManifestEntry {

package/server/vendor/react-dom-client.ts

@@ -1,4 +1,4 @@
-
+// @ts-nocheck — see ./react.ts for the rationale.
 import * as m from "react-dom/client";
 
 export default m;

package/server/vendor/react-dom.ts

@@ -1,5 +1,6 @@
-
-
+// @ts-nocheck — see ./react.ts for the full rationale behind vendor entries
+// and why we enumerate named exports manually instead of relying on
+// `export * from "<cjs>"`.
 import * as m from "react-dom";
 
 export default m;

package/server/vendor/react-jsx-dev-runtime.ts

@@ -1,4 +1,4 @@
-
+// @ts-nocheck — see ./react.ts for the rationale.
 import * as m from "react/jsx-dev-runtime";
 
 export default m;

package/server/vendor/react-jsx-runtime.ts

@@ -1,4 +1,4 @@
-
+// @ts-nocheck — see ./react.ts for the rationale.
 import * as m from "react/jsx-runtime";
 
 export default m;

package/server/vendor/react-refresh-runtime.ts

@@ -1,5 +1,5 @@
-
-
+// @ts-nocheck — react-refresh/runtime ships implementation details without
+// stable ESM type declarations for the browser-side runtime surface.
 import * as m from "react-refresh/runtime";
 
 export default m;

package/server/vendor/react-server-dom-webpack-client-browser.ts

@@ -1,4 +1,4 @@
-
+// @ts-nocheck — see ./react.ts for the rationale.
 import * as m from "react-server-dom-webpack/client.browser";
 
 export default m;

package/server/vendor/react.ts

@@ -1,5 +1,12 @@
-
-
+// @ts-nocheck — `@types/react` declares its module via `export =`, which TS
+// refuses to combine with wildcard re-export forms. At bundle time Bun sees
+// the JS module (CJS) which does expose these named properties.
+//
+// We enumerate exports explicitly because Bun's `export * from "<cjs>"` only
+// emits an internal `__reExport` object and never generates top-level ESM
+// named bindings — so downstream chunks that `import { useState } from
+// "react"` would silently get `undefined`. See the importmap dedup story
+// in `vendorSpecifiers.ts` for the rationale behind these entries.
 import * as m from "react";
 
 export default m;

package/server/vendor/scheduler.ts

@@ -1,5 +1,6 @@
-
-
+// @ts-nocheck — `scheduler` ships no `.d.ts`, and see ./react.ts for the
+// rationale behind manual named re-exports (Bun's `export * from "<cjs>"`
+// doesn't emit ESM exports).
 import * as m from "scheduler";
 
 export default m;

package/server/webRouter.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import { DEFAULT_AKAN_I18N } from "akanjs/common";
+import { normalizeRscTargetUrlForHostBasePath } from "./webRouter";
+
+describe("WebRouter RSC target normalization", () => {
+  test("maps public host paths to the hidden basePath route for RSC navigation", () => {
+    const target = new URL("https://akanjs.com/en/docs/intro/quickstart");
+
+    const normalized = normalizeRscTargetUrlForHostBasePath(target, {
+      basePath: "akanjs",
+      i18n: DEFAULT_AKAN_I18N,
+    });
+
+    expect(normalized.url.href).toBe("https://akanjs.com/en/akanjs/docs/intro/quickstart");
+    expect(normalized.basePath).toBe("akanjs");
+  });
+
+  test("maps debug public paths by matching configured basePath route seeds", () => {
+    const target = new URL("https://akanjs-debug.akanjs.com/en/references/cli/overview");
+
+    const normalized = normalizeRscTargetUrlForHostBasePath(target, {
+      basePath: null,
+      basePaths: ["office", "akanjs", "soft"],
+      i18n: DEFAULT_AKAN_I18N,
+      seedEntries: [
+        {
+          routeId: "/:lang/akanjs/references/cli/overview",
+          pattern: "/:lang/akanjs/references/cli/overview",
+          seeds: [],
+        },
+      ],
+    });
+
+    expect(normalized.url.href).toBe("https://akanjs-debug.akanjs.com/en/akanjs/references/cli/overview");
+    expect(normalized.basePath).toBe("akanjs");
+  });
+
+  test("does not duplicate an already internal basePath route", () => {
+    const target = new URL("https://akanjs.com/en/akanjs/docs/intro/quickstart");
+
+    const normalized = normalizeRscTargetUrlForHostBasePath(target, {
+      basePath: "akanjs",
+      i18n: DEFAULT_AKAN_I18N,
+    });
+
+    expect(normalized.url.href).toBe("https://akanjs.com/en/akanjs/docs/intro/quickstart");
+    expect(normalized.basePath).toBe("akanjs");
+  });
+});

package/server/webRouter.ts

@@ -437,11 +437,12 @@ export class WebRouter {
     const fwdProto = req.headers.get("x-forwarded-proto")?.split(",")[0]?.trim();
     const fwdHost = req.headers.get("x-forwarded-host")?.split(",")[0]?.trim();
     const hostFallback = fwdHost ?? req.headers.get("host");
-    const protoFallback = fwdProto ?? parsed.protocol.slice(0, -1); 
+    const protoFallback = fwdProto ?? parsed.protocol.slice(0, -1); // strip trailing ':'
     if (hostFallback && protoFallback) {
       try {
         return new URL(`${protoFallback}://${hostFallback}`).origin;
       } catch {
+        /* fallthrough */
       }
     }
     return parsed.origin;
@@ -461,7 +462,7 @@ export class WebRouter {
   static #isTrustedRscTarget(clientOrigin: string, targetUrl: URL): boolean {
     try {
       if (targetUrl.origin === clientOrigin) return true;
-      
+      // TLS termination + missing/partial forwarded headers may skew scheme while hostname matches the public host.
       return targetUrl.hostname === new URL(clientOrigin).hostname;
     } catch {
       return false;

package/service/adapt.ts

@@ -10,7 +10,7 @@ export interface Adaptor {
 
 export type AdaptorCls<
   Methods = any,
-  
+  // biome-ignore lint/complexity/noBannedTypes: `{}` keeps un-injected adaptor classes assignable.
   InjectMap extends Record<string, InjectInfo> = {},
 > = Cls<
   Methods & ExtractInjectInfoObject<InjectMap> & Adaptor,
@@ -22,6 +22,7 @@ export function adapt<Name extends string>(name: Name): AdaptorCls;
 export function adapt<Name extends string, Injection extends InjectBuilder<"use" | "env" | "memory" | "plug">>(
   name: Name,
   injectBuilder: Injection,
+  // biome-ignore lint/complexity/noBannedTypes: `{}` preserves adaptor method inference for generated class types.
 ): AdaptorCls<{}, ReturnType<Injection>>;
 
 export function adapt(name: string, injectBuilder?: InjectBuilder) {
@@ -31,8 +32,10 @@ export function adapt(name: string, injectBuilder?: InjectBuilder) {
     static readonly [INJECT_META] = injectInfoMap;
     static readonly refName = name;
     async onInit() {
+      //
     }
     async onDestroy() {
+      //
     }
   }
   return Adaptor;
@@ -41,6 +44,7 @@ export function adapt(name: string, injectBuilder?: InjectBuilder) {
 export function dangerouslyAdapt<Name extends string, Injection extends InjectBuilder>(
   name: Name,
   injectBuilder: Injection,
+  // biome-ignore lint/complexity/noBannedTypes: `{}` preserves adaptor method inference for generated class types.
 ): AdaptorCls<{}, ReturnType<Injection>>;
 export function dangerouslyAdapt(name: string, injectBuilder?: InjectBuilder) {
   return adapt(name, injectBuilder as InjectBuilder<"use" | "env" | "memory" | "plug">);

package/service/predefinedAdaptor/cache.adaptor.ts

@@ -35,7 +35,8 @@ export class RedisCache
         operationMode,
         repoName,
         redis = {
-
+          // username, // TODO: Implement username and password
+          // password, // TODO: Implement username and password
           sshOptions: {
             host: `${appName}-${environment}.${serveDomain}`,
             port: 32767,

package/service/predefinedAdaptor/compress.adaptor.test.ts

@@ -0,0 +1,184 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { Any, dayjs, Float, Int, type PrimitiveScalar } from "akanjs/base";
+import { ConstantRegistry, via } from "akanjs/constant";
+import { ProtobufCompressor } from "./compress.adaptor";
+
+const NestedScalar = via((f) => ({
+  label: f(String),
+  point: f(Int),
+}));
+ConstantRegistry.buildScalar("ServiceCompressNestedScalar", NestedScalar, { NestedScalar });
+
+const TestScalar = via((f) => ({
+  name: f(String),
+  age: f(Int),
+  score: f(Float),
+  active: f(Boolean),
+  tags: f([String]),
+  nested: f(NestedScalar),
+  nestedList: f([NestedScalar]),
+  meta: f(Map, { of: String }),
+  nestedMap: f(Map, { of: NestedScalar as unknown as typeof PrimitiveScalar }),
+}));
+ConstantRegistry.buildScalar("ServiceCompressTestScalar", TestScalar, { TestScalar });
+
+const Compressor = new ProtobufCompressor();
+
+beforeAll(async () => {
+  await Compressor.onInit();
+});
+
+const expectBuffer = (buffer: Buffer | null) => {
+  expect(buffer).toBeInstanceOf(Buffer);
+  if (!buffer) throw new Error("Expected compressor to return a buffer");
+  return buffer;
+};
+
+describe("Compressor", () => {
+  describe("encode/decode primitives (arrDepth=0)", () => {
+    test("String", () => {
+      const buf = expectBuffer(Compressor.encode(String, 0, "hello"));
+      const decoded = Compressor.decode<string>(String, 0, buf);
+      expect(decoded).toBe("hello");
+    });
+
+    test("Int", () => {
+      const buf = expectBuffer(Compressor.encode(Int, 0, 42));
+      const decoded = Compressor.decode<number>(Int, 0, buf);
+      expect(decoded).toBe(42);
+    });
+
+    test("Float", () => {
+      const buf = expectBuffer(Compressor.encode(Float, 0, 3.14));
+      const decoded = Compressor.decode<number>(Float, 0, buf);
+      expect(decoded).toBeCloseTo(3.14, 2);
+    });
+
+    test("Boolean", () => {
+      const buf = expectBuffer(Compressor.encode(Boolean, 0, true));
+      const decoded = Compressor.decode<boolean>(Boolean, 0, buf);
+      expect(decoded).toBe(true);
+    });
+
+    test("Date", () => {
+      const now = dayjs("2025-01-01T00:00:00Z");
+      const buf = expectBuffer(Compressor.encode(Date, 0, now));
+      const decoded = Compressor.decode<Date>(Date, 0, buf);
+      expect(dayjs(decoded).toISOString()).toBe(now.toISOString());
+    });
+
+    test("Any (JSON object)", () => {
+      const obj = { key: "value", nested: { a: 1 } };
+      const buf = expectBuffer(Compressor.encode(Any, 0, obj));
+      const decoded = Compressor.decode(Any, 0, buf);
+      expect(decoded).toEqual(obj);
+    });
+  });
+
+  describe("encode/decode array of primitives (arrDepth=1)", () => {
+    test("[String]", () => {
+      const values = ["hello", "world", "test"];
+      const buf = expectBuffer(Compressor.encode(String, 1, values));
+      const decoded = Compressor.decode<string[]>(String, 1, buf);
+      expect(decoded).toEqual(values);
+    });
+
+    test("[Int]", () => {
+      const values = [1, 2, 3, 100];
+      const buf = expectBuffer(Compressor.encode(Int, 1, values));
+      const decoded = Compressor.decode<number[]>(Int, 1, buf);
+      expect(decoded).toEqual(values);
+    });
+
+    test("[Boolean]", () => {
+      const values = [true, false, true];
+      const buf = expectBuffer(Compressor.encode(Boolean, 1, values));
+      const decoded = Compressor.decode<boolean[]>(Boolean, 1, buf);
+      expect(decoded).toEqual(values);
+    });
+
+    test("empty array", () => {
+      const buf = expectBuffer(Compressor.encode(String, 1, []));
+      const decoded = Compressor.decode<string[]>(String, 1, buf);
+      expect(decoded).toEqual([]);
+    });
+  });
+
+  describe("encode/decode ConstantCls (arrDepth=0, delegates)", () => {
+    test("round-trips through encode/decode", () => {
+      const original = new TestScalar({
+        name: "bob",
+        age: 25,
+        score: 8.0,
+        active: false,
+        tags: ["one", "two"],
+        nested: { label: "nested", point: 1 },
+        nestedList: [
+          { label: "a", point: 2 },
+          { label: "b", point: 3 },
+        ],
+      } as never);
+      Object.defineProperty(original, "meta", { value: new Map([["locale", "ko"]]), configurable: true });
+      Object.defineProperty(original, "nestedMap", {
+        value: new Map([["home", new NestedScalar({ label: "home", point: 4 })]]),
+        configurable: true,
+      });
+      const buf = expectBuffer(Compressor.encode(TestScalar, 0, original));
+      const decoded = Compressor.decode<typeof original>(TestScalar, 0, buf, { raw: true }) as typeof original & {
+        nestedList: InstanceType<typeof NestedScalar>[];
+        meta: Map<string, string>;
+      };
+      const nestedMapHome = (decoded.nestedMap as Map<string, { label: string; point: number }>).get("home");
+      expect(decoded.name).toBe("bob");
+      expect(decoded.age).toBe(25);
+      expect(decoded.active).toBe(false);
+      expect(decoded.tags).toEqual(["one", "two"]);
+      expect(decoded.nested.label).toBe("nested");
+      expect(decoded.nestedList[1]?.point).toBe(3);
+      expect(decoded.meta.get("locale")).toBe("ko");
+      expect(nestedMapHome?.point).toBe(4);
+    });
+  });
+
+  describe("encode/decode array of ConstantCls (arrDepth=1)", () => {
+    test("[TestScalar]", () => {
+      const items = [
+        new TestScalar({
+          name: "alice",
+          age: 30,
+          score: 9.5,
+          active: true,
+          tags: [],
+          nested: { label: "n1", point: 1 },
+          nestedList: [],
+          meta: {} as never,
+          nestedMap: {} as never,
+        } as never),
+        new TestScalar({
+          name: "bob",
+          age: 25,
+          score: 8.0,
+          active: false,
+          tags: [],
+          nested: { label: "n2", point: 2 },
+          nestedList: [],
+          meta: {} as never,
+          nestedMap: {} as never,
+        } as never),
+      ];
+      const buf = expectBuffer(Compressor.encode(TestScalar, 1, items));
+      const decoded = Compressor.decode<(typeof items)[0][]>(TestScalar, 1, buf);
+      expect(decoded).toHaveLength(2);
+      expect(decoded[0]?.name).toBe("alice");
+      expect(decoded[0]?.age).toBe(30);
+      expect(decoded[1]?.name).toBe("bob");
+      expect(decoded[1]?.active).toBe(false);
+    });
+
+    test("empty model array", () => {
+      const buf = expectBuffer(Compressor.encode(TestScalar, 1, []));
+      const decoded = Compressor.decode<InstanceType<typeof TestScalar>[]>(TestScalar, 1, buf);
+      expect(decoded).toEqual([]);
+    });
+  });
+});

package/service/predefinedAdaptor/database.adaptor.ts

@@ -300,7 +300,7 @@ const jsonPath = (path: string) =>
     .map((part) => part.replaceAll('"', '\\"'))
     .join(".")}`;
 const encodeSqlValue = (value: unknown) => encodeDocumentValue(value);
-
+// Dates are persisted as epoch ms, but legacy rows may hold ISO strings; accept both.
 const decodeDateValue = (value: unknown) => {
   if (value === null || value === undefined) return value;
   if (typeof value === "number") return dayjs(value);
@@ -1128,7 +1128,7 @@ export class SqliteDocumentStore {
   private prepareReadStmt(sql: string) {
     const cached = this.#readStmtCache.get(sql);
     if (cached) return cached;
-    
+    // Keep the cache bounded; list/find query shapes repeat heavily, while ad-hoc filters should not grow forever.
     if (this.#readStmtCache.size >= 128) {
       const oldest = this.#readStmtCache.keys().next().value;
       if (oldest) this.#readStmtCache.delete(oldest);

package/service/predefinedAdaptor/solidCache.adaptor.test.ts

@@ -0,0 +1,107 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { dayjs } from "akanjs/base";
+import { SolidCache } from "./solidCache.adaptor";
+import { getSolidConfig } from "./solidSqlite";
+
+const createCache = async () => {
+  const filePath = path.join(tmpdir(), `solid-cache-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+  const config = getSolidConfig({ appName: "test", environment: "test", solid: { filePath } });
+  const cache = new SolidCache();
+  // The DI container injects `config`; in tests we assign it directly before init.
+  Object.assign(cache, { config });
+  await cache.onInit();
+  return { cache, filePath };
+};
+
+const cleanup = (filePath: string) => {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      rmSync(`${filePath}${suffix}`);
+    } catch {
+      // ignore missing files
+    }
+  }
+};
+
+describe("SolidCache adaptor (sqlite)", () => {
+  let cache: SolidCache;
+  let filePath: string;
+
+  beforeEach(async () => {
+    ({ cache, filePath } = await createCache());
+  });
+
+  afterEach(async () => {
+    await cache.onDestroy();
+    cleanup(filePath);
+  });
+
+  test("round-trips string and number values like the redis cache", async () => {
+    await cache.set("remoteAuthToken", "remote-1", "jwt-token");
+    expect(await cache.get<string>("remoteAuthToken", "remote-1")).toBe("jwt-token");
+
+    await cache.set("lastResetAt", "user-1", 1234);
+    expect(await cache.get<number>("lastResetAt", "user-1")).toBe(1234);
+  });
+
+  test("overwrites an existing key on repeated set", async () => {
+    await cache.set("remoteAuthToken", "remote-1", "first");
+    await cache.set("remoteAuthToken", "remote-1", "second");
+    expect(await cache.get<string>("remoteAuthToken", "remote-1")).toBe("second");
+  });
+
+  test("returns the value while the expiration is in the future", async () => {
+    await cache.set("remoteAuthToken", "remote-1", "jwt-token", { expireAt: dayjs().add(30, "second") });
+    expect(await cache.get<string>("remoteAuthToken", "remote-1")).toBe("jwt-token");
+  });
+
+  test("returns undefined once the expiration has passed", async () => {
+    await cache.set("remoteAuthToken", "remote-1", "jwt-token", { expireAt: dayjs().subtract(1, "second") });
+    expect(await cache.get<string>("remoteAuthToken", "remote-1")).toBeUndefined();
+  });
+
+  test("returns undefined for an unknown key", async () => {
+    expect(await cache.get<string>("remoteAuthToken", "missing")).toBeUndefined();
+  });
+
+  test("deletes a stored value", async () => {
+    await cache.set("remoteAuthToken", "remote-1", "jwt-token");
+    await cache.delete("remoteAuthToken", "remote-1");
+    expect(await cache.get<string>("remoteAuthToken", "remote-1")).toBeUndefined();
+  });
+
+  test("round-trips and removes hash values", async () => {
+    await cache.hset("session", "user-1", "field-a", "value-a");
+    await cache.hset("session", "user-1", "field-b", "value-b");
+    expect(await cache.hget<string>("session", "user-1", "field-a")).toBe("value-a");
+    expect(await cache.hget<string>("session", "user-1", "field-b")).toBe("value-b");
+
+    await cache.hdelete("session", "user-1", "field-a");
+    expect(await cache.hget<string>("session", "user-1", "field-a")).toBeUndefined();
+    expect(await cache.hget<string>("session", "user-1", "field-b")).toBe("value-b");
+  });
+
+  test("lists and clears hash values", async () => {
+    await cache.hset("session", "user-1", "field-b", "value-b");
+    await cache.hset("session", "user-1", "field-a", "value-a");
+    await cache.hset("session", "user-2", "field-c", "value-c");
+
+    expect(await cache.hkeys("session", "user-1")).toEqual(["field-a", "field-b"]);
+    expect(await cache.hentries<string>("session", "user-1")).toEqual([
+      ["field-a", "value-a"],
+      ["field-b", "value-b"],
+    ]);
+
+    await cache.hclear("session", "user-1");
+    expect(await cache.hkeys("session", "user-1")).toEqual([]);
+    expect(await cache.hget<string>("session", "user-2", "field-c")).toBe("value-c");
+  });
+
+  test("expires hash values once the expiration has passed", async () => {
+    await cache.hset("session", "user-1", "field-a", "value-a", { expireAt: dayjs().subtract(1, "second") });
+    expect(await cache.hget<string>("session", "user-1", "field-a")).toBeUndefined();
+  });
+});