cloudrop 0.1.1 → 0.3.0

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 (50) hide show
  1. package/CHANGELOG.md +115 -0
  2. package/README.md +34 -4
  3. package/dist/adapters/drizzle.d.ts +1 -1
  4. package/dist/adapters/drizzle.js +3 -3
  5. package/dist/adapters/drizzle.js.map +1 -1
  6. package/dist/adapters/prisma.d.ts +1 -1
  7. package/dist/adapters/prisma.js +1 -1
  8. package/dist/adapters/sql.d.ts +4 -1
  9. package/dist/adapters/sql.js +8 -1
  10. package/dist/adapters/sql.js.map +1 -1
  11. package/dist/cli.js +2045 -0
  12. package/dist/{client-Dj6ON4MN.d.ts → client-CP_ajLF4.d.ts} +43 -25
  13. package/dist/{client-Y1zUEbCj.js → client-DxP3uv8V.js} +172 -44
  14. package/dist/client-DxP3uv8V.js.map +1 -0
  15. package/dist/client.d.ts +3 -3
  16. package/dist/client.js +1 -1
  17. package/dist/errors-CUxMmFAe.js.map +1 -1
  18. package/dist/index.d.ts +92 -7
  19. package/dist/index.js +432 -152
  20. package/dist/index.js.map +1 -1
  21. package/dist/next.d.ts +1 -1
  22. package/dist/node.d.ts +1 -1
  23. package/dist/react.d.ts +18 -4
  24. package/dist/react.js +23 -3
  25. package/dist/react.js.map +1 -1
  26. package/dist/{route-CspI1Ypt.js → route-C8-YjzdY.js} +3 -2
  27. package/dist/{route-CspI1Ypt.js.map → route-C8-YjzdY.js.map} +1 -1
  28. package/dist/{store-BfCJejGh.d.ts → store-B539nY3J.d.ts} +41 -3
  29. package/dist/testing.d.ts +81 -0
  30. package/dist/testing.js +1243 -0
  31. package/dist/testing.js.map +1 -0
  32. package/dist/{transactional-DnvnGsVH.js → transactional-CiNwMiDb.js} +215 -105
  33. package/dist/transactional-CiNwMiDb.js.map +1 -0
  34. package/dist/{types-BrAx3dA4.d.ts → types-CFfMw-n_.d.ts} +1 -1
  35. package/docs/README.md +30 -0
  36. package/docs/bucket-setup.md +226 -0
  37. package/docs/client.md +386 -0
  38. package/docs/command.md +129 -0
  39. package/docs/deployment.md +169 -0
  40. package/docs/errors.md +150 -0
  41. package/docs/hono.md +276 -0
  42. package/docs/react.md +508 -0
  43. package/docs/resume.md +253 -0
  44. package/docs/server.md +603 -0
  45. package/docs/store.md +804 -0
  46. package/docs/testing-your-app.md +328 -0
  47. package/docs/troubleshooting.md +176 -0
  48. package/package.json +16 -8
  49. package/dist/client-Y1zUEbCj.js.map +0 -1
  50. package/dist/transactional-DnvnGsVH.js.map +0 -1
@@ -0,0 +1,1243 @@
1
+ import { createCloudropClient } from "./client.js";
2
+ import { CloudropError, r2, route } from "./index.js";
3
+ // src/storage/xml.ts
4
+ const ENTITIES = {
5
+ amp: "&",
6
+ lt: "<",
7
+ gt: ">",
8
+ quot: "\"",
9
+ apos: "'"
10
+ };
11
+ const ESCAPES = {
12
+ "<": "&lt;",
13
+ ">": "&gt;",
14
+ "&": "&amp;",
15
+ "\"": "&quot;",
16
+ "'": "&apos;"
17
+ };
18
+ function decodeXml(text) {
19
+ return text.replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (match, entity) => {
20
+ if (!entity.startsWith("#")) return ENTITIES[entity] ?? "";
21
+ const codePoint = entity[1] === "x" ? Number.parseInt(entity.slice(2), 16) : Number.parseInt(entity.slice(1), 10);
22
+ return Number.isFinite(codePoint) && codePoint <= 1114111 ? String.fromCodePoint(codePoint) : match;
23
+ });
24
+ }
25
+ function xmlBlocks(xml, tag) {
26
+ const pattern = new RegExp(`<${tag}(?:\\s[^>]*)?(?<!/)>([\\s\\S]*?)</${tag}>`, "g");
27
+ return Array.from(xml.matchAll(pattern), (match) => match[1] ?? "");
28
+ }
29
+ function xmlText(xml, tag) {
30
+ const block = xmlBlocks(xml, tag)[0];
31
+ return block === void 0 ? void 0 : decodeXml(block);
32
+ }
33
+ function stripQuotes(value) {
34
+ return value.replaceAll("\"", "");
35
+ }
36
+ function escapeXml(value) {
37
+ return value.replace(/[<>&"']/g, (char) => ESCAPES[char] ?? char);
38
+ }
39
+ // src/checksum.ts
40
+ const POLYNOMIAL = 2197175160;
41
+ const TABLES = (() => {
42
+ const tables = /* @__PURE__ */ new Uint32Array(2048);
43
+ for (let index = 0; index < 256; index++) {
44
+ let value = index;
45
+ for (let bit = 0; bit < 8; bit++) value = value & 1 ? value >>> 1 ^ POLYNOMIAL : value >>> 1;
46
+ tables[index] = value >>> 0;
47
+ }
48
+ for (let index = 0; index < 256; index++) {
49
+ let value = tables[index];
50
+ for (let row = 1; row < 8; row++) {
51
+ value = tables[value & 255] ^ value >>> 8;
52
+ tables[row * 256 + index] = value >>> 0;
53
+ }
54
+ }
55
+ return tables;
56
+ })();
57
+ function crc32c(bytes, previous = 0) {
58
+ let crc = ~previous >>> 0;
59
+ let index = 0;
60
+ const blockEnd = bytes.length - 8;
61
+ for (; index <= blockEnd; index += 8) {
62
+ const low = crc ^ bytes[index] ^ bytes[index + 1] << 8 ^ bytes[index + 2] << 16 ^ bytes[index + 3] << 24;
63
+ crc = (TABLES[1792 + (low & 255)] ^ TABLES[1536 + (low >>> 8 & 255)] ^ TABLES[1280 + (low >>> 16 & 255)] ^ TABLES[1024 + (low >>> 24)] ^ TABLES[768 + bytes[index + 4]] ^ TABLES[512 + bytes[index + 5]] ^ TABLES[256 + bytes[index + 6]] ^ TABLES[bytes[index + 7]]) >>> 0;
64
+ }
65
+ for (; index < bytes.length; index++) crc = TABLES[(crc ^ bytes[index]) & 255] ^ crc >>> 8;
66
+ return ~crc >>> 0;
67
+ }
68
+ function crc32cBase64(bytes) {
69
+ const value = crc32c(bytes);
70
+ return btoa(String.fromCharCode(value >>> 24, value >>> 16 & 255, value >>> 8 & 255, value & 255));
71
+ }
72
+ // src/rules.ts
73
+ const MiB = 1048576;
74
+ const GiB = 1024 * MiB;
75
+ const R2_RULES = {
76
+ minPartSize: 5 * MiB,
77
+ maxPartSize: 5 * GiB - 5 * MiB,
78
+ maxParts: 1e4,
79
+ maxSinglePutSize: 5 * GiB - 5 * MiB,
80
+ maxObjectSize: 5 * (1024 * GiB) - 5 * GiB,
81
+ maxPresignSeconds: 604800
82
+ };
83
+ // src/storage/sigv4.ts
84
+ const encoder = new TextEncoder();
85
+ const UNSIGNED_PAYLOAD = "UNSIGNED-PAYLOAD";
86
+ function toHex(bytes) {
87
+ const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
88
+ return Array.from(view, (byte) => byte.toString(16).padStart(2, "0")).join("");
89
+ }
90
+ async function sha256Hex(data) {
91
+ const bytes = typeof data === "string" ? encoder.encode(data) : data;
92
+ return toHex(await crypto.subtle.digest("SHA-256", bytes));
93
+ }
94
+ function importHmacKey(raw) {
95
+ return crypto.subtle.importKey("raw", raw, {
96
+ name: "HMAC",
97
+ hash: "SHA-256"
98
+ }, false, ["sign"]);
99
+ }
100
+ async function hmac(key, data) {
101
+ return new Uint8Array(await crypto.subtle.sign("HMAC", key, encoder.encode(data)));
102
+ }
103
+ async function deriveSigningKey(secretAccessKey, day, region) {
104
+ let raw = await hmac(await importHmacKey(encoder.encode(`AWS4${secretAccessKey}`)), day);
105
+ for (const part of [
106
+ region,
107
+ "s3",
108
+ "aws4_request"
109
+ ]) raw = await hmac(await importHmacKey(raw), part);
110
+ return importHmacKey(raw);
111
+ }
112
+ const signingKeys = /* @__PURE__ */ new WeakMap();
113
+ const MAX_CACHED_SCOPES = 8;
114
+ function signingKey(credentials, day, region) {
115
+ let cached = signingKeys.get(credentials);
116
+ if (cached?.secretAccessKey !== credentials.secretAccessKey) {
117
+ cached = {
118
+ secretAccessKey: credentials.secretAccessKey,
119
+ byScope: /* @__PURE__ */ new Map()
120
+ };
121
+ signingKeys.set(credentials, cached);
122
+ }
123
+ const scope = `${day}/${region}`;
124
+ let derived = cached.byScope.get(scope);
125
+ if (!derived) {
126
+ const { byScope } = cached;
127
+ if (byScope.size >= MAX_CACHED_SCOPES) byScope.clear();
128
+ derived = deriveSigningKey(credentials.secretAccessKey, day, region);
129
+ derived.catch(() => byScope.delete(scope));
130
+ byScope.set(scope, derived);
131
+ }
132
+ return derived;
133
+ }
134
+ function encodeRfc3986(value) {
135
+ return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
136
+ }
137
+ function toAmzDate(date) {
138
+ return date.toISOString().replace(/[-:]|\.\d{3}/g, "");
139
+ }
140
+ function canonicalPath(url) {
141
+ return url.pathname.split("/").map((segment) => encodeRfc3986(decodeURIComponent(segment))).join("/");
142
+ }
143
+ function canonicalQuery(params) {
144
+ return Array.from(params, ([name, value]) => [encodeRfc3986(name), encodeRfc3986(value)]).sort(([aName, aValue], [bName, bValue]) => {
145
+ if (aName !== bName) return aName < bName ? -1 : 1;
146
+ if (aValue === bValue) return 0;
147
+ return aValue < bValue ? -1 : 1;
148
+ }).map(([name, value]) => `${name}=${value}`).join("&");
149
+ }
150
+ function canonicalHeaders(url, headers) {
151
+ const all = { host: url.host };
152
+ for (const [name, value] of Object.entries(headers)) all[name.toLowerCase()] = value.trim().replace(/\s+/g, " ");
153
+ const names = Object.keys(all).sort();
154
+ return {
155
+ canonical: names.map((name) => `${name}:${all[name]}\n`).join(""),
156
+ signedHeaders: names.join(";")
157
+ };
158
+ }
159
+ async function sign(input, amzDate, scope, canonicalRequest) {
160
+ const stringToSign = [
161
+ "AWS4-HMAC-SHA256",
162
+ amzDate,
163
+ scope,
164
+ await sha256Hex(canonicalRequest)
165
+ ].join("\n");
166
+ return toHex(await hmac(await signingKey(input.credentials, amzDate.slice(0, 8), input.region), stringToSign));
167
+ }
168
+ async function presignUrl(input) {
169
+ const amzDate = toAmzDate(input.date);
170
+ const scope = `${amzDate.slice(0, 8)}/${input.region}/s3/aws4_request`;
171
+ const { canonical, signedHeaders } = canonicalHeaders(input.url, input.headers ?? {});
172
+ const url = new URL(input.url);
173
+ url.searchParams.set("X-Amz-Algorithm", "AWS4-HMAC-SHA256");
174
+ url.searchParams.set("X-Amz-Credential", `${input.credentials.accessKeyId}/${scope}`);
175
+ url.searchParams.set("X-Amz-Date", amzDate);
176
+ url.searchParams.set("X-Amz-Expires", String(input.expiresIn));
177
+ url.searchParams.set("X-Amz-SignedHeaders", signedHeaders);
178
+ const query = canonicalQuery(url.searchParams);
179
+ url.search = `${query}&X-Amz-Signature=${await sign(input, amzDate, scope, [
180
+ input.method,
181
+ canonicalPath(url),
182
+ query,
183
+ canonical,
184
+ signedHeaders,
185
+ UNSIGNED_PAYLOAD
186
+ ].join("\n"))}`;
187
+ return url;
188
+ }
189
+ async function signRequest(input) {
190
+ const amzDate = toAmzDate(input.date);
191
+ const scope = `${amzDate.slice(0, 8)}/${input.region}/s3/aws4_request`;
192
+ const headers = {
193
+ ...input.headers,
194
+ "x-amz-content-sha256": input.payloadHash,
195
+ "x-amz-date": amzDate
196
+ };
197
+ const { canonical, signedHeaders } = canonicalHeaders(input.url, headers);
198
+ const signature = await sign(input, amzDate, scope, [
199
+ input.method,
200
+ canonicalPath(input.url),
201
+ canonicalQuery(input.url.searchParams),
202
+ canonical,
203
+ signedHeaders,
204
+ input.payloadHash
205
+ ].join("\n"));
206
+ return {
207
+ ...headers,
208
+ authorization: `AWS4-HMAC-SHA256 Credential=${input.credentials.accessKeyId}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`
209
+ };
210
+ }
211
+ // src/testing/fake-r2/responses.ts
212
+ const XML_HEADERS = { "content-type": "application/xml" };
213
+ function xmlResponse(body, status = 200) {
214
+ return new Response(`<?xml version="1.0" encoding="UTF-8"?>${body}`, {
215
+ status,
216
+ headers: XML_HEADERS
217
+ });
218
+ }
219
+ function errorResponse(status, code, message) {
220
+ return xmlResponse(`<Error><Code>${code}</Code><Message>${escapeXml(message)}</Message></Error>`, status);
221
+ }
222
+ const noSuchUpload = () => errorResponse(404, "NoSuchUpload", "The specified multipart upload does not exist.");
223
+ const clockSkewed = () => errorResponse(403, "RequestTimeTooSkewed", "The difference between the request time and the server time is too large.");
224
+ const preconditionFailed = () => errorResponse(412, "PreconditionFailed", "At least one of the pre-conditions you specified did not hold.");
225
+ // src/testing/fake-r2/bucket.ts
226
+ const META_PREFIX = "x-amz-meta-";
227
+ const MAX_LIST_PAGE = 1e3;
228
+ async function etagOf(body) {
229
+ return (await sha256Hex(body)).slice(0, 32);
230
+ }
231
+ function readHeaders(headers) {
232
+ const metadata = {};
233
+ headers.forEach((value, name) => {
234
+ if (name.startsWith("x-amz-meta-")) metadata[name.slice(11)] = value;
235
+ });
236
+ return {
237
+ type: headers.get("content-type") ?? void 0,
238
+ disposition: headers.get("content-disposition") ?? void 0,
239
+ metadata
240
+ };
241
+ }
242
+ function checksumMismatch(headers, body) {
243
+ const expected = headers.get("x-amz-checksum-crc32c");
244
+ if (expected === null || expected === crc32cBase64(body)) return null;
245
+ return errorResponse(400, "BadDigest", "The CRC32C you specified did not match the calculated checksum.");
246
+ }
247
+ function findUpload(bucket, key, query) {
248
+ const upload = bucket.uploads.get(query.get("uploadId") ?? "");
249
+ return upload && upload.key === key ? upload : void 0;
250
+ }
251
+ function readPartNumber(query) {
252
+ const partNumber = Number(query.get("partNumber"));
253
+ if (Number.isInteger(partNumber) && partNumber >= 1 && partNumber <= R2_RULES.maxParts) return partNumber;
254
+ return errorResponse(400, "InvalidArgument", "Part number must be an integer between 1 and 10000.");
255
+ }
256
+ // src/testing/fake-r2/copy.ts
257
+ function copySource(bucket, headers) {
258
+ const [sourceBucket = "", ...sourceSegments] = (headers.get("x-amz-copy-source") ?? "").replace(/^\//, "").split("/");
259
+ const source = decodeURIComponent(sourceBucket) === bucket.name ? bucket.objects.get(sourceSegments.map(decodeURIComponent).join("/")) : void 0;
260
+ if (!source) return errorResponse(404, "NoSuchKey", "The copy source does not exist.");
261
+ const ifMatch = headers.get("x-amz-copy-source-if-match");
262
+ if (ifMatch !== null && stripQuotes(ifMatch) !== source.etag) return preconditionFailed();
263
+ return source;
264
+ }
265
+ function copiedRange(source, rangeHeader) {
266
+ if (rangeHeader === null) return source.body;
267
+ const range = /^bytes=(\d+)-(\d+)$/.exec(rangeHeader);
268
+ const [start, end] = [Number(range?.[1]), Number(range?.[2])];
269
+ if (!range || start > end || end >= source.body.length) return errorResponse(400, "InvalidArgument", "The copy source range is malformed or outside the source object.");
270
+ return source.body.subarray(start, end + 1);
271
+ }
272
+ async function copyPart(bucket, { key, query, headers }, source) {
273
+ const upload = findUpload(bucket, key, query);
274
+ if (!upload) return noSuchUpload();
275
+ const partNumber = readPartNumber(query);
276
+ if (partNumber instanceof Response) return partNumber;
277
+ const body = copiedRange(source, headers.get("x-amz-copy-source-range"));
278
+ if (body instanceof Response) return body;
279
+ const etag = await etagOf(body);
280
+ upload.parts.set(partNumber, {
281
+ body,
282
+ etag,
283
+ checksumCrc32c: void 0,
284
+ uploadedAt: bucket.now()
285
+ });
286
+ return xmlResponse(`<CopyPartResult><ETag>"${etag}"</ETag></CopyPartResult>`);
287
+ }
288
+ async function copyObject(bucket, { key, headers }, source) {
289
+ const replaced = headers.get("x-amz-metadata-directive") === "REPLACE";
290
+ const etag = await etagOf(source.body);
291
+ bucket.objects.set(key, {
292
+ body: source.body,
293
+ headers: replaced ? readHeaders(headers) : source.headers,
294
+ etag,
295
+ uploadedAt: bucket.now()
296
+ });
297
+ return xmlResponse(`<CopyObjectResult><ETag>"${etag}"</ETag></CopyObjectResult>`);
298
+ }
299
+ async function copy(bucket, request) {
300
+ const source = copySource(bucket, request.headers);
301
+ if (source instanceof Response) return source;
302
+ return request.query.has("uploadId") ? copyPart(bucket, request, source) : copyObject(bucket, request, source);
303
+ }
304
+ function bucketConfig(bucket, name) {
305
+ if (!bucket.config) return errorResponse(403, "AccessDenied", "Access Denied");
306
+ const xml = bucket.config[name];
307
+ if (xml !== void 0) return xmlResponse(xml);
308
+ return errorResponse(404, name === "cors" ? "NoSuchCORSConfiguration" : "NoSuchLifecycleConfiguration", "The bucket has no such configuration.");
309
+ }
310
+ const SHAPES = {
311
+ cors: {
312
+ root: "CORSConfiguration",
313
+ rule: "CORSRule",
314
+ needs: [["AllowedOrigin"], ["AllowedMethod"]]
315
+ },
316
+ lifecycle: {
317
+ root: "LifecycleConfiguration",
318
+ rule: "Rule",
319
+ needs: [["Status"], ["Filter", "Prefix"]]
320
+ }
321
+ };
322
+ function wellFormed(xml, name) {
323
+ const { root, rule, needs } = SHAPES[name];
324
+ const rules = xmlBlocks(xmlBlocks(xml, root)[0] ?? "", rule);
325
+ return rules.length > 0 && rules.every((each) => needs.every((tags) => tags.some((tag) => each.includes(`<${tag}`))));
326
+ }
327
+ async function putBucketConfig(bucket, name, { headers, body }) {
328
+ if (!bucket.config) return errorResponse(403, "AccessDenied", "Access Denied");
329
+ const sha256 = headers.get("x-amz-checksum-sha256");
330
+ if (sha256 === null) return errorResponse(400, "InvalidRequest", "Missing required header for this request: Content-MD5");
331
+ const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", body));
332
+ if (sha256 !== btoa(String.fromCharCode(...digest))) return errorResponse(400, "BadDigest", "The SHA256 you specified did not match the calculated checksum.");
333
+ const xml = new TextDecoder().decode(body).replace(/^<\?xml[^>]*\?>/, "");
334
+ if (!wellFormed(xml, name)) return errorResponse(400, "MalformedXML", "The XML you provided was not well-formed.");
335
+ bucket.config[name] = xml;
336
+ return new Response(null, { status: 200 });
337
+ }
338
+ // src/testing/fake-r2/multipart.ts
339
+ const utf8$1 = new TextEncoder();
340
+ function concat(chunks) {
341
+ const out = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));
342
+ let offset = 0;
343
+ for (const chunk of chunks) {
344
+ out.set(chunk, offset);
345
+ offset += chunk.length;
346
+ }
347
+ return out;
348
+ }
349
+ function createUpload(bucket, { key, headers }) {
350
+ bucket.uploadCounter += 1;
351
+ const uploadId = `fake/upload+${bucket.uploadCounter}==`;
352
+ bucket.uploads.set(uploadId, {
353
+ key,
354
+ headers: readHeaders(headers),
355
+ parts: /* @__PURE__ */ new Map()
356
+ });
357
+ return xmlResponse(`<InitiateMultipartUploadResult><Bucket>${escapeXml(bucket.name)}</Bucket><Key>${escapeXml(key)}</Key><UploadId>${escapeXml(uploadId)}</UploadId></InitiateMultipartUploadResult>`);
358
+ }
359
+ async function uploadPart(bucket, { key, query, headers, body }) {
360
+ const upload = findUpload(bucket, key, query);
361
+ if (!upload) return noSuchUpload();
362
+ const badChecksum = checksumMismatch(headers, body);
363
+ if (badChecksum) return badChecksum;
364
+ const partNumber = readPartNumber(query);
365
+ if (partNumber instanceof Response) return partNumber;
366
+ const etag = await etagOf(body);
367
+ upload.parts.set(partNumber, {
368
+ body,
369
+ etag,
370
+ checksumCrc32c: headers.get("x-amz-checksum-crc32c") ?? void 0,
371
+ uploadedAt: bucket.now()
372
+ });
373
+ return new Response(null, {
374
+ status: 200,
375
+ headers: { etag: `"${etag}"` }
376
+ });
377
+ }
378
+ function partSizeFailure(parts) {
379
+ const firstSize = parts[0]?.body.length ?? 0;
380
+ for (const [index, part] of parts.entries()) {
381
+ const isLast = index === parts.length - 1;
382
+ if (!isLast && part.body.length < R2_RULES.minPartSize) return errorResponse(400, "EntityTooSmall", "Your proposed upload is smaller than the minimum allowed object size.");
383
+ if (isLast ? part.body.length > firstSize : part.body.length !== firstSize) return errorResponse(400, "InvalidPart", "All non-trailing parts must have the same length.");
384
+ }
385
+ return null;
386
+ }
387
+ function requestedParts(upload, body) {
388
+ const requested = xmlBlocks(new TextDecoder().decode(body), "Part").map((block) => ({
389
+ partNumber: Number(xmlText(block, "PartNumber")),
390
+ etag: stripQuotes(xmlText(block, "ETag") ?? "")
391
+ }));
392
+ if (requested.length === 0) return errorResponse(400, "MalformedXML", "The request lists no parts.");
393
+ const parts = [];
394
+ let previousNumber = 0;
395
+ for (const item of requested) {
396
+ if (item.partNumber <= previousNumber) return errorResponse(400, "InvalidPartOrder", "Parts must be listed in ascending order.");
397
+ previousNumber = item.partNumber;
398
+ const part = upload.parts.get(item.partNumber);
399
+ if (!part || part.etag !== item.etag) return errorResponse(400, "InvalidPart", `Part ${item.partNumber} was not found or its ETag does not match.`);
400
+ parts.push(part);
401
+ }
402
+ return parts;
403
+ }
404
+ async function completeUpload(bucket, { key, query, headers, body }) {
405
+ const uploadId = query.get("uploadId") ?? "";
406
+ const upload = findUpload(bucket, key, query);
407
+ if (!upload) return noSuchUpload();
408
+ const parts = requestedParts(upload, body);
409
+ if (parts instanceof Response) return parts;
410
+ const sizeFailure = partSizeFailure(parts);
411
+ if (sizeFailure) return sizeFailure;
412
+ if (headers.get("if-none-match") === "*" && bucket.objects.has(key)) {
413
+ bucket.uploads.delete(uploadId);
414
+ return preconditionFailed();
415
+ }
416
+ const etag = `${await etagOf(utf8$1.encode(parts.map((part) => part.etag).join("")))}-${parts.length}`;
417
+ bucket.objects.set(key, {
418
+ body: concat(parts.map((part) => part.body)),
419
+ headers: upload.headers,
420
+ etag,
421
+ uploadedAt: bucket.now(),
422
+ partCount: parts.length
423
+ });
424
+ bucket.uploads.delete(uploadId);
425
+ return xmlResponse(`<CompleteMultipartUploadResult><Bucket>${escapeXml(bucket.name)}</Bucket><Key>${escapeXml(key)}</Key><ETag>"${etag}"</ETag></CompleteMultipartUploadResult>`);
426
+ }
427
+ function listParts(bucket, { key, query }) {
428
+ const upload = findUpload(bucket, key, query);
429
+ if (!upload) return noSuchUpload();
430
+ const max = Math.min(Number(query.get("max-parts") ?? 1e3), MAX_LIST_PAGE);
431
+ const marker = Number(query.get("part-number-marker") ?? 0);
432
+ const remaining = Array.from(upload.parts).filter(([number]) => number > marker).sort(([a], [b]) => a - b);
433
+ const page = remaining.slice(0, max);
434
+ const truncated = remaining.length > max;
435
+ const parts = page.map(([number, part]) => {
436
+ const checksum = part.checksumCrc32c ? `<ChecksumCRC32C>${part.checksumCrc32c}</ChecksumCRC32C>` : "";
437
+ return `<Part><PartNumber>${number}</PartNumber><ETag>"${part.etag}"</ETag><Size>${part.body.length}</Size><LastModified>${part.uploadedAt.toISOString()}</LastModified>${checksum}</Part>`;
438
+ }).join("");
439
+ return xmlResponse(`<ListPartsResult><IsTruncated>${truncated}</IsTruncated>${truncated ? `<NextPartNumberMarker>${page.at(-1)?.[0] ?? marker}</NextPartNumberMarker>` : ""}${parts}</ListPartsResult>`);
440
+ }
441
+ function abortUpload(bucket, { key, query }) {
442
+ if (findUpload(bucket, key, query)) bucket.uploads.delete(query.get("uploadId") ?? "");
443
+ return new Response(null, { status: 204 });
444
+ }
445
+ // src/testing/fake-r2/objects.ts
446
+ const utf8 = new TextEncoder();
447
+ function compareKeys(a, b) {
448
+ const left = utf8.encode(a);
449
+ const right = utf8.encode(b);
450
+ for (let index = 0; index < Math.min(left.length, right.length); index++) if (left[index] !== right[index]) return left[index] - right[index];
451
+ return left.length - right.length;
452
+ }
453
+ async function putObject(bucket, { key, headers, body }) {
454
+ const badChecksum = checksumMismatch(headers, body);
455
+ if (badChecksum) return badChecksum;
456
+ if (headers.get("if-none-match") === "*" && bucket.objects.has(key)) return preconditionFailed();
457
+ const etag = await etagOf(body);
458
+ bucket.objects.set(key, {
459
+ body,
460
+ headers: readHeaders(headers),
461
+ etag,
462
+ uploadedAt: bucket.now()
463
+ });
464
+ return new Response(null, {
465
+ status: 200,
466
+ headers: { etag: `"${etag}"` }
467
+ });
468
+ }
469
+ function objectHeaders(object) {
470
+ const headers = new Headers({
471
+ etag: `"${object.etag}"`,
472
+ "last-modified": object.uploadedAt.toUTCString(),
473
+ "content-length": String(object.body.length)
474
+ });
475
+ if (object.headers.type) headers.set("content-type", object.headers.type);
476
+ if (object.headers.disposition) headers.set("content-disposition", object.headers.disposition);
477
+ for (const [name, value] of Object.entries(object.headers.metadata)) headers.set(`${META_PREFIX}${name}`, value);
478
+ if (object.partCount) headers.set("x-amz-mp-parts-count", String(object.partCount));
479
+ return headers;
480
+ }
481
+ const COMPRESSED_TYPES = /* @__PURE__ */ new Set([
482
+ "text/plain",
483
+ "text/html",
484
+ "text/markdown",
485
+ "application/json",
486
+ "application/javascript",
487
+ "application/xml",
488
+ "image/svg+xml",
489
+ "font/ttf",
490
+ "application/wasm"
491
+ ]);
492
+ const SMALLEST_COMPRESSED = 50;
493
+ function compressedHead(object, request, headers) {
494
+ const type = object.headers.type?.split(";")[0]?.trim().toLowerCase() ?? "";
495
+ const wanted = request.get("accept-encoding")?.trim().toLowerCase();
496
+ if (!COMPRESSED_TYPES.has(type) || object.body.length < SMALLEST_COMPRESSED || wanted === "identity") return headers;
497
+ headers.delete("content-length");
498
+ headers.set("content-encoding", "gzip");
499
+ return headers;
500
+ }
501
+ function bodyResponse(object, rangeHeader, headers) {
502
+ const range = /^bytes=(\d+)-(\d+)$/.exec(rangeHeader ?? "");
503
+ if (!range) return new Response(object.body, {
504
+ status: 200,
505
+ headers
506
+ });
507
+ const start = Number(range[1]);
508
+ if (start >= object.body.length || Number(range[2]) < start) return errorResponse(416, "InvalidRange", "The requested range is not satisfiable.");
509
+ const end = Math.min(Number(range[2]), object.body.length - 1);
510
+ const slice = object.body.subarray(start, end + 1);
511
+ headers.set("content-range", `bytes ${start}-${end}/${object.body.length}`);
512
+ headers.set("content-length", String(slice.length));
513
+ return new Response(slice, {
514
+ status: 206,
515
+ headers
516
+ });
517
+ }
518
+ function getObject(bucket, { key, method, headers, query }) {
519
+ const object = bucket.objects.get(key);
520
+ if (!object) return method === "HEAD" ? new Response(null, { status: 404 }) : errorResponse(404, "NoSuchKey", "The specified key does not exist.");
521
+ const responseHeaders = objectHeaders(object);
522
+ if (method === "HEAD") return new Response(null, {
523
+ status: 200,
524
+ headers: compressedHead(object, headers, responseHeaders)
525
+ });
526
+ const disposition = query.get("response-content-disposition");
527
+ if (disposition !== null) responseHeaders.set("content-disposition", disposition);
528
+ return bodyResponse(object, headers.get("range"), responseHeaders);
529
+ }
530
+ function deleteObject(bucket, { key }) {
531
+ bucket.objects.delete(key);
532
+ return new Response(null, { status: 204 });
533
+ }
534
+ function listObjects(bucket, { query }) {
535
+ const prefix = query.get("prefix") ?? "";
536
+ const token = query.get("continuation-token");
537
+ const after = token === null ? "" : bucket.listTokens.get(token);
538
+ if (after === void 0) return errorResponse(400, "InvalidArgument", "The continuation token is not valid.");
539
+ const max = Math.min(Number(query.get("max-keys") ?? 1e3), MAX_LIST_PAGE);
540
+ const matching = Array.from(bucket.objects).filter(([key]) => key.startsWith(prefix) && (after === "" || compareKeys(key, after) > 0)).sort(([a], [b]) => compareKeys(a, b));
541
+ const page = matching.slice(0, max);
542
+ const truncated = matching.length > max;
543
+ const contents = page.map(([key, object]) => `<Contents><Key>${escapeXml(key)}</Key><Size>${object.body.length}</Size><ETag>"${object.etag}"</ETag><LastModified>${object.uploadedAt.toISOString()}</LastModified></Contents>`).join("");
544
+ const nextToken = `fake-token-${bucket.listTokens.size + 1}`;
545
+ if (truncated) bucket.listTokens.set(nextToken, page.at(-1)?.[0] ?? "");
546
+ return xmlResponse(`<ListBucketResult><IsTruncated>${truncated}</IsTruncated>${truncated ? `<NextContinuationToken>${nextToken}</NextContinuationToken>` : ""}${contents}</ListBucketResult>`);
547
+ }
548
+ // src/testing/fake-r2/signature.ts
549
+ const MAX_CLOCK_SKEW_MS = 9e5;
550
+ const PRESIGNED_SKIPPED = ["host"];
551
+ const HEADER_SIGNED_SKIPPED = [
552
+ "host",
553
+ "x-amz-date",
554
+ "x-amz-content-sha256"
555
+ ];
556
+ const signatureMismatch = () => errorResponse(403, "SignatureDoesNotMatch", "The request signature does not match.");
557
+ function parseAmzDate(value) {
558
+ return /* @__PURE__ */ new Date(`${value.slice(0, 4)}-${value.slice(4, 6)}-${value.slice(6, 8)}T${value.slice(9, 11)}:${value.slice(11, 13)}:${value.slice(13, 15)}Z`);
559
+ }
560
+ function queryAsWritten(url) {
561
+ const params = new URLSearchParams();
562
+ for (const pair of url.search.slice(1).split("&")) {
563
+ if (pair === "") continue;
564
+ const at = pair.indexOf("=");
565
+ params.append(decodeURIComponent(at < 0 ? pair : pair.slice(0, at)), at < 0 ? "" : decodeURIComponent(pair.slice(at + 1)));
566
+ }
567
+ const rebuilt = new URL(url);
568
+ rebuilt.search = params.toString();
569
+ return rebuilt;
570
+ }
571
+ function signedHeaderValue(request, name, body) {
572
+ return name === "content-length" ? String(body.length) : request.headers.get(name);
573
+ }
574
+ function collectSignedHeaders(request, names, body, skipped) {
575
+ const headers = {};
576
+ for (const name of names) {
577
+ if (skipped.includes(name)) continue;
578
+ const value = signedHeaderValue(request, name, body);
579
+ if (value === null) return errorResponse(403, "SignatureDoesNotMatch", `Signed header ${name} is missing.`);
580
+ headers[name] = value;
581
+ }
582
+ return headers;
583
+ }
584
+ function presignedWindow(query, now) {
585
+ const signedAt = parseAmzDate(query.get("X-Amz-Date") ?? "");
586
+ const expires = Number(query.get("X-Amz-Expires"));
587
+ if (Number.isNaN(signedAt.getTime())) return errorResponse(400, "AuthorizationQueryParametersError", "X-Amz-Date is missing or malformed.");
588
+ if (!Number.isInteger(expires) || expires < 1 || expires > R2_RULES.maxPresignSeconds) return errorResponse(400, "InvalidArgument", "X-Amz-Expires must be between 1 and 604800 seconds.");
589
+ if (signedAt.getTime() - now().getTime() > MAX_CLOCK_SKEW_MS) return clockSkewed();
590
+ if (now().getTime() > signedAt.getTime() + expires * 1e3) return errorResponse(403, "ExpiredRequest", "Request has expired.");
591
+ return {
592
+ signedAt,
593
+ expires
594
+ };
595
+ }
596
+ function unsignedMetadata(request, signedNames) {
597
+ if (request.method !== "PUT") return null;
598
+ const name = [...request.headers.keys()].find((header) => header.startsWith("x-amz-meta-") && !signedNames.includes(header));
599
+ return name ? errorResponse(403, "SignatureDoesNotMatch", `Header ${name} is not signed.`) : null;
600
+ }
601
+ function withoutSignature(url) {
602
+ const unsigned = new URL(url);
603
+ for (const name of Array.from(unsigned.searchParams.keys())) if (name.startsWith("X-Amz-")) unsigned.searchParams.delete(name);
604
+ return unsigned;
605
+ }
606
+ async function verifyPresigned(bucket, request, url, body) {
607
+ const query = url.searchParams;
608
+ const window = presignedWindow(query, bucket.now);
609
+ if (window instanceof Response) return window;
610
+ const signedNames = (query.get("X-Amz-SignedHeaders") ?? "").split(";");
611
+ const headers = collectSignedHeaders(request, signedNames, body, PRESIGNED_SKIPPED);
612
+ if (headers instanceof Response) return headers;
613
+ const unsigned = unsignedMetadata(request, signedNames);
614
+ if (unsigned) return unsigned;
615
+ return (await presignUrl({
616
+ method: request.method,
617
+ url: withoutSignature(url),
618
+ headers,
619
+ credentials: bucket.credentials,
620
+ region: (query.get("X-Amz-Credential") ?? "").split("/")[2] ?? "",
621
+ date: window.signedAt,
622
+ expiresIn: window.expires
623
+ })).searchParams.get("X-Amz-Signature") === query.get("X-Amz-Signature") ? null : signatureMismatch();
624
+ }
625
+ async function verifyHeaderSigned(bucket, request, url, body) {
626
+ const authorization = request.headers.get("authorization");
627
+ if (!authorization) return errorResponse(403, "AccessDenied", "The request is not signed.");
628
+ const signedAt = parseAmzDate(request.headers.get("x-amz-date") ?? "");
629
+ if (Number.isNaN(signedAt.getTime())) return errorResponse(403, "SignatureDoesNotMatch", "X-Amz-Date is missing or malformed.");
630
+ if (Math.abs(signedAt.getTime() - bucket.now().getTime()) > MAX_CLOCK_SKEW_MS) return clockSkewed();
631
+ const payloadHash = request.headers.get("x-amz-content-sha256") ?? "";
632
+ if (payloadHash !== "UNSIGNED-PAYLOAD" && payloadHash !== await sha256Hex(body)) return errorResponse(400, "XAmzContentSHA256Mismatch", "The payload hash does not match the body.");
633
+ const headers = collectSignedHeaders(request, /SignedHeaders=([^,]+)/.exec(authorization)?.[1]?.split(";") ?? [], body, HEADER_SIGNED_SKIPPED);
634
+ if (headers instanceof Response) return headers;
635
+ return (await signRequest({
636
+ method: request.method,
637
+ url,
638
+ headers,
639
+ credentials: bucket.credentials,
640
+ region: /Credential=[^/]+\/\d{8}\/([^/]+)\//.exec(authorization)?.[1] ?? "",
641
+ date: signedAt,
642
+ payloadHash
643
+ })).authorization === authorization ? null : signatureMismatch();
644
+ }
645
+ async function verifySignature(bucket, request, url, body) {
646
+ let writtenUrl;
647
+ try {
648
+ writtenUrl = queryAsWritten(url);
649
+ } catch {
650
+ return errorResponse(400, "InvalidURI", "The query string is not valid percent-encoding.");
651
+ }
652
+ return url.searchParams.has("X-Amz-Signature") ? verifyPresigned(bucket, request, writtenUrl, body) : verifyHeaderSigned(bucket, request, writtenUrl, body);
653
+ }
654
+ // src/testing/fake-r2.ts
655
+ const isBucketGet = (request) => request.method === "GET" && request.key === "";
656
+ const isBucketPut = (request) => request.method === "PUT" && request.key === "";
657
+ const ROUTES = [
658
+ {
659
+ matches: (r) => isBucketGet(r) && r.query.get("list-type") === "2",
660
+ run: listObjects
661
+ },
662
+ {
663
+ matches: (r) => isBucketGet(r) && r.query.has("cors"),
664
+ run: (bucket) => bucketConfig(bucket, "cors")
665
+ },
666
+ {
667
+ matches: (r) => isBucketGet(r) && r.query.has("lifecycle"),
668
+ run: (bucket) => bucketConfig(bucket, "lifecycle")
669
+ },
670
+ {
671
+ matches: (r) => isBucketPut(r) && r.query.has("cors"),
672
+ run: (bucket, r) => putBucketConfig(bucket, "cors", r)
673
+ },
674
+ {
675
+ matches: (r) => isBucketPut(r) && r.query.has("lifecycle"),
676
+ run: (bucket, r) => putBucketConfig(bucket, "lifecycle", r)
677
+ },
678
+ {
679
+ matches: (r) => r.method === "POST" && r.query.has("uploads"),
680
+ run: createUpload
681
+ },
682
+ {
683
+ matches: (r) => r.method === "PUT" && r.headers.has("x-amz-copy-source"),
684
+ run: copy
685
+ },
686
+ {
687
+ matches: (r) => r.method === "PUT" && r.query.has("uploadId"),
688
+ run: uploadPart
689
+ },
690
+ {
691
+ matches: (r) => r.method === "POST" && r.query.has("uploadId"),
692
+ run: completeUpload
693
+ },
694
+ {
695
+ matches: (r) => r.method === "GET" && r.query.has("uploadId"),
696
+ run: listParts
697
+ },
698
+ {
699
+ matches: (r) => r.method === "DELETE" && r.query.has("uploadId"),
700
+ run: abortUpload
701
+ },
702
+ {
703
+ matches: (r) => r.method === "PUT",
704
+ run: putObject
705
+ },
706
+ {
707
+ matches: (r) => r.method === "GET" || r.method === "HEAD",
708
+ run: getObject
709
+ },
710
+ {
711
+ matches: (r) => r.method === "DELETE",
712
+ run: deleteObject
713
+ }
714
+ ];
715
+ function createFakeR2(options) {
716
+ const bucket = {
717
+ name: options.bucket,
718
+ credentials: options.credentials,
719
+ now: options.now ?? (() => /* @__PURE__ */ new Date()),
720
+ config: options.bucketConfig && { ...options.bucketConfig },
721
+ objects: /* @__PURE__ */ new Map(),
722
+ uploads: /* @__PURE__ */ new Map(),
723
+ listTokens: /* @__PURE__ */ new Map(),
724
+ uploadCounter: 0
725
+ };
726
+ async function handle(request) {
727
+ const answer = await route(request);
728
+ const headers = new Headers(answer.headers);
729
+ headers.set("date", bucket.now().toUTCString());
730
+ return new Response(request.method === "HEAD" ? null : answer.body, {
731
+ status: answer.status,
732
+ headers
733
+ });
734
+ }
735
+ async function route(request) {
736
+ const url = new URL(request.url);
737
+ const [, bucketSegment = "", ...keySegments] = url.pathname.split("/");
738
+ if (decodeURIComponent(bucketSegment) !== bucket.name) return errorResponse(404, "NoSuchBucket", "The specified bucket does not exist.");
739
+ const key = keySegments.map(decodeURIComponent).join("/");
740
+ const body = new Uint8Array(await request.arrayBuffer());
741
+ const denied = await verifySignature(bucket, request, url, body);
742
+ if (denied) return denied;
743
+ const verified = {
744
+ method: request.method,
745
+ key,
746
+ query: url.searchParams,
747
+ headers: request.headers,
748
+ body
749
+ };
750
+ const matched = ROUTES.find((candidate) => candidate.matches(verified));
751
+ if (matched) return matched.run(bucket, verified);
752
+ return errorResponse(501, "NotImplemented", `${request.method} is not implemented by the fake.`);
753
+ }
754
+ return {
755
+ fetch: (input, init) => handle(new Request(input, init)),
756
+ pendingUploads: () => bucket.uploads.size,
757
+ object: (key) => bucket.objects.get(key),
758
+ keys: () => [...bucket.objects.keys()].sort()
759
+ };
760
+ }
761
+ // src/testing/memory-store-reads.ts
762
+ const CLEANUP = /* @__PURE__ */ new Set([
763
+ "aborted",
764
+ "rejected",
765
+ "failed",
766
+ "expired",
767
+ "deleted"
768
+ ]);
769
+ function toRecord(row) {
770
+ const { claim: _claim, updatedAt: _updatedAt, requestKey: _requestKey, ...record } = structuredClone(row);
771
+ return record;
772
+ }
773
+ function page(rows, sortKey, cursor, limit) {
774
+ const after = cursor === null ? rows : rows.filter((row) => sortKey(row) > cursor);
775
+ const records = after.slice(0, limit);
776
+ const last = records.at(-1);
777
+ return {
778
+ records,
779
+ cursor: after.length > limit && last ? sortKey(last) : null
780
+ };
781
+ }
782
+ const timeKey = (time, id) => `${String(time?.getTime() ?? 0).padStart(13, "0")}:${id}`;
783
+ const newestFirst = (a, b) => b.createdAt.getTime() - a.createdAt.getTime() || (a.id < b.id ? 1 : a.id > b.id ? -1 : 0);
784
+ function listedAfter(cursor) {
785
+ const split = cursor.indexOf(":");
786
+ const time = Number(cursor.slice(0, split));
787
+ const id = cursor.slice(split + 1);
788
+ return (row) => row.createdAt.getTime() < time || row.createdAt.getTime() === time && row.id < id;
789
+ }
790
+ function readMethods({ files, usage }) {
791
+ return {
792
+ get: async (id) => {
793
+ const row = files.get(id);
794
+ return row ? toRecord(row) : null;
795
+ },
796
+ stale: async ({ kind, before, claimedBefore, limit, cursor }) => {
797
+ const cutoff = before.getTime();
798
+ const isWork = kind === "expire" ? (row) => row.expiresAt.getTime() < cutoff && (row.status === "pending" || row.status === "completing" && (row.claimedAt?.getTime() ?? 0) < claimedBefore.getTime()) : (row) => CLEANUP.has(row.status) && row.cleanedAt === null && (row.endedAt?.getTime() ?? 0) < cutoff;
799
+ const sortKey = (row) => timeKey(kind === "expire" ? row.expiresAt : row.endedAt, row.id);
800
+ const found = page([...files.values()].filter(isWork).sort((a, b) => sortKey(a) < sortKey(b) ? -1 : 1), sortKey, cursor, limit);
801
+ return {
802
+ records: found.records.map(toRecord),
803
+ cursor: found.cursor
804
+ };
805
+ },
806
+ list: async ({ owner, statuses, route, limit, cursor }) => {
807
+ const after = cursor === null ? () => true : listedAfter(cursor);
808
+ const rows = [...files.values()].filter((row) => row.owner === owner && statuses.includes(row.status) && (route === null || row.route === route)).filter(after).sort(newestFirst);
809
+ const kept = rows.slice(0, limit);
810
+ const last = kept.at(-1);
811
+ const next = rows.length > limit && last ? `${last.createdAt.getTime()}:${last.id}` : null;
812
+ return {
813
+ records: kept.map(toRecord),
814
+ cursor: next
815
+ };
816
+ },
817
+ owners: async (cursor, limit) => {
818
+ const found = page([...usage.keys()].sort(), (owner) => owner, cursor, limit);
819
+ return {
820
+ owners: found.records,
821
+ cursor: found.cursor
822
+ };
823
+ }
824
+ };
825
+ }
826
+ // src/testing/memory-store-methods.ts
827
+ const ZERO = {
828
+ reservedBytes: 0,
829
+ activeBytes: 0,
830
+ files: 0
831
+ };
832
+ const RESERVING = /* @__PURE__ */ new Set(["pending", "completing"]);
833
+ function countRows(rows, owner) {
834
+ const counted = { ...ZERO };
835
+ for (const row of rows) {
836
+ if (row.owner !== owner) continue;
837
+ if (RESERVING.has(row.status)) counted.reservedBytes += row.size;
838
+ if (row.status === "completed") {
839
+ counted.activeBytes += row.size;
840
+ counted.files += 1;
841
+ }
842
+ }
843
+ return counted;
844
+ }
845
+ function storeMethods(tables, atomic) {
846
+ const { files, usage } = tables;
847
+ const countsOf = (owner) => {
848
+ const row = usage.get(owner);
849
+ return row ? {
850
+ reservedBytes: row.reservedBytes,
851
+ activeBytes: row.activeBytes,
852
+ files: row.files
853
+ } : { ...ZERO };
854
+ };
855
+ function adjust(write, owner, delta, now) {
856
+ if (owner === null || Object.keys(delta).length === 0) return;
857
+ const counts = countsOf(owner);
858
+ write.usage({
859
+ owner,
860
+ reservedBytes: counts.reservedBytes + (delta.reservedBytes ?? 0),
861
+ activeBytes: counts.activeBytes + (delta.activeBytes ?? 0),
862
+ files: counts.files + (delta.files ?? 0),
863
+ updatedAt: now
864
+ });
865
+ }
866
+ const releaseFrom = (from, size) => {
867
+ if (RESERVING.has(from)) return { reservedBytes: -size };
868
+ return from === "completed" ? {
869
+ activeBytes: -size,
870
+ files: -1
871
+ } : {};
872
+ };
873
+ const unchanged = (id) => {
874
+ const row = files.get(id);
875
+ return {
876
+ changed: false,
877
+ record: row ? toRecord(row) : null
878
+ };
879
+ };
880
+ return {
881
+ ...readMethods(tables),
882
+ reserve: ({ owner, limit, expiresAt, requestKey, files: accepted }, now) => atomic("reserve", (write) => {
883
+ if (accepted.length === 0) return [];
884
+ const routes = new Set(accepted.map((file) => file.route));
885
+ const superseded = requestKey === null ? [] : [...files.values()].filter((row) => row.requestKey === requestKey && row.owner === owner && routes.has(row.route) && row.status === "pending");
886
+ for (const row of superseded) {
887
+ write.file({
888
+ ...row,
889
+ status: "aborted",
890
+ endedAt: now,
891
+ updatedAt: now
892
+ });
893
+ adjust(write, owner, { reservedBytes: -row.size }, now);
894
+ }
895
+ return accepted.map((file) => {
896
+ if (owner !== null && limit !== null) {
897
+ const { reservedBytes, activeBytes } = countsOf(owner);
898
+ if (reservedBytes + activeBytes + file.size > limit) return "over-quota";
899
+ }
900
+ if (files.has(file.id)) throw new Error(`A file row with the id "${file.id}" already exists.`);
901
+ write.file({
902
+ ...file,
903
+ owner,
904
+ status: "pending",
905
+ uploadId: null,
906
+ result: null,
907
+ claim: null,
908
+ claimedAt: null,
909
+ expiresAt,
910
+ createdAt: now,
911
+ updatedAt: now,
912
+ completedAt: null,
913
+ endedAt: null,
914
+ cleanedAt: null,
915
+ requestKey
916
+ });
917
+ adjust(write, owner, { reservedBytes: file.size }, now);
918
+ return "reserved";
919
+ });
920
+ }),
921
+ attach: (id, uploadId, now) => atomic("attach", (write) => {
922
+ const row = files.get(id);
923
+ if (row?.status !== "pending" || row.uploadId !== null && row.uploadId !== uploadId) return false;
924
+ write.file({
925
+ ...row,
926
+ uploadId,
927
+ updatedAt: now
928
+ });
929
+ return true;
930
+ }),
931
+ claim: (id, claim, now, leaseMs) => atomic("claim", (write) => {
932
+ const row = files.get(id);
933
+ if (!row) return { kind: "missing" };
934
+ if (row.status === "completed") return {
935
+ kind: "completed",
936
+ record: toRecord(row)
937
+ };
938
+ const leaseOver = (row.claimedAt?.getTime() ?? 0) < now.getTime() - leaseMs;
939
+ if (row.status === "pending" || row.status === "completing" && leaseOver) {
940
+ write.file({
941
+ ...row,
942
+ status: "completing",
943
+ claim,
944
+ claimedAt: now,
945
+ updatedAt: now
946
+ });
947
+ return { kind: "claimed" };
948
+ }
949
+ return row.status === "completing" ? { kind: "busy" } : {
950
+ kind: "ended",
951
+ record: toRecord(row)
952
+ };
953
+ }),
954
+ release: (id, claim, now) => atomic("release", (write) => {
955
+ const row = files.get(id);
956
+ if (row?.status !== "completing" || row.claim !== claim) return false;
957
+ write.file({
958
+ ...row,
959
+ status: "pending",
960
+ claim: null,
961
+ claimedAt: null,
962
+ updatedAt: now
963
+ });
964
+ return true;
965
+ }),
966
+ complete: (id, claim, result, now, options) => atomic("complete", (write) => {
967
+ const row = files.get(id);
968
+ if (row?.status !== "completing" || row.claim !== claim) return {
969
+ ...unchanged(id),
970
+ replaced: []
971
+ };
972
+ const replaced = options?.replace && row.owner !== null ? [...files.values()].filter((other) => other.owner === row.owner && other.route === row.route && other.status === "completed" && other.id !== id) : [];
973
+ const deleted = replaced.map((other) => ({
974
+ ...other,
975
+ status: "deleted",
976
+ endedAt: now,
977
+ updatedAt: now
978
+ }));
979
+ for (const other of deleted) write.file(other);
980
+ const done = {
981
+ ...row,
982
+ status: "completed",
983
+ result,
984
+ completedAt: now,
985
+ updatedAt: now
986
+ };
987
+ write.file(done);
988
+ const freed = replaced.reduce((sum, other) => sum + other.size, 0);
989
+ const delta = {
990
+ reservedBytes: -row.size,
991
+ activeBytes: row.size - freed,
992
+ files: 1 - replaced.length
993
+ };
994
+ adjust(write, row.owner, delta, now);
995
+ return {
996
+ changed: true,
997
+ record: toRecord(done),
998
+ replaced: deleted.map(toRecord)
999
+ };
1000
+ }),
1001
+ end: (id, from, to, now, options) => atomic("end", (write) => {
1002
+ const row = files.get(id);
1003
+ if (row?.status !== from) return unchanged(id);
1004
+ const cleanedAt = options?.cleaned ? now : row.cleanedAt;
1005
+ const ended = {
1006
+ ...row,
1007
+ status: to,
1008
+ endedAt: now,
1009
+ cleanedAt,
1010
+ updatedAt: now
1011
+ };
1012
+ write.file(ended);
1013
+ adjust(write, row.owner, releaseFrom(from, row.size), now);
1014
+ return {
1015
+ changed: true,
1016
+ record: toRecord(ended)
1017
+ };
1018
+ }),
1019
+ revoke: (owner, now) => atomic("revoke", (write) => {
1020
+ const revoked = [...files.values()].filter((row) => row.owner === owner && row.status === "pending");
1021
+ for (const row of revoked) {
1022
+ write.file({
1023
+ ...row,
1024
+ status: "aborted",
1025
+ endedAt: now,
1026
+ updatedAt: now
1027
+ });
1028
+ adjust(write, owner, { reservedBytes: -row.size }, now);
1029
+ }
1030
+ return revoked.length;
1031
+ }),
1032
+ cleaned: (id, now) => atomic("cleaned", (write) => {
1033
+ const row = files.get(id);
1034
+ if (row && row.cleanedAt === null) write.file({
1035
+ ...row,
1036
+ cleanedAt: now,
1037
+ updatedAt: now
1038
+ });
1039
+ }),
1040
+ usage: async (owner) => countsOf(owner),
1041
+ reconcile: (owner) => atomic("reconcile", (write) => {
1042
+ const counted = countRows(files.values(), owner);
1043
+ const current = countsOf(owner);
1044
+ const same = Object.keys(ZERO).every((name) => counted[name] === current[name]);
1045
+ if (!same) write.usage({
1046
+ owner,
1047
+ ...counted,
1048
+ updatedAt: /* @__PURE__ */ new Date()
1049
+ });
1050
+ return !same;
1051
+ })
1052
+ };
1053
+ }
1054
+ // src/testing/memory-store.ts
1055
+ const COUNTERS = [
1056
+ "reservedBytes",
1057
+ "activeBytes",
1058
+ "files"
1059
+ ];
1060
+ function undoUsage(usage, stored, before) {
1061
+ const current = usage.get(stored.owner);
1062
+ if (current === stored || current === void 0) {
1063
+ if (before) usage.set(stored.owner, before);
1064
+ else usage.delete(stored.owner);
1065
+ return;
1066
+ }
1067
+ const taken = { ...current };
1068
+ for (const counter of COUNTERS) taken[counter] -= stored[counter] - (before?.[counter] ?? 0);
1069
+ usage.set(stored.owner, taken);
1070
+ }
1071
+ function memoryStore$1() {
1072
+ const tables = {
1073
+ files: /* @__PURE__ */ new Map(),
1074
+ usage: /* @__PURE__ */ new Map()
1075
+ };
1076
+ const app = [];
1077
+ let fault = null;
1078
+ let usageFault = false;
1079
+ function atomic(method, journal, body) {
1080
+ const armed = fault?.method === method ? fault : null;
1081
+ if (armed) fault = null;
1082
+ const undo = [];
1083
+ const checkFault = () => {
1084
+ if (armed && undo.length === armed.afterWrites) throw new Error(`Injected failure in ${method} after ${armed.afterWrites} writes.`);
1085
+ };
1086
+ const write = {
1087
+ file(row) {
1088
+ checkFault();
1089
+ const before = tables.files.get(row.id);
1090
+ undo.push(() => before ? tables.files.set(row.id, before) : tables.files.delete(row.id));
1091
+ tables.files.set(row.id, structuredClone(row));
1092
+ },
1093
+ usage(row) {
1094
+ if (usageFault) {
1095
+ usageFault = false;
1096
+ throw new Error("Injected failure writing the usage table.");
1097
+ }
1098
+ checkFault();
1099
+ const before = tables.usage.get(row.owner);
1100
+ const stored = structuredClone(row);
1101
+ tables.usage.set(row.owner, stored);
1102
+ undo.push(() => undoUsage(tables.usage, stored, before));
1103
+ }
1104
+ };
1105
+ try {
1106
+ const result = body(write);
1107
+ journal?.push(...undo);
1108
+ return Promise.resolve(result);
1109
+ } catch (error) {
1110
+ for (const step of undo.toReversed()) step();
1111
+ return Promise.reject(error);
1112
+ }
1113
+ }
1114
+ const store = storeMethods(tables, (method, body) => atomic(method, null, body));
1115
+ async function transaction(run) {
1116
+ const journal = [];
1117
+ const calls = [];
1118
+ const tx = {
1119
+ calls,
1120
+ write(entry) {
1121
+ const row = { entry };
1122
+ app.push(row);
1123
+ journal.push(() => app.splice(app.indexOf(row), 1));
1124
+ }
1125
+ };
1126
+ const inner = storeMethods(tables, (method, body) => atomic(method, journal, body));
1127
+ const recorded = Object.fromEntries(Object.entries(inner).map(([name, method]) => [name, (...args) => {
1128
+ calls.push(name);
1129
+ return method(...args);
1130
+ }]));
1131
+ try {
1132
+ return await run(tx, recorded);
1133
+ } catch (error) {
1134
+ for (const step of journal.toReversed()) step();
1135
+ throw error;
1136
+ }
1137
+ }
1138
+ const sorted = (map) => [...map.entries()].sort(([a], [b]) => a < b ? -1 : 1).map(([, row]) => structuredClone(row));
1139
+ return {
1140
+ ...store,
1141
+ transaction,
1142
+ raw: {
1143
+ files: async () => sorted(tables.files),
1144
+ usage: async () => sorted(tables.usage),
1145
+ putUsage: async (row) => void tables.usage.set(row.owner, structuredClone(row)),
1146
+ deleteUsage: async (owner) => void tables.usage.delete(owner)
1147
+ },
1148
+ injectFailure(method, afterWrites) {
1149
+ fault = {
1150
+ method,
1151
+ afterWrites
1152
+ };
1153
+ },
1154
+ failNextUsageWrite() {
1155
+ usageFault = true;
1156
+ },
1157
+ appRows: () => app.map((row) => row.entry)
1158
+ };
1159
+ }
1160
+ // src/testing.ts
1161
+ const CREDENTIALS = {
1162
+ accessKeyId: "cloudrop-test-key",
1163
+ secretAccessKey: "cloudrop-test-secret"
1164
+ };
1165
+ const PAGE_ORIGIN = "http://localhost";
1166
+ const STORE = Symbol.for("cloudrop.store");
1167
+ const PATH = /^(?:\/[^/?#\s]+)+$/;
1168
+ function testBucket(options) {
1169
+ const { publicUrl, cors, lifecycle } = options ?? {};
1170
+ const fake = createFakeR2({
1171
+ bucket: "uploads",
1172
+ credentials: CREDENTIALS,
1173
+ bucketConfig: cors === void 0 && lifecycle === void 0 ? void 0 : {
1174
+ cors,
1175
+ lifecycle
1176
+ }
1177
+ });
1178
+ return {
1179
+ storage: r2({
1180
+ bucket: "uploads",
1181
+ accountId: "0".repeat(32),
1182
+ ...CREDENTIALS,
1183
+ publicUrl,
1184
+ fetch: fake.fetch
1185
+ }),
1186
+ fetch: fake.fetch,
1187
+ object(key) {
1188
+ const stored = fake.object(key);
1189
+ if (!stored) return null;
1190
+ const { body, headers } = stored;
1191
+ return {
1192
+ key,
1193
+ size: body.byteLength,
1194
+ type: headers.type ?? null,
1195
+ disposition: headers.disposition ?? null,
1196
+ metadata: { ...headers.metadata },
1197
+ parts: stored.partCount ?? null,
1198
+ body: body.slice(),
1199
+ uploadedAt: new Date(stored.uploadedAt)
1200
+ };
1201
+ },
1202
+ keys: fake.keys,
1203
+ pendingUploads: fake.pendingUploads
1204
+ };
1205
+ }
1206
+ function testClient(cloudrop, options) {
1207
+ const { bucket, headers, basePath = "/api/cloudrop" } = options ?? {};
1208
+ if (!bucket) throw new CloudropError("INVALID_CONFIG", "testClient needs the test bucket the server stores in: testClient(cloudrop, { bucket }).");
1209
+ if (typeof basePath !== "string" || !PATH.test(basePath)) throw new CloudropError("INVALID_CONFIG", "basePath must be the path the server is mounted at, such as \"/api/cloudrop\", with no origin and no trailing slash.");
1210
+ const server = `${PAGE_ORIGIN}${basePath}`;
1211
+ const fetch = (url, init) => {
1212
+ if (!url.startsWith(`${server}/`)) return bucket.fetch(url, init);
1213
+ const sent = new Headers(init.headers);
1214
+ sent.set("origin", PAGE_ORIGIN);
1215
+ return cloudrop.handler(new Request(url, {
1216
+ method: init.method,
1217
+ headers: sent,
1218
+ body: init.body
1219
+ }));
1220
+ };
1221
+ return createCloudropClient({
1222
+ basePath: server,
1223
+ headers,
1224
+ fetch,
1225
+ persist: false
1226
+ });
1227
+ }
1228
+ function memoryStore(options) {
1229
+ const { transaction, raw: _raw, injectFailure: _inject, failNextUsageWrite: _fail, appRows: _rows, ...methods } = memoryStore$1();
1230
+ if (!options?.transaction) return methods;
1231
+ const store = {
1232
+ ...methods,
1233
+ transaction: (run) => transaction((_tx, inner) => run(void 0, inner))
1234
+ };
1235
+ store.route = ((policy, callbacks) => ({ definition: {
1236
+ ...route(policy, callbacks).definition,
1237
+ [STORE]: store
1238
+ } }));
1239
+ return store;
1240
+ }
1241
+ export { memoryStore, testBucket, testClient };
1242
+
1243
+ //# sourceMappingURL=testing.js.map