@sigil-dev/grimoire 0.9.29 → 0.9.31

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (105) hide show
  1. package/bin/sigil.ts +4 -0
  2. package/index.ts +16 -10
  3. package/package.json +14 -6
  4. package/server.ts +2 -2
  5. package/src/adapters/bun.ts +17 -17
  6. package/src/adapters/static.ts +41 -41
  7. package/src/adapters/types.ts +36 -36
  8. package/src/base.ts +4 -1
  9. package/src/client/csrf.ts +47 -47
  10. package/src/client/deferred.ts +1 -4
  11. package/src/client/enhance.ts +160 -160
  12. package/src/client/router.ts +927 -926
  13. package/src/config-file.ts +84 -0
  14. package/src/dev/compile-module.ts +199 -193
  15. package/src/dev/hmr-client.ts +229 -229
  16. package/src/dev/hmr-server.ts +274 -266
  17. package/src/dev/loader.ts +144 -144
  18. package/src/dev/runtime-bundle.ts +5 -3
  19. package/src/duration.ts +46 -0
  20. package/src/env/modules.ts +62 -62
  21. package/src/env/required.ts +42 -42
  22. package/src/env/typegen.ts +61 -61
  23. package/src/headers.ts +105 -105
  24. package/src/logger/transports.ts +117 -117
  25. package/src/plugin-order.ts +88 -0
  26. package/src/rendering/head.ts +49 -49
  27. package/src/rendering/hydrate.ts +162 -162
  28. package/src/rendering/images.ts +43 -43
  29. package/src/rendering/preload.ts +22 -8
  30. package/src/rendering/ssrPlugin.ts +107 -107
  31. package/src/rendering/timing.ts +40 -40
  32. package/src/routing/route-ids.ts +65 -0
  33. package/src/routing/route.ts +65 -0
  34. package/src/routing/router.ts +84 -32
  35. package/src/routing/scanner.ts +18 -5
  36. package/src/routing/transform-routes.ts +102 -102
  37. package/src/server/after-response.ts +206 -206
  38. package/src/server/asset-cache.ts +57 -57
  39. package/src/server/build.ts +304 -295
  40. package/src/server/cached.ts +114 -114
  41. package/src/server/client-address.ts +82 -82
  42. package/src/server/client-dir.ts +63 -63
  43. package/src/server/client-entry.ts +44 -44
  44. package/src/server/context.ts +18 -10
  45. package/src/server/cookie-utils.ts +80 -80
  46. package/src/server/coordinator.ts +479 -476
  47. package/src/server/hooks.ts +122 -122
  48. package/src/server/index.ts +1181 -1171
  49. package/src/server/plugins.ts +172 -172
  50. package/src/server/prerender.ts +473 -473
  51. package/src/server/reserved.ts +17 -17
  52. package/src/server/resolver.ts +149 -123
  53. package/src/server/rewrite.ts +28 -28
  54. package/src/server/warm.ts +9 -3
  55. package/src/server/with-headers.ts +27 -27
  56. package/src/server/worker.ts +2 -6
  57. package/src/server-only.ts +78 -0
  58. package/src/testing/dom.ts +73 -73
  59. package/src/testing/index.ts +169 -169
  60. package/src/testing/server.ts +1 -0
  61. package/src/typegen/index.ts +97 -2
  62. package/src/types.ts +642 -508
  63. package/test/after-response.test.ts +132 -132
  64. package/test/asset-cache-policy.test.ts +6 -2
  65. package/test/base.test.ts +20 -6
  66. package/test/cached.test.ts +126 -126
  67. package/test/client-address.test.ts +78 -78
  68. package/test/client-csrf.test.ts +61 -61
  69. package/test/client-dir.test.ts +101 -101
  70. package/test/client-router.test.ts +37 -5
  71. package/test/config-file.test.ts +84 -0
  72. package/test/coordinator.test.ts +9 -2
  73. package/test/deferred.test.ts +4 -2
  74. package/test/dev-loader.test.ts +30 -30
  75. package/test/env.test.ts +171 -171
  76. package/test/force-production.test.ts +7 -2
  77. package/test/images.test.ts +20 -8
  78. package/test/locals-header.test.ts +61 -61
  79. package/test/middleware.test.ts +243 -243
  80. package/test/parser-plugins.test.ts +98 -92
  81. package/test/plugin-handle.test.ts +62 -62
  82. package/test/plugin-order.test.ts +98 -0
  83. package/test/plugin-routes.test.ts +47 -42
  84. package/test/plugin-services-context.test.ts +7 -2
  85. package/test/preload.test.ts +4 -1
  86. package/test/prerender.test.ts +3 -1
  87. package/test/rendering.test.ts +3 -2
  88. package/test/required-env.test.ts +32 -32
  89. package/test/resolver-windows.test.ts +22 -23
  90. package/test/rewrite-html.test.ts +90 -90
  91. package/test/route-group-layouts.test.ts +38 -36
  92. package/test/route.test.ts +103 -0
  93. package/test/routing.test.ts +225 -197
  94. package/test/scanning.test.ts +53 -33
  95. package/test/server-context.test.ts +22 -0
  96. package/test/server-only.test.ts +110 -0
  97. package/test/server.test.ts +659 -640
  98. package/test/services.test.ts +3 -3
  99. package/test/streaming.test.ts +11 -6
  100. package/test/testing-helpers.test.ts +166 -166
  101. package/test/typegen.test.ts +209 -112
  102. package/test/warm.test.ts +96 -96
  103. package/test/worker-context.test.ts +59 -59
  104. package/test/workspace-files.test.ts +26 -10
  105. package/test/workspace-versions.test.ts +146 -131
@@ -1,132 +1,132 @@
1
- import { beforeEach, describe, expect, test } from "bun:test";
2
- import {
3
- _resetAfterResponseForTest,
4
- afterResponse,
5
- drainAfterResponse,
6
- withAfterResponse,
7
- } from "../src/server/after-response.ts";
8
-
9
- const req = () => new Request("http://localhost/");
10
-
11
- beforeEach(() => {
12
- _resetAfterResponseForTest();
13
- });
14
-
15
- describe("afterResponse", () => {
16
- test("does not run before the body is consumed", async () => {
17
- let ran = false;
18
- const res = await withAfterResponse(req(), async () => {
19
- afterResponse(() => {
20
- ran = true;
21
- });
22
- return new Response("hello");
23
- });
24
- expect(ran).toBe(false);
25
- await res.text();
26
- await Bun.sleep(10);
27
- expect(ran).toBe(true);
28
- });
29
-
30
- test("a body Bun types itself is still typed when served", async () => {
31
- const server = Bun.serve({
32
- port: 0,
33
- fetch: (r) =>
34
- withAfterResponse(r, async () => {
35
- afterResponse(() => {});
36
- return new Response("not found", { status: 404 });
37
- }),
38
- });
39
- try {
40
- const res = await fetch(`http://localhost:${server.port}/`);
41
- expect(res.status).toBe(404);
42
- expect(res.headers.get("content-type")).toStartWith("text/plain");
43
- expect(await res.text()).toBe("not found");
44
- } finally {
45
- server.stop(true);
46
- }
47
- });
48
-
49
- test("runs for a response with no body", async () => {
50
- let ran = false;
51
- await withAfterResponse(req(), async () => {
52
- afterResponse(() => {
53
- ran = true;
54
- });
55
- return new Response(null, { status: 204 });
56
- });
57
- await Bun.sleep(10);
58
- expect(ran).toBe(true);
59
- });
60
-
61
- test("a throwing task does not corrupt the response", async () => {
62
- const res = await withAfterResponse(req(), async () => {
63
- afterResponse(() => {
64
- throw new Error("boom");
65
- });
66
- return new Response("still fine");
67
- });
68
- expect(await res.text()).toBe("still fine");
69
- await Bun.sleep(10);
70
- });
71
-
72
- test("tasks are isolated per request under concurrency", async () => {
73
- const order: string[] = [];
74
- const make = (tag: string) =>
75
- withAfterResponse(req(), async () => {
76
- afterResponse(() => order.push(tag));
77
- return new Response(tag);
78
- });
79
-
80
- const [a, b] = await Promise.all([make("A"), make("B")]);
81
- await Promise.all([a.text(), b.text()]);
82
- await Bun.sleep(20);
83
-
84
- expect(order.sort()).toEqual(["A", "B"]);
85
- });
86
-
87
- test("preserves status, statusText and headers through the rewrap", async () => {
88
- const res = await withAfterResponse(
89
- req(),
90
- async () =>
91
- new Response("x", {
92
- status: 404,
93
- statusText: "Nope",
94
- headers: { "x-test": "1" },
95
- }),
96
- );
97
- expect(res.status).toBe(404);
98
- expect(res.headers.get("x-test")).toBe("1");
99
- expect(await res.text()).toBe("x");
100
- });
101
-
102
- test("drain waits for a task that is still running", async () => {
103
- let done = false;
104
- const res = await withAfterResponse(req(), async () => {
105
- afterResponse(async () => {
106
- await Bun.sleep(50);
107
- done = true;
108
- });
109
- return new Response("y");
110
- });
111
- await res.text();
112
- await drainAfterResponse(1000);
113
- expect(done).toBe(true);
114
- });
115
-
116
- test("drain returns promptly when nothing is pending", async () => {
117
- const t = Date.now();
118
- await drainAfterResponse(500);
119
- expect(Date.now() - t).toBeLessThan(200);
120
- });
121
-
122
- test("drain gives up rather than hanging on a stuck task", async () => {
123
- const res = await withAfterResponse(req(), async () => {
124
- afterResponse(() => Bun.sleep(60_000));
125
- return new Response("z");
126
- });
127
- await res.text();
128
- const t = Date.now();
129
- await drainAfterResponse(200);
130
- expect(Date.now() - t).toBeLessThan(1500);
131
- });
132
- });
1
+ import { beforeEach, describe, expect, test } from "bun:test";
2
+ import {
3
+ _resetAfterResponseForTest,
4
+ afterResponse,
5
+ drainAfterResponse,
6
+ withAfterResponse,
7
+ } from "../src/server/after-response.ts";
8
+
9
+ const req = () => new Request("http://localhost/");
10
+
11
+ beforeEach(() => {
12
+ _resetAfterResponseForTest();
13
+ });
14
+
15
+ describe("afterResponse", () => {
16
+ test("does not run before the body is consumed", async () => {
17
+ let ran = false;
18
+ const res = await withAfterResponse(req(), async () => {
19
+ afterResponse(() => {
20
+ ran = true;
21
+ });
22
+ return new Response("hello");
23
+ });
24
+ expect(ran).toBe(false);
25
+ await res.text();
26
+ await Bun.sleep(10);
27
+ expect(ran).toBe(true);
28
+ });
29
+
30
+ test("a body Bun types itself is still typed when served", async () => {
31
+ const server = Bun.serve({
32
+ port: 0,
33
+ fetch: (r) =>
34
+ withAfterResponse(r, async () => {
35
+ afterResponse(() => {});
36
+ return new Response("not found", { status: 404 });
37
+ }),
38
+ });
39
+ try {
40
+ const res = await fetch(`http://localhost:${server.port}/`);
41
+ expect(res.status).toBe(404);
42
+ expect(res.headers.get("content-type")).toStartWith("text/plain");
43
+ expect(await res.text()).toBe("not found");
44
+ } finally {
45
+ server.stop(true);
46
+ }
47
+ });
48
+
49
+ test("runs for a response with no body", async () => {
50
+ let ran = false;
51
+ await withAfterResponse(req(), async () => {
52
+ afterResponse(() => {
53
+ ran = true;
54
+ });
55
+ return new Response(null, { status: 204 });
56
+ });
57
+ await Bun.sleep(10);
58
+ expect(ran).toBe(true);
59
+ });
60
+
61
+ test("a throwing task does not corrupt the response", async () => {
62
+ const res = await withAfterResponse(req(), async () => {
63
+ afterResponse(() => {
64
+ throw new Error("boom");
65
+ });
66
+ return new Response("still fine");
67
+ });
68
+ expect(await res.text()).toBe("still fine");
69
+ await Bun.sleep(10);
70
+ });
71
+
72
+ test("tasks are isolated per request under concurrency", async () => {
73
+ const order: string[] = [];
74
+ const make = (tag: string) =>
75
+ withAfterResponse(req(), async () => {
76
+ afterResponse(() => order.push(tag));
77
+ return new Response(tag);
78
+ });
79
+
80
+ const [a, b] = await Promise.all([make("A"), make("B")]);
81
+ await Promise.all([a.text(), b.text()]);
82
+ await Bun.sleep(20);
83
+
84
+ expect(order.sort()).toEqual(["A", "B"]);
85
+ });
86
+
87
+ test("preserves status, statusText and headers through the rewrap", async () => {
88
+ const res = await withAfterResponse(
89
+ req(),
90
+ async () =>
91
+ new Response("x", {
92
+ status: 404,
93
+ statusText: "Nope",
94
+ headers: { "x-test": "1" },
95
+ }),
96
+ );
97
+ expect(res.status).toBe(404);
98
+ expect(res.headers.get("x-test")).toBe("1");
99
+ expect(await res.text()).toBe("x");
100
+ });
101
+
102
+ test("drain waits for a task that is still running", async () => {
103
+ let done = false;
104
+ const res = await withAfterResponse(req(), async () => {
105
+ afterResponse(async () => {
106
+ await Bun.sleep(50);
107
+ done = true;
108
+ });
109
+ return new Response("y");
110
+ });
111
+ await res.text();
112
+ await drainAfterResponse(1000);
113
+ expect(done).toBe(true);
114
+ });
115
+
116
+ test("drain returns promptly when nothing is pending", async () => {
117
+ const t = Date.now();
118
+ await drainAfterResponse(500);
119
+ expect(Date.now() - t).toBeLessThan(200);
120
+ });
121
+
122
+ test("drain gives up rather than hanging on a stuck task", async () => {
123
+ const res = await withAfterResponse(req(), async () => {
124
+ afterResponse(() => Bun.sleep(60_000));
125
+ return new Response("z");
126
+ });
127
+ await res.text();
128
+ const t = Date.now();
129
+ await drainAfterResponse(200);
130
+ expect(Date.now() - t).toBeLessThan(1500);
131
+ });
132
+ });
@@ -26,8 +26,12 @@ describe("isContentAddressed", () => {
26
26
  test("a bundler chunk name counts", () => {
27
27
  // Shared chunks are named for their contents, and every page load
28
28
  // fetches them. Without this they revalidated each time.
29
- expect(isContentAddressed("/__grimoire__/chunk-jp4kgm87.js", "")).toBe(true);
30
- expect(cacheControlFor("/__grimoire__/chunk-1pk15q3t.js", "")).toBe("immutable");
29
+ expect(isContentAddressed("/__grimoire__/chunk-jp4kgm87.js", "")).toBe(
30
+ true,
31
+ );
32
+ expect(cacheControlFor("/__grimoire__/chunk-1pk15q3t.js", "")).toBe(
33
+ "immutable",
34
+ );
31
35
  });
32
36
 
33
37
  test("chunk- must be the whole stem, not a lookalike", () => {
package/test/base.test.ts CHANGED
@@ -22,8 +22,12 @@ describe("normalizeBase", () => {
22
22
  });
23
23
 
24
24
  test("each mistake is named, with the fix", () => {
25
- expect(() => normalizeBase("repo")).toThrow(/must start with a slash: "\/repo"/);
26
- expect(() => normalizeBase("/repo/")).toThrow(/must not end with a slash: "\/repo"/);
25
+ expect(() => normalizeBase("repo")).toThrow(
26
+ /must start with a slash: "\/repo"/,
27
+ );
28
+ expect(() => normalizeBase("/repo/")).toThrow(
29
+ /must not end with a slash: "\/repo"/,
30
+ );
27
31
  expect(() => normalizeBase("https://u.github.io/repo")).toThrow(/full URL/);
28
32
  expect(() => normalizeBase("//cdn/repo")).toThrow(/full URL/);
29
33
  expect(() => normalizeBase("/a b")).toThrow(/plain path/);
@@ -59,7 +63,10 @@ describe("withBase and stripBase", () => {
59
63
  describe("extractLinks under a base", () => {
60
64
  const page = `<a href="/repo/a">a</a> <a href="/repo">home</a> <a href="/other">no</a> <a href="/repo/f.xml">no</a>`;
61
65
  test("strips the base and skips links outside it", () => {
62
- expect(extractLinks(page, "http://localhost", "/repo").sort()).toEqual(["/", "/a"]);
66
+ expect(extractLinks(page, "http://localhost", "/repo").sort()).toEqual([
67
+ "/",
68
+ "/a",
69
+ ]);
63
70
  });
64
71
  });
65
72
 
@@ -90,8 +97,10 @@ describe("a server under a base", () => {
90
97
  _skipBuild: true,
91
98
  _forceProduction: true,
92
99
  });
93
- const get = (app: { fetch(r: Request): Response | Promise<Response> }, path: string) =>
94
- Promise.resolve(app.fetch(new Request(`http://localhost${path}`)));
100
+ const get = (
101
+ app: { fetch(r: Request): Response | Promise<Response> },
102
+ path: string,
103
+ ) => Promise.resolve(app.fetch(new Request(`http://localhost${path}`)));
95
104
 
96
105
  test("routes see the route path, not the full one", async () => {
97
106
  const app = await make();
@@ -128,7 +137,12 @@ describe("a server under a base", () => {
128
137
 
129
138
  test("a bad base stops startup", async () => {
130
139
  await expect(
131
- createApp({ routes: dir, base: "/repo/", _skipBuild: true, _forceProduction: true }),
140
+ createApp({
141
+ routes: dir,
142
+ base: "/repo/",
143
+ _skipBuild: true,
144
+ _forceProduction: true,
145
+ }),
132
146
  ).rejects.toThrow(/must not end with a slash/);
133
147
  });
134
148
  });
@@ -1,126 +1,126 @@
1
- import { describe, expect, test } from "bun:test";
2
- import { cached, cachedBy } from "../src/server/cached.ts";
3
-
4
- const tick = (ms: number) => Bun.sleep(ms);
5
-
6
- describe("cached", () => {
7
- test("returns the same value while fresh and builds once", async () => {
8
- let n = 0;
9
- const get = cached(async () => ++n, { ttl: 1000 });
10
- expect(await get()).toBe(1);
11
- expect(await get()).toBe(1);
12
- expect(n).toBe(1);
13
- });
14
-
15
- test("concurrent first calls share one build", async () => {
16
- let n = 0;
17
- const get = cached(
18
- async () => {
19
- await tick(20);
20
- return ++n;
21
- },
22
- { ttl: 1000 },
23
- );
24
- expect(await Promise.all([get(), get(), get()])).toEqual([1, 1, 1]);
25
- expect(n).toBe(1);
26
- });
27
-
28
- test("an expired value is served at once while one refresh runs", async () => {
29
- let n = 0;
30
- const get = cached(
31
- async () => {
32
- await tick(30);
33
- return ++n;
34
- },
35
- { ttl: 20 },
36
- );
37
- await get();
38
- await tick(40);
39
- const t0 = performance.now();
40
- expect(await get()).toBe(1); // stale, instantly
41
- expect(await get()).toBe(1); // refresh still in flight, still one
42
- expect(performance.now() - t0).toBeLessThan(25);
43
- await tick(50);
44
- expect(n).toBe(2);
45
- expect(await get()).toBe(2);
46
- });
47
-
48
- test("past staleFor the caller waits for the fresh value", async () => {
49
- let n = 0;
50
- const get = cached(async () => ++n, { ttl: 10, staleFor: 10 });
51
- await get();
52
- await tick(40);
53
- expect(await get()).toBe(2);
54
- });
55
-
56
- test("a failed background refresh keeps the stale value and reports it", async () => {
57
- let n = 0;
58
- const errors: unknown[] = [];
59
- const get = cached(
60
- async () => {
61
- if (++n > 1) throw new Error("upstream down");
62
- return "v1";
63
- },
64
- { ttl: 10, onError: (e) => errors.push(e) },
65
- );
66
- await get();
67
- await tick(20);
68
- expect(await get()).toBe("v1");
69
- await tick(10);
70
- expect(errors).toHaveLength(1);
71
- expect(await get()).toBe("v1");
72
- });
73
-
74
- test("a failed first build throws and is not cached", async () => {
75
- let n = 0;
76
- const get = cached(
77
- async () => {
78
- if (++n === 1) throw new Error("first fails");
79
- return "ok";
80
- },
81
- { ttl: 1000 },
82
- );
83
- await expect(get()).rejects.toThrow("first fails");
84
- expect(await get()).toBe("ok");
85
- });
86
-
87
- test("invalidate forces the next call to rebuild", async () => {
88
- let n = 0;
89
- const get = cached(async () => ++n, { ttl: 1000 });
90
- await get();
91
- get.invalidate();
92
- expect(await get()).toBe(2);
93
- });
94
- });
95
-
96
- describe("cachedBy", () => {
97
- test("caches per argument and evicts the least recently used past max", async () => {
98
- const calls: string[] = [];
99
- const get = cachedBy(
100
- async (id: string) => {
101
- calls.push(id);
102
- return id.toUpperCase();
103
- },
104
- { ttl: 1000, max: 2 },
105
- );
106
- await get("a");
107
- await get("b");
108
- await get("a"); // hit: "b" is now the least recently used
109
- expect(calls).toEqual(["a", "b"]);
110
- await get("c"); // pushes out "b", not "a"
111
- await get("a");
112
- expect(calls).toEqual(["a", "b", "c"]);
113
- await get("b");
114
- expect(calls).toEqual(["a", "b", "c", "b"]);
115
- });
116
-
117
- test("invalidate(key) drops only that key", async () => {
118
- let n = 0;
119
- const get = cachedBy(async (_id: string) => ++n, { ttl: 1000 });
120
- await get("x");
121
- await get("y");
122
- get.invalidate("x");
123
- expect(await get("y")).toBe(2);
124
- expect(await get("x")).toBe(3);
125
- });
126
- });
1
+ import { describe, expect, test } from "bun:test";
2
+ import { cached, cachedBy } from "../src/server/cached.ts";
3
+
4
+ const tick = (ms: number) => Bun.sleep(ms);
5
+
6
+ describe("cached", () => {
7
+ test("returns the same value while fresh and builds once", async () => {
8
+ let n = 0;
9
+ const get = cached(async () => ++n, { ttl: 1000 });
10
+ expect(await get()).toBe(1);
11
+ expect(await get()).toBe(1);
12
+ expect(n).toBe(1);
13
+ });
14
+
15
+ test("concurrent first calls share one build", async () => {
16
+ let n = 0;
17
+ const get = cached(
18
+ async () => {
19
+ await tick(20);
20
+ return ++n;
21
+ },
22
+ { ttl: 1000 },
23
+ );
24
+ expect(await Promise.all([get(), get(), get()])).toEqual([1, 1, 1]);
25
+ expect(n).toBe(1);
26
+ });
27
+
28
+ test("an expired value is served at once while one refresh runs", async () => {
29
+ let n = 0;
30
+ const get = cached(
31
+ async () => {
32
+ await tick(30);
33
+ return ++n;
34
+ },
35
+ { ttl: 20 },
36
+ );
37
+ await get();
38
+ await tick(40);
39
+ const t0 = performance.now();
40
+ expect(await get()).toBe(1); // stale, instantly
41
+ expect(await get()).toBe(1); // refresh still in flight, still one
42
+ expect(performance.now() - t0).toBeLessThan(25);
43
+ await tick(50);
44
+ expect(n).toBe(2);
45
+ expect(await get()).toBe(2);
46
+ });
47
+
48
+ test("past staleFor the caller waits for the fresh value", async () => {
49
+ let n = 0;
50
+ const get = cached(async () => ++n, { ttl: 10, staleFor: 10 });
51
+ await get();
52
+ await tick(40);
53
+ expect(await get()).toBe(2);
54
+ });
55
+
56
+ test("a failed background refresh keeps the stale value and reports it", async () => {
57
+ let n = 0;
58
+ const errors: unknown[] = [];
59
+ const get = cached(
60
+ async () => {
61
+ if (++n > 1) throw new Error("upstream down");
62
+ return "v1";
63
+ },
64
+ { ttl: 10, onError: (e) => errors.push(e) },
65
+ );
66
+ await get();
67
+ await tick(20);
68
+ expect(await get()).toBe("v1");
69
+ await tick(10);
70
+ expect(errors).toHaveLength(1);
71
+ expect(await get()).toBe("v1");
72
+ });
73
+
74
+ test("a failed first build throws and is not cached", async () => {
75
+ let n = 0;
76
+ const get = cached(
77
+ async () => {
78
+ if (++n === 1) throw new Error("first fails");
79
+ return "ok";
80
+ },
81
+ { ttl: 1000 },
82
+ );
83
+ await expect(get()).rejects.toThrow("first fails");
84
+ expect(await get()).toBe("ok");
85
+ });
86
+
87
+ test("invalidate forces the next call to rebuild", async () => {
88
+ let n = 0;
89
+ const get = cached(async () => ++n, { ttl: 1000 });
90
+ await get();
91
+ get.invalidate();
92
+ expect(await get()).toBe(2);
93
+ });
94
+ });
95
+
96
+ describe("cachedBy", () => {
97
+ test("caches per argument and evicts the least recently used past max", async () => {
98
+ const calls: string[] = [];
99
+ const get = cachedBy(
100
+ async (id: string) => {
101
+ calls.push(id);
102
+ return id.toUpperCase();
103
+ },
104
+ { ttl: 1000, max: 2 },
105
+ );
106
+ await get("a");
107
+ await get("b");
108
+ await get("a"); // hit: "b" is now the least recently used
109
+ expect(calls).toEqual(["a", "b"]);
110
+ await get("c"); // pushes out "b", not "a"
111
+ await get("a");
112
+ expect(calls).toEqual(["a", "b", "c"]);
113
+ await get("b");
114
+ expect(calls).toEqual(["a", "b", "c", "b"]);
115
+ });
116
+
117
+ test("invalidate(key) drops only that key", async () => {
118
+ let n = 0;
119
+ const get = cachedBy(async (_id: string) => ++n, { ttl: 1000 });
120
+ await get("x");
121
+ await get("y");
122
+ get.invalidate("x");
123
+ expect(await get("y")).toBe(2);
124
+ expect(await get("x")).toBe(3);
125
+ });
126
+ });