@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

main
ts 274 lines 10.8 KB
Raw
1 import * as Cloudflare from "@alchemy.run/cloudflare";
2 import { CloudflareEnvironment } from "@alchemy.run/cloudflare/CloudflareEnvironment";
3 import { describe, expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as vectorize from "@distilled.cloud/cloudflare/vectorize";
6 import * as Provider from "alchemy/Provider";
7 import { poll } from "alchemy/Util/poll";
8 import * as Effect from "effect/Effect";
9 import { MinimumLogLevel } from "effect/References";
10 import * as Schedule from "effect/Schedule";
11 import { waitForMetadata } from "./Readiness.ts";
12
13 const { test } = Test.make({ providers: Cloudflare.providers() });
14
15 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
16
17 // Bounded typed wait for a parent VectorizeIndex to actually disappear from
18 // Cloudflare after a delete/replace. Index deletes are quick; allow eight
19 // retries before surfacing the last observed state as a `PredicateFailed`.
20 const waitForIndexGone = (accountId: string, indexName: string) =>
21 poll({
22 description: `parent index ${indexName} is gone`,
23 effect: vectorize.getIndex({ accountId, indexName }).pipe(
24 Effect.timeout("5 seconds"),
25 Effect.as(false),
26 Effect.catchTag(["NotFound", "Gone"], () => Effect.succeed(true)),
27 ),
28 predicate: (gone) => gone,
29 schedule: Schedule.max([Schedule.spaced("2 seconds"), Schedule.recurs(8)]),
30 });
31
32 describe.skipIf(!!process.env.FAST)(
33 "Cloudflare.Vectorize.MetadataIndex",
34 { tags: ["provider:cloudflare", "provider:cloudflare:vectorize", "live"] },
35 () => {
36 test.provider(
37 "create and delete a metadata index",
38 (stack) =>
39 Effect.gen(function* () {
40 const { accountId } = yield* yield* CloudflareEnvironment;
41
42 yield* stack.destroy();
43
44 const { index, meta } = yield* stack.deploy(
45 Effect.gen(function* () {
46 const index = yield* Cloudflare.Vectorize.Index("ParentIdx", {
47 dimensions: 32,
48 metric: "cosine",
49 });
50 const meta = yield* Cloudflare.Vectorize.MetadataIndex("MetaIdx", {
51 indexName: index.indexName,
52 propertyName: "category",
53 indexType: "string",
54 });
55 return { index, meta };
56 }),
57 );
58
59 expect(meta.propertyName).toBe("category");
60 expect(meta.indexType).toBe("string");
61 expect(meta.indexName).toBe(index.indexName);
62
63 // The metadata index appears in the parent's list once Cloudflare
64 // processes the async mutation.
65 const entries = yield* waitForMetadata(accountId, index.indexName, [meta]);
66 expect(entries.find((e) => e.propertyName === "category")?.indexType?.toLowerCase()).toBe(
67 "string",
68 );
69
70 yield* stack.destroy();
71
72 // Both parent and metadata index are gone.
73 const after = yield* listMetadataIndexes(accountId, index.indexName);
74 expect(after.length).toBe(0);
75 }).pipe(Effect.ensuring(stack.destroy().pipe(Effect.orDie).pipe(Effect.ignore)), logLevel),
76 { timeout: 210_000 },
77 );
78
79 test.provider(
80 "multiple metadata indexes on the same parent coexist",
81 (stack) =>
82 Effect.gen(function* () {
83 const { accountId } = yield* yield* CloudflareEnvironment;
84
85 yield* stack.destroy();
86
87 const { index, category, price } = yield* stack.deploy(
88 Effect.gen(function* () {
89 const index = yield* Cloudflare.Vectorize.Index("MultiParent", {
90 dimensions: 32,
91 metric: "cosine",
92 });
93 const category = yield* Cloudflare.Vectorize.MetadataIndex("CategoryMeta", {
94 indexName: index.indexName,
95 propertyName: "category",
96 indexType: "string",
97 });
98 const price = yield* Cloudflare.Vectorize.MetadataIndex("PriceMeta", {
99 indexName: index.indexName,
100 propertyName: "price",
101 indexType: "number",
102 });
103 return { index, category, price };
104 }),
105 );
106 const entries = yield* waitForMetadata(accountId, index.indexName, [category, price]);
107 expect(entries.find((e) => e.propertyName === "category")?.indexType?.toLowerCase()).toBe(
108 "string",
109 );
110 expect(entries.find((e) => e.propertyName === "price")?.indexType?.toLowerCase()).toBe(
111 "number",
112 );
113
114 yield* stack.destroy();
115 }).pipe(
116 // Guarantee teardown even if a poll/assertion fails or the test is
117 // interrupted by a timeout — the scratch stack's state is in-memory
118 // only, so a body that throws before the trailing `destroy()` would
119 // otherwise leak the parent + metadata indexes with no next-run
120 // cleanup.
121 Effect.ensuring(stack.destroy().pipe(Effect.orDie).pipe(Effect.ignore)),
122 logLevel,
123 ),
124 { timeout: 210_000 },
125 );
126
127 test.provider(
128 "replacing the parent index also replaces the metadata index",
129 (stack) =>
130 Effect.gen(function* () {
131 const { accountId } = yield* yield* CloudflareEnvironment;
132
133 yield* stack.destroy();
134
135 // Initial deploy with dimensions=32.
136 const { index: oldIndex } = yield* stack.deploy(
137 Effect.gen(function* () {
138 const index = yield* Cloudflare.Vectorize.Index("ReplaceParent", {
139 dimensions: 32,
140 metric: "cosine",
141 });
142 yield* Cloudflare.Vectorize.MetadataIndex("ReplaceMeta", {
143 indexName: index.indexName,
144 propertyName: "tag",
145 indexType: "string",
146 });
147 return { index };
148 }),
149 );
150 // Replacement must also work while the old metadata mutation is pending.
151
152 // Re-deploy with different dimensions — the parent replaces, which
153 // also replaces the metadata index on the new parent.
154 const { index: newIndex, meta: newMeta } = yield* stack.deploy(
155 Effect.gen(function* () {
156 const index = yield* Cloudflare.Vectorize.Index("ReplaceParent", {
157 dimensions: 64,
158 metric: "cosine",
159 });
160 const meta = yield* Cloudflare.Vectorize.MetadataIndex("ReplaceMeta", {
161 indexName: index.indexName,
162 propertyName: "tag",
163 indexType: "string",
164 });
165 return { index, meta };
166 }),
167 );
168
169 expect(newIndex.indexName).not.toBe(oldIndex.indexName);
170 expect(newMeta.indexName).toBe(newIndex.indexName);
171
172 // Old parent is gone — bounded typed wait for the replacement's
173 // delete of the old index to settle.
174 const oldGone = yield* waitForIndexGone(accountId, oldIndex.indexName);
175 expect(oldGone).toBe(true);
176
177 // The new parent has the metadata index.
178 yield* waitForMetadata(accountId, newIndex.indexName, [newMeta]);
179
180 yield* stack.destroy();
181 }).pipe(Effect.ensuring(stack.destroy().pipe(Effect.orDie).pipe(Effect.ignore)), logLevel),
182 { timeout: 210_000 },
183 );
184
185 test.provider(
186 "list enumerates the deployed metadata index",
187 (stack) =>
188 Effect.gen(function* () {
189 yield* stack.destroy();
190
191 const { index, meta } = yield* stack.deploy(
192 Effect.gen(function* () {
193 const index = yield* Cloudflare.Vectorize.Index("ListParent", {
194 dimensions: 32,
195 metric: "cosine",
196 });
197 const meta = yield* Cloudflare.Vectorize.MetadataIndex("ListMeta", {
198 indexName: index.indexName,
199 propertyName: "category",
200 indexType: "string",
201 });
202 return { index, meta };
203 }),
204 );
205
206 const provider = yield* Provider.findProvider(Cloudflare.Vectorize.MetadataIndex);
207
208 const { accountId } = yield* yield* CloudflareEnvironment;
209 yield* waitForMetadata(accountId, index.indexName, [meta]);
210 const all = yield* provider.list().pipe(Effect.timeout("20 seconds"));
211
212 const entry = all.find(
213 (x) => x.indexName === index.indexName && x.propertyName === "category",
214 );
215 expect(entry?.indexType).toBe("string");
216 expect(entry?.accountId).toBeDefined();
217
218 yield* stack.destroy();
219 }).pipe(Effect.ensuring(stack.destroy().pipe(Effect.orDie).pipe(Effect.ignore)), logLevel),
220 { timeout: 210_000 },
221 );
222
223 test.provider(
224 "destroy is idempotent when the parent index was deleted out-of-band",
225 (stack) =>
226 Effect.gen(function* () {
227 const { accountId } = yield* yield* CloudflareEnvironment;
228
229 yield* stack.destroy();
230
231 const { index } = yield* stack.deploy(
232 Effect.gen(function* () {
233 const index = yield* Cloudflare.Vectorize.Index("OobParent", {
234 dimensions: 32,
235 metric: "cosine",
236 });
237 yield* Cloudflare.Vectorize.MetadataIndex("OobMeta", {
238 indexName: index.indexName,
239 propertyName: "ns",
240 indexType: "string",
241 });
242 return { index };
243 }),
244 );
245 // Simulate Cloudflare's cascading delete: drop the parent directly.
246 // On Cloudflare's side this also removes the metadata index.
247 // Deletion must work even while the metadata mutation is pending;
248 // waiting for query visibility is not a prerequisite for teardown.
249 yield* vectorize.deleteIndex({ accountId, indexName: index.indexName });
250
251 // Bounded typed wait for the out-of-band delete to actually settle
252 // before exercising the idempotent `destroy` path.
253 const gone = yield* waitForIndexGone(accountId, index.indexName);
254 expect(gone).toBe(true);
255
256 // The metadata index provider's delete tolerates 404/410 from the
257 // missing parent, so `destroy` succeeds without erroring.
258 yield* stack.destroy();
259 }).pipe(Effect.ensuring(stack.destroy().pipe(Effect.orDie).pipe(Effect.ignore)), logLevel),
260 { timeout: 210_000 },
261 );
262 },
263 );
264
265 const listMetadataIndexes = Effect.fn(function* (accountId: string, indexName: string) {
266 return yield* vectorize.listIndexMetadataIndexes({ accountId, indexName }).pipe(
267 Effect.timeout("5 seconds"),
268 Effect.map((res) => res.metadataIndexes ?? []),
269 Effect.catchTag(["NotFound", "Gone"], () =>
270 // Parent index gone — treat as "no metadata indexes".
271 Effect.succeed([]),
272 ),
273 );
274 });