@constructive-io/sheets 0.14.1 → 0.15.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 (60) hide show
  1. package/README.md +231 -157
  2. package/dist/advanced.cjs +7192 -3840
  3. package/dist/advanced.cjs.map +1 -1
  4. package/dist/advanced.d.cts +2 -2
  5. package/dist/advanced.d.ts +2 -2
  6. package/dist/advanced.js +5 -5
  7. package/dist/auth.cjs.map +1 -1
  8. package/dist/auth.js +3 -3
  9. package/dist/chunk-CJ4PRA64.js +312 -0
  10. package/dist/chunk-CJ4PRA64.js.map +1 -0
  11. package/dist/chunk-II3MSNRO.js +18 -0
  12. package/dist/chunk-II3MSNRO.js.map +1 -0
  13. package/dist/{chunk-BYAYBXVB.js → chunk-J7KK4UWI.js} +6 -6
  14. package/dist/chunk-MBSHDF55.js +839 -0
  15. package/dist/chunk-MBSHDF55.js.map +1 -0
  16. package/dist/chunk-MOFFS5WQ.js +128 -0
  17. package/dist/chunk-MOFFS5WQ.js.map +1 -0
  18. package/dist/chunk-VCBY2AMT.js +8920 -0
  19. package/dist/chunk-VCBY2AMT.js.map +1 -0
  20. package/dist/{chunk-YJZFHL2D.js → chunk-ZOQDSOMO.js} +50 -312
  21. package/dist/chunk-ZOQDSOMO.js.map +1 -0
  22. package/dist/date-editor-ORCB43ZM.js +346 -0
  23. package/dist/date-editor-ORCB43ZM.js.map +1 -0
  24. package/dist/{grid-cell-types-C2-ocDS7.d.cts → grid-cell-types-YNIVK4hN.d.cts} +71 -18
  25. package/dist/{grid-cell-types-C2-ocDS7.d.ts → grid-cell-types-YNIVK4hN.d.ts} +71 -18
  26. package/dist/index.cjs +22733 -12052
  27. package/dist/index.cjs.map +1 -1
  28. package/dist/index.d.cts +1432 -266
  29. package/dist/index.d.ts +1432 -266
  30. package/dist/index.js +12688 -6097
  31. package/dist/index.js.map +1 -1
  32. package/dist/sheets-context-Bb7ZoNBg.d.cts +436 -0
  33. package/dist/sheets-context-CPuf31LS.d.ts +436 -0
  34. package/dist/testing.cjs +1170 -589
  35. package/dist/testing.cjs.map +1 -1
  36. package/dist/testing.d.cts +80 -11
  37. package/dist/testing.d.ts +80 -11
  38. package/dist/testing.js +778 -147
  39. package/dist/testing.js.map +1 -1
  40. package/package.json +4 -5
  41. package/dist/chunk-4EZ6A23C.js +0 -44
  42. package/dist/chunk-4EZ6A23C.js.map +0 -1
  43. package/dist/chunk-6Y7CZ5VS.js +0 -168
  44. package/dist/chunk-6Y7CZ5VS.js.map +0 -1
  45. package/dist/chunk-BGL6EBTE.js +0 -446
  46. package/dist/chunk-BGL6EBTE.js.map +0 -1
  47. package/dist/chunk-ER3FIDK7.js +0 -4383
  48. package/dist/chunk-ER3FIDK7.js.map +0 -1
  49. package/dist/chunk-GZM2CSTR.js +0 -279
  50. package/dist/chunk-GZM2CSTR.js.map +0 -1
  51. package/dist/chunk-X7DHTSOX.js +0 -21
  52. package/dist/chunk-X7DHTSOX.js.map +0 -1
  53. package/dist/chunk-YJZFHL2D.js.map +0 -1
  54. package/dist/date-editor-G26WKILO.js +0 -358
  55. package/dist/date-editor-G26WKILO.js.map +0 -1
  56. package/dist/map-picker-ZUGGOIZS.js +0 -290
  57. package/dist/map-picker-ZUGGOIZS.js.map +0 -1
  58. package/dist/sheets-context-CHUVJCff.d.ts +0 -245
  59. package/dist/sheets-context-C_MkTxXm.d.cts +0 -245
  60. /package/dist/{chunk-BYAYBXVB.js.map → chunk-J7KK4UWI.js.map} +0 -0
@@ -0,0 +1,839 @@
1
+ "use client";
2
+
3
+ // src/context/sheets-upload-discovery.ts
4
+ import { getIntrospectionQuery } from "graphql";
5
+ import { createError as createError2 } from "@constructive-io/data";
6
+
7
+ // src/context/sheets-upload-presigned.ts
8
+ import { createError } from "@constructive-io/data";
9
+ var UPLOAD_PAYLOAD_FIELDS = ["uploadUrl", "uploadHeaders", "fileId", "key", "deduplicated", "expiresAt", "file"];
10
+ function headersOf(value) {
11
+ let parsed = value;
12
+ if (typeof parsed === "string") {
13
+ try {
14
+ parsed = JSON.parse(parsed);
15
+ } catch {
16
+ return null;
17
+ }
18
+ }
19
+ if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
20
+ const entries = Object.entries(parsed);
21
+ if (!entries.every(([, header]) => typeof header === "string")) return null;
22
+ return Object.fromEntries(entries);
23
+ }
24
+ function projectionOf(value) {
25
+ let parsed = value;
26
+ if (typeof parsed === "string") {
27
+ try {
28
+ parsed = JSON.parse(parsed);
29
+ } catch {
30
+ return null;
31
+ }
32
+ }
33
+ if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
34
+ const projection = parsed;
35
+ return isFileProjection(projection) ? projection : null;
36
+ }
37
+ function isFileProjection(value) {
38
+ return typeof value.id === "string" && typeof value.key === "string";
39
+ }
40
+ var UNFINISHED_UPLOAD = "unfinishedUpload";
41
+ function unfinishedUploadOf(error) {
42
+ const value = error && typeof error === "object" ? error[UNFINISHED_UPLOAD] : null;
43
+ return value && typeof value === "object" ? value : null;
44
+ }
45
+ function withUnfinishedUpload(error, upload) {
46
+ if (!error || typeof error !== "object") return error;
47
+ const recorded = unfinishedUploadOf(error);
48
+ const fileId = recorded?.fileId ?? upload.fileId;
49
+ if (!fileId) return error;
50
+ const value = {
51
+ fileId,
52
+ filesType: recorded?.filesType ?? upload.filesType ?? null,
53
+ filesTableKey: recorded?.filesTableKey ?? upload.filesTableKey ?? null
54
+ };
55
+ Object.defineProperty(error, UNFINISHED_UPLOAD, { value, enumerable: false, configurable: true, writable: true });
56
+ return error;
57
+ }
58
+ function readUploadPayload(raw) {
59
+ if (!raw || typeof raw !== "object") {
60
+ throw createError.badRequest("Upload failed: the storage service returned no answer.");
61
+ }
62
+ const payload = raw;
63
+ const file = projectionOf(payload.file);
64
+ if (!file) {
65
+ throw createError.badRequest("Upload failed: the server returned an invalid file projection.");
66
+ }
67
+ const deduplicated = payload.deduplicated === true;
68
+ const uploadUrl = typeof payload.uploadUrl === "string" && payload.uploadUrl ? payload.uploadUrl : null;
69
+ if (!deduplicated && !uploadUrl) {
70
+ throw withUnfinishedUpload(createError.badRequest("Upload failed: the server returned no uploadUrl for a new file."), {
71
+ fileId: typeof payload.fileId === "string" ? payload.fileId : file.id
72
+ });
73
+ }
74
+ return {
75
+ uploadUrl,
76
+ uploadHeaders: headersOf(payload.uploadHeaders),
77
+ fileId: typeof payload.fileId === "string" ? payload.fileId : file.id,
78
+ key: typeof payload.key === "string" ? payload.key : file.key,
79
+ deduplicated,
80
+ expiresAt: typeof payload.expiresAt === "string" ? payload.expiresAt : null,
81
+ file
82
+ };
83
+ }
84
+ var MAX_HASHED_FILE_BYTES = 512 * 1024 * 1024;
85
+ function hex(digest) {
86
+ const bytes = new Uint8Array(digest);
87
+ let out = "";
88
+ for (let i = 0; i < bytes.length; i++) out += bytes[i].toString(16).padStart(2, "0");
89
+ return out;
90
+ }
91
+ function requireSubtle() {
92
+ if (!globalThis.crypto?.subtle) {
93
+ throw createError.badRequest("This browser cannot hash files (Web Crypto is unavailable), so it cannot upload them.");
94
+ }
95
+ return globalThis.crypto.subtle;
96
+ }
97
+ function readBytes(file) {
98
+ if (typeof file.arrayBuffer === "function") return file.arrayBuffer();
99
+ return new Promise((resolve, reject) => {
100
+ const reader = new FileReader();
101
+ reader.onload = () => resolve(reader.result);
102
+ reader.onerror = () => reject(reader.error ?? new Error("The file could not be read."));
103
+ reader.readAsArrayBuffer(file);
104
+ });
105
+ }
106
+ async function sha256HexOfFile(file) {
107
+ if (file.size > MAX_HASHED_FILE_BYTES) {
108
+ throw createError.badRequest(
109
+ `This file is too large to upload from the browser (the limit is ${MAX_HASHED_FILE_BYTES / (1024 * 1024)} MB).`
110
+ );
111
+ }
112
+ const subtle = requireSubtle();
113
+ return hex(await subtle.digest("SHA-256", await readBytes(file)));
114
+ }
115
+ var CHECKSUM_SHA256_HEADER = "x-amz-checksum-sha256";
116
+ var UPLOAD_ID_HEADER = "x-amz-meta-upload-id";
117
+ function sha256HexToBase64(contentHash) {
118
+ const pairs = contentHash.match(/.{2}/g) ?? [];
119
+ let binary = "";
120
+ for (const pair of pairs) binary += String.fromCharCode(parseInt(pair, 16));
121
+ return btoa(binary);
122
+ }
123
+ function fallbackPutHeaders(contentType, contentHash, uploadId) {
124
+ return {
125
+ "Content-Type": contentType,
126
+ ...contentHash ? { [CHECKSUM_SHA256_HEADER]: sha256HexToBase64(contentHash) } : {},
127
+ ...uploadId ? { [UPLOAD_ID_HEADER]: uploadId } : {}
128
+ };
129
+ }
130
+ var STORAGE_UPLOAD_BLOCKED_MESSAGE = "Upload failed: file storage didn't accept uploads from this site, or the connection dropped. If it keeps failing, ask an admin to allow this site in the storage settings.";
131
+ var PUT_RESPONSE = "putResponse";
132
+ function putRejected(status, statusText, body) {
133
+ const error = createError.badRequest(`Upload failed: ${status} ${statusText}${body ? ` \u2014 ${body}` : ""}`);
134
+ Object.defineProperty(error, PUT_RESPONSE, { value: { status, body }, enumerable: false });
135
+ return error;
136
+ }
137
+ function putResponseOf(error) {
138
+ const response = error && typeof error === "object" ? error[PUT_RESPONSE] : null;
139
+ return response && typeof response === "object" ? response : null;
140
+ }
141
+ function abortError() {
142
+ return typeof DOMException === "function" ? new DOMException("The upload was cancelled.", "AbortError") : Object.assign(new Error("The upload was cancelled."), { name: "AbortError" });
143
+ }
144
+ function isAbortError(error) {
145
+ return Boolean(error && typeof error === "object" && error.name === "AbortError");
146
+ }
147
+ function blockedError() {
148
+ return createError.graphql(STORAGE_UPLOAD_BLOCKED_MESSAGE, "STORAGE_UPLOAD_BLOCKED");
149
+ }
150
+ function putWithXhr(url, body, options, total) {
151
+ return new Promise((resolve, reject) => {
152
+ const xhr = new XMLHttpRequest();
153
+ const onAbort = () => xhr.abort();
154
+ const done = () => options.signal?.removeEventListener("abort", onAbort);
155
+ xhr.open("PUT", url);
156
+ for (const [name, value] of Object.entries(options.headers)) xhr.setRequestHeader(name, value);
157
+ xhr.upload.addEventListener("progress", (event) => {
158
+ if (!event.lengthComputable || event.total === 0) return;
159
+ options.onProgress?.({ loaded: event.loaded, total: event.total, percentage: Math.round(event.loaded / event.total * 100) });
160
+ });
161
+ xhr.addEventListener("load", () => {
162
+ done();
163
+ if (xhr.status >= 200 && xhr.status < 300) {
164
+ options.onProgress?.({ loaded: total, total, percentage: 100 });
165
+ resolve();
166
+ } else {
167
+ reject(putRejected(xhr.status, xhr.statusText, xhr.responseText ?? ""));
168
+ }
169
+ });
170
+ xhr.addEventListener("error", () => {
171
+ done();
172
+ reject(blockedError());
173
+ });
174
+ xhr.addEventListener("abort", () => {
175
+ done();
176
+ reject(abortError());
177
+ });
178
+ options.signal?.addEventListener("abort", onAbort, { once: true });
179
+ xhr.send(body);
180
+ });
181
+ }
182
+ async function putFile(url, body, options) {
183
+ if (options.signal?.aborted) throw abortError();
184
+ const total = body instanceof ArrayBuffer ? body.byteLength : body.size;
185
+ if (options.onProgress && typeof XMLHttpRequest !== "undefined") {
186
+ await putWithXhr(url, body, options, total);
187
+ return;
188
+ }
189
+ let response;
190
+ try {
191
+ response = await fetch(url, {
192
+ method: "PUT",
193
+ headers: options.headers,
194
+ body,
195
+ ...options.signal ? { signal: options.signal } : {}
196
+ });
197
+ } catch (error) {
198
+ if (isAbortError(error)) throw abortError();
199
+ throw blockedError();
200
+ }
201
+ if (!response.ok) {
202
+ throw putRejected(response.status, response.statusText, await response.text().catch(() => ""));
203
+ }
204
+ options.onProgress?.({ loaded: total, total, percentage: 100 });
205
+ }
206
+ function isExpired(payload, now = Date.now()) {
207
+ if (!payload.expiresAt) return false;
208
+ const expiry = Date.parse(payload.expiresAt);
209
+ return Number.isFinite(expiry) && expiry <= now;
210
+ }
211
+ function looksExpired(error, payload) {
212
+ const response = putResponseOf(error);
213
+ if (response?.status !== 403) return false;
214
+ return isExpired(payload) || /expired/i.test(response.body);
215
+ }
216
+ async function transferFile(file, request, options = {}) {
217
+ const contentType = file.type || "application/octet-stream";
218
+ const contentHash = await sha256HexOfFile(file);
219
+ if (options.signal?.aborted) throw abortError();
220
+ const input = { contentHash, contentType, size: file.size, filename: file.name };
221
+ let payload = await request(input, options.signal);
222
+ const putOrRenew = async () => {
223
+ for (let renewals = 0; ; renewals += 1) {
224
+ if (payload.deduplicated) {
225
+ options.onProgress?.({ loaded: file.size, total: file.size, percentage: 100 });
226
+ return payload;
227
+ }
228
+ if (options.signal?.aborted) throw abortError();
229
+ if (isExpired(payload) && renewals === 0) {
230
+ payload = await request(input, options.signal);
231
+ continue;
232
+ }
233
+ try {
234
+ await putFile(payload.uploadUrl, file, {
235
+ headers: payload.uploadHeaders ?? fallbackPutHeaders(contentType, contentHash, payload.fileId),
236
+ onProgress: options.onProgress,
237
+ signal: options.signal
238
+ });
239
+ return payload;
240
+ } catch (error) {
241
+ if (renewals > 0 || !looksExpired(error, payload)) throw error;
242
+ payload = await request(input, options.signal);
243
+ }
244
+ }
245
+ };
246
+ try {
247
+ return await putOrRenew();
248
+ } catch (error) {
249
+ throw withUnfinishedUpload(error, { fileId: payload.fileId });
250
+ }
251
+ }
252
+
253
+ // src/context/sheets-upload-discovery.ts
254
+ var capabilityCache = /* @__PURE__ */ new WeakMap();
255
+ async function discoverStorageCapabilities(endpoint, execute) {
256
+ let endpoints = capabilityCache.get(execute);
257
+ if (!endpoints) {
258
+ endpoints = /* @__PURE__ */ new Map();
259
+ capabilityCache.set(execute, endpoints);
260
+ }
261
+ const cached = endpoints.get(endpoint);
262
+ if (cached) return cached;
263
+ const promise = (async () => {
264
+ const data = await execute(getIntrospectionQuery());
265
+ const schema = data?.__schema;
266
+ if (!schema) throw createError2.badRequest("Uploads are not enabled for this endpoint.");
267
+ return resolveStorageCapabilities(schema);
268
+ })();
269
+ promise.catch(() => endpoints.delete(endpoint));
270
+ endpoints.set(endpoint, promise);
271
+ return promise;
272
+ }
273
+ async function discoverUploadCapability(endpoint, execute, uploadFieldName) {
274
+ const { upload, uploads } = await discoverStorageCapabilities(endpoint, execute);
275
+ if (uploadFieldName) {
276
+ const named = uploads.find((candidate) => candidate.uploadFieldName === uploadFieldName);
277
+ if (!named) throw createError2.badRequest(`Uploads are not enabled for this endpoint: it has no ${uploadFieldName}.`);
278
+ return { ...named, download: null };
279
+ }
280
+ if (!upload) capabilityCache.get(execute)?.delete(endpoint);
281
+ return requireUploadCapability(upload);
282
+ }
283
+ async function discoverSoleUploadCapability(storage) {
284
+ const { uploads, sole } = await discoverStorageCapabilities(storage.endpoint, storage.execute);
285
+ if (uploads.length > 1) {
286
+ throw createError2.badRequest("The storage service has several file stores, and none is chosen for this column.");
287
+ }
288
+ if (!sole) {
289
+ capabilityCache.get(storage.execute)?.delete(storage.endpoint);
290
+ throw createError2.badRequest("Uploads are not enabled for this storage service.");
291
+ }
292
+ return sole;
293
+ }
294
+ function requireUploadCapability(upload) {
295
+ if (!upload) throw createError2.badRequest("Uploads are not enabled for this endpoint.");
296
+ return upload;
297
+ }
298
+ function namedTypeName(ref) {
299
+ let cur = ref;
300
+ while (cur && (cur.kind === "NON_NULL" || cur.kind === "LIST")) cur = cur.ofType ?? null;
301
+ return cur?.name ?? null;
302
+ }
303
+ function isListTypeRef(ref) {
304
+ let cur = ref;
305
+ while (cur && cur.kind === "NON_NULL") cur = cur.ofType ?? null;
306
+ return cur?.kind === "LIST";
307
+ }
308
+ var PK_FIELD_NAME = "id";
309
+ function resolveStorageCapabilities(schema) {
310
+ const typeByName = /* @__PURE__ */ new Map();
311
+ for (const t of schema.types) {
312
+ if (t.name) typeByName.set(t.name, t);
313
+ }
314
+ const objectHasFields = (typeName, names) => {
315
+ const t = typeName ? typeByName.get(typeName) : void 0;
316
+ if (!t?.fields) return false;
317
+ const present = new Set(t.fields.map((f) => f.name));
318
+ return names.every((n) => present.has(n));
319
+ };
320
+ const inputHasFields = (typeName, names) => {
321
+ const t = typeName ? typeByName.get(typeName) : void 0;
322
+ if (!t?.inputFields) return false;
323
+ const present = new Set(t.inputFields.map((f) => f.name));
324
+ return names.every((n) => present.has(n));
325
+ };
326
+ const PAYLOAD_FIELDS = ["uploadUrl", "fileId", "key", "deduplicated"];
327
+ const INPUT_FIELDS = ["contentHash", "contentType", "size"];
328
+ const LEGACY_INPUT_FIELDS = [...INPUT_FIELDS, "bucketKey"];
329
+ const mutationType = schema.mutationType ? typeByName.get(schema.mutationType.name) : null;
330
+ const queryType = schema.queryType ? typeByName.get(schema.queryType.name) : null;
331
+ let upload = null;
332
+ const uploads = [];
333
+ for (const field of mutationType?.fields ?? []) {
334
+ const inputArg = field.args.find((a) => a.name === "input");
335
+ if (!inputArg) continue;
336
+ const inputTypeName = namedTypeName(inputArg.type);
337
+ const payloadTypeName = namedTypeName(field.type);
338
+ if (inputTypeName && inputHasFields(inputTypeName, INPUT_FIELDS) && objectHasFields(payloadTypeName, PAYLOAD_FIELDS)) {
339
+ const payloadFields = typeByName.get(payloadTypeName ?? "")?.fields ?? [];
340
+ const candidate = {
341
+ uploadFieldName: field.name,
342
+ inputTypeName,
343
+ hasFileProjection: payloadFields.some(
344
+ (f) => f.name === "file" && !isListTypeRef(f.type) && namedTypeName(f.type) === "JSON"
345
+ ),
346
+ payloadFieldNames: payloadFields.map((f) => f.name),
347
+ inputFieldNames: (typeByName.get(inputTypeName)?.inputFields ?? []).map((f) => f.name)
348
+ };
349
+ uploads.push(candidate);
350
+ if (!inputHasFields(inputTypeName, LEGACY_INPUT_FIELDS) || upload?.uploadFieldName === "uploadAppFile") continue;
351
+ if (field.name === "uploadAppFile") upload = candidate;
352
+ else upload ??= candidate;
353
+ }
354
+ }
355
+ const fileTypes = /* @__PURE__ */ new Set();
356
+ for (const t of schema.types) {
357
+ if (t.kind === "OBJECT" && t.name && t.fields?.some((f) => f.name === "downloadUrl")) fileTypes.add(t.name);
358
+ }
359
+ const uploadType = upload?.uploadFieldName.replace(/^upload/, "") ?? "AppFile";
360
+ const uploadDownload = resolveDownloadByIdField(typeByName, queryType, fileTypes, uploadType);
361
+ const preferredPreviewType = fileTypes.has("AppFile") ? "AppFile" : uploadType;
362
+ const previewType = fileTypes.has(preferredPreviewType) ? preferredPreviewType : uploadDownload?.fileTypeName ?? preferredPreviewType;
363
+ const download = previewType === uploadType ? uploadDownload : resolveDownloadByIdField(typeByName, queryType, fileTypes, previewType);
364
+ const batch = resolveConnectionDownloadField(typeByName, queryType, fileTypes, previewType, true);
365
+ const only = uploads.length === 1 ? uploads[0] : null;
366
+ const sole = only ? {
367
+ ...only,
368
+ download: only === upload ? uploadDownload : resolveDownloadByIdField(typeByName, queryType, fileTypes, only.uploadFieldName.replace(/^upload/, ""))
369
+ } : null;
370
+ return {
371
+ upload: upload ? { ...upload, download: uploadDownload } : null,
372
+ uploads,
373
+ sole,
374
+ download,
375
+ batch
376
+ };
377
+ }
378
+ function resolveDownloadByIdField(typeByName, queryType, fileTypesWithDownloadUrl, preferred) {
379
+ let singular = null;
380
+ for (const field of queryType?.fields ?? []) {
381
+ const returnTypeName = namedTypeName(field.type);
382
+ if (!returnTypeName || !fileTypesWithDownloadUrl.has(returnTypeName)) continue;
383
+ if (field.args.length === 1 && field.args[0].name === PK_FIELD_NAME) {
384
+ const candidate = {
385
+ fileByIdField: field.name,
386
+ fileByIdArgName: "id",
387
+ fileTypeName: returnTypeName,
388
+ idScalarName: namedTypeName(field.args[0].type) ?? void 0
389
+ };
390
+ if (returnTypeName === preferred) return candidate;
391
+ singular ??= candidate;
392
+ }
393
+ }
394
+ const connection = resolveConnectionDownloadField(typeByName, queryType, fileTypesWithDownloadUrl, preferred);
395
+ if (connection?.fileTypeName === preferred) return connection;
396
+ if (singular || connection) return singular ?? connection;
397
+ const nodeField = queryType?.fields?.find((f) => f.name === "node" && f.args.some((a) => a.name === "nodeId"));
398
+ if (nodeField && fileTypesWithDownloadUrl.size > 0) {
399
+ const fileTypeName = fileTypesWithDownloadUrl.has(preferred) ? preferred : [...fileTypesWithDownloadUrl][0];
400
+ return { fileByIdField: "node", fileByIdArgName: "nodeId", fileTypeName };
401
+ }
402
+ return null;
403
+ }
404
+ function resolveConnectionDownloadField(typeByName, queryType, fileTypesWithDownloadUrl, preferred, batch = false) {
405
+ const EQUALITY_OPERATORS = ["equalTo", "eq"];
406
+ const candidates = [];
407
+ for (const field of queryType?.fields ?? []) {
408
+ const connTypeName = namedTypeName(field.type);
409
+ if (!connTypeName) continue;
410
+ const connType = typeByName.get(connTypeName);
411
+ if (connType?.kind !== "OBJECT" || !connType.fields) continue;
412
+ const nodesField = connType.fields.find((f) => {
413
+ if (!isListTypeRef(f.type)) return false;
414
+ const elem = namedTypeName(f.type);
415
+ return elem != null && fileTypesWithDownloadUrl.has(elem);
416
+ });
417
+ if (!nodesField) continue;
418
+ const fileTypeName = namedTypeName(nodesField.type);
419
+ if (batch && (fileTypeName !== preferred || !typeByName.get(fileTypeName)?.fields?.some((candidate) => candidate.name === PK_FIELD_NAME))) continue;
420
+ const connectionHasFirst = field.args.some((arg) => arg.name === "first");
421
+ for (const arg of field.args) {
422
+ const filterTypeName = namedTypeName(arg.type);
423
+ const filterType = filterTypeName ? typeByName.get(filterTypeName) : null;
424
+ if (filterType?.kind !== "INPUT_OBJECT" || !filterType.inputFields) continue;
425
+ const idField = filterType.inputFields.find((f) => f.name === PK_FIELD_NAME);
426
+ if (!idField) continue;
427
+ const idFieldTypeName = namedTypeName(idField.type);
428
+ const idFieldType = idFieldTypeName ? typeByName.get(idFieldTypeName) : null;
429
+ if (idFieldType?.kind === "INPUT_OBJECT" && idFieldType.inputFields) {
430
+ const inputFields = idFieldType.inputFields;
431
+ const opField = batch ? inputFields.find((f) => f.name === "in" && isListTypeRef(f.type)) : EQUALITY_OPERATORS.map((op) => inputFields.find((f) => f.name === op)).find((f) => f != null);
432
+ if (opField) {
433
+ candidates.push({
434
+ fileByIdField: field.name,
435
+ fileByIdArgName: "connection",
436
+ fileTypeName,
437
+ idScalarName: namedTypeName(opField.type) ?? void 0,
438
+ connectionFilterArgName: arg.name,
439
+ connectionIdField: idField.name,
440
+ connectionIdOperator: opField.name,
441
+ connectionNodesField: nodesField.name,
442
+ connectionHasFirst
443
+ });
444
+ break;
445
+ }
446
+ continue;
447
+ }
448
+ if (!batch && (idFieldType?.kind === "SCALAR" || !idFieldType && idFieldTypeName)) {
449
+ candidates.push({
450
+ fileByIdField: field.name,
451
+ fileByIdArgName: "connection",
452
+ fileTypeName,
453
+ idScalarName: idFieldTypeName ?? void 0,
454
+ connectionFilterArgName: arg.name,
455
+ connectionIdField: idField.name,
456
+ connectionNodesField: nodesField.name,
457
+ connectionHasFirst
458
+ });
459
+ break;
460
+ }
461
+ }
462
+ }
463
+ if (candidates.length === 0) return null;
464
+ return candidates.find((c) => c.fileTypeName === preferred) ?? candidates[0];
465
+ }
466
+ function uploadInputOf(cap, input) {
467
+ const inputFields = new Set(cap.inputFieldNames ?? []);
468
+ const has = (name) => inputFields.size === 0 || inputFields.has(name);
469
+ const bucket = input.bucketKey !== void 0 ? has("bucketKey") ? { bucketKey: input.bucketKey } : {} : has("isPublic") ? { isPublic: input.isPublic ?? true } : {};
470
+ return {
471
+ ...bucket,
472
+ ...input.databaseId !== void 0 && inputFields.has("databaseId") ? { databaseId: input.databaseId } : {},
473
+ contentHash: input.contentHash,
474
+ contentType: input.contentType,
475
+ size: input.size,
476
+ ...has("filename") ? { filename: input.filename } : {}
477
+ };
478
+ }
479
+ function uploadMutation(cap, payloadFields) {
480
+ return `
481
+ mutation SheetsUpload($input: ${cap.inputTypeName}!) {
482
+ ${cap.uploadFieldName}(input: $input) {
483
+ ${payloadFields.join("\n ")}
484
+ }
485
+ }
486
+ `.trim();
487
+ }
488
+ var LEGACY_PAYLOAD_FIELDS = ["uploadUrl", "fileId", "key", "deduplicated", "file"];
489
+ async function requestDiscoveredUpload(execute, cap, input, signal) {
490
+ const payloadFields = cap.payloadFieldNames?.length ? UPLOAD_PAYLOAD_FIELDS.filter((name) => cap.payloadFieldNames.includes(name)) : LEGACY_PAYLOAD_FIELDS;
491
+ const data = await execute(uploadMutation(cap, payloadFields), { input: uploadInputOf(cap, input) }, { signal });
492
+ return readUploadPayload(data?.[cap.uploadFieldName]);
493
+ }
494
+ function projectionToFileValue(file, fallbackName, fallbackMime) {
495
+ return {
496
+ ...file,
497
+ bucket_id: typeof file.bucket_id === "string" ? file.bucket_id : "",
498
+ mime: typeof file.mime === "string" ? file.mime : fallbackMime,
499
+ size: typeof file.size === "number" ? file.size : 0,
500
+ filename: typeof file.filename === "string" ? file.filename : fallbackName
501
+ };
502
+ }
503
+ function createPresignedSheetsUpload({ endpoint, execute }, bucketKey) {
504
+ return async (file, _path, options) => {
505
+ if (!endpoint) throw createError2.badRequest("No GraphQL endpoint configured.");
506
+ const cap = await discoverUploadCapability(endpoint, execute);
507
+ if (!cap.hasFileProjection) {
508
+ throw createError2.badRequest("Uploads require a storage mutation that returns a file projection.");
509
+ }
510
+ let payload;
511
+ try {
512
+ payload = await transferFile(
513
+ file,
514
+ (input) => requestDiscoveredUpload(execute, cap, { ...input, bucketKey }),
515
+ { onProgress: options?.onProgress }
516
+ );
517
+ } catch (error) {
518
+ throw withUnfinishedUpload(error, { filesType: cap.download?.fileTypeName ?? null });
519
+ }
520
+ const result = {
521
+ file: projectionToFileValue(payload.file, file.name, file.type || "application/octet-stream")
522
+ };
523
+ if (!cap.download) return result;
524
+ try {
525
+ return { ...result, url: await fetchDownloadUrl(execute, cap.download, payload.fileId) };
526
+ } catch {
527
+ return result;
528
+ }
529
+ };
530
+ }
531
+ function toGlobalId(typeName, id) {
532
+ if (typeof btoa !== "function") {
533
+ throw createError2.badRequest("Cannot encode the file node id: btoa is unavailable in this environment.");
534
+ }
535
+ return btoa(JSON.stringify([typeName, id]));
536
+ }
537
+ async function fetchDownloadUrl(execute, cap, fileId) {
538
+ const missing = () => createError2.badRequest("Upload succeeded but no downloadUrl was returned for the file.");
539
+ if (cap.fileByIdArgName === "nodeId") {
540
+ const nodeId = toGlobalId(cap.fileTypeName, fileId);
541
+ const query2 = `
542
+ query SheetsDownloadUrl($nodeId: ID!) {
543
+ ${cap.fileByIdField}(nodeId: $nodeId) {
544
+ ... on ${cap.fileTypeName} {
545
+ downloadUrl
546
+ }
547
+ }
548
+ }
549
+ `.trim();
550
+ const data2 = await execute(query2, { nodeId });
551
+ const url2 = data2?.[cap.fileByIdField]?.downloadUrl;
552
+ if (!url2) throw missing();
553
+ return url2;
554
+ }
555
+ if (cap.fileByIdArgName === "connection") {
556
+ const idScalar2 = cap.idScalarName ?? "ID";
557
+ const filterArg = cap.connectionFilterArgName;
558
+ const idField = cap.connectionIdField;
559
+ const nodesField = cap.connectionNodesField;
560
+ const filterLiteral = cap.connectionIdOperator ? `{ ${idField}: { ${cap.connectionIdOperator}: $id } }` : `{ ${idField}: $id }`;
561
+ const query2 = `
562
+ query SheetsDownloadUrl($id: ${idScalar2}!) {
563
+ ${cap.fileByIdField}(${filterArg}: ${filterLiteral}${cap.connectionHasFirst ? ", first: 1" : ""}) {
564
+ ${nodesField} {
565
+ downloadUrl
566
+ }
567
+ }
568
+ }
569
+ `.trim();
570
+ const data2 = await execute(
571
+ query2,
572
+ { id: fileId }
573
+ );
574
+ const url2 = data2?.[cap.fileByIdField]?.[nodesField]?.[0]?.downloadUrl;
575
+ if (!url2) throw missing();
576
+ return url2;
577
+ }
578
+ const idScalar = cap.idScalarName ?? "ID";
579
+ const query = `
580
+ query SheetsDownloadUrl($id: ${idScalar}!) {
581
+ ${cap.fileByIdField}(id: $id) {
582
+ id
583
+ downloadUrl
584
+ }
585
+ }
586
+ `.trim();
587
+ const data = await execute(query, { id: fileId });
588
+ const url = data?.[cap.fileByIdField]?.downloadUrl;
589
+ if (!url) throw missing();
590
+ return url;
591
+ }
592
+ async function fetchMediaDownloadUrls({ endpoint, execute }, getActiveIds) {
593
+ const { batch, download } = await discoverStorageCapabilities(endpoint, execute);
594
+ const ids = getActiveIds();
595
+ const urls = /* @__PURE__ */ new Map();
596
+ if (ids.length === 0) return urls;
597
+ if (batch) {
598
+ const first = batch.connectionHasFirst ? `, first: ${ids.length}` : "";
599
+ const query = `query SheetsMediaDownloadUrls($ids: [${batch.idScalarName ?? "ID"}!]!) {
600
+ ${batch.fileByIdField}(${batch.connectionFilterArgName}: {
601
+ ${batch.connectionIdField}: { in: $ids }
602
+ }${first}) { ${batch.connectionNodesField} { id downloadUrl } }
603
+ }`;
604
+ const data = await execute(query, { ids });
605
+ for (const row of data?.[batch.fileByIdField]?.[batch.connectionNodesField] ?? []) {
606
+ if (row?.downloadUrl) urls.set(row.id, row.downloadUrl);
607
+ }
608
+ } else if (download) {
609
+ const results = await Promise.allSettled(ids.map((id) => fetchDownloadUrl(execute, download, id)));
610
+ results.forEach((result, index) => {
611
+ if (result.status === "fulfilled") urls.set(ids[index], result.value);
612
+ });
613
+ }
614
+ return urls;
615
+ }
616
+ async function resolveDownloadUrl(execute, endpoint, fileId) {
617
+ try {
618
+ const { download } = await discoverStorageCapabilities(endpoint, execute);
619
+ return download ? await fetchDownloadUrl(execute, download, fileId) : null;
620
+ } catch {
621
+ return null;
622
+ }
623
+ }
624
+
625
+ // src/context/sheets-execute.ts
626
+ import { print } from "graphql";
627
+ import { ConstructiveError, createError as createError3, isAuthenticationCode, parseGraphQLError } from "@constructive-io/data";
628
+ import { ConstructiveError as ConstructiveError2 } from "@constructive-io/data";
629
+ function documentToString(document) {
630
+ if (typeof document === "string") return document;
631
+ if (document instanceof String) return document.toString();
632
+ if (document && typeof document === "object" && "kind" in document) {
633
+ return print(document);
634
+ }
635
+ if (document === null || document === void 0) {
636
+ throw createError3.badRequest("Invalid GraphQL document: null or undefined");
637
+ }
638
+ return String(document);
639
+ }
640
+ var PARTIAL_RESULT = "partialResult";
641
+ var RESPONSE_ERRORS = "responseErrors";
642
+ function withResponseErrors(error, data, errors) {
643
+ Object.defineProperty(error, RESPONSE_ERRORS, { value: errors, enumerable: false, configurable: true });
644
+ if (data != null) {
645
+ Object.defineProperty(error, PARTIAL_RESULT, {
646
+ value: { data, errors },
647
+ enumerable: false,
648
+ configurable: true
649
+ });
650
+ }
651
+ return error;
652
+ }
653
+ function responseErrorsOf(error) {
654
+ const errors = error && typeof error === "object" ? error[RESPONSE_ERRORS] : null;
655
+ return Array.isArray(errors) ? errors : null;
656
+ }
657
+ function partialResultOf(error) {
658
+ const partial = error && typeof error === "object" ? error[PARTIAL_RESULT] : null;
659
+ return partial && typeof partial === "object" ? partial : null;
660
+ }
661
+ function parseGraphQLResponse(response, onAuthError) {
662
+ if (!response.errors?.length) return null;
663
+ if (response.errors.some((candidate) => isAuthenticationCode(candidate.extensions?.code))) {
664
+ onAuthError?.();
665
+ return createError3.unauthorized("Authentication required. Please log in again.");
666
+ }
667
+ const error = response.errors[0];
668
+ const code = error.extensions?.code;
669
+ const message = error.message || "GraphQL query failed";
670
+ if (code === "ACCESS_SUSPENDED") return parseGraphQLError(error);
671
+ if (code === "FORBIDDEN") {
672
+ return createError3.forbidden("You do not have permission to perform this action.");
673
+ }
674
+ return createError3.graphql(message, code);
675
+ }
676
+ function createSheetsExecute(config, getToken) {
677
+ return async (document, variables, options) => {
678
+ const url = config.endpoint;
679
+ if (!url) {
680
+ throw createError3.badRequest("No GraphQL endpoint configured.");
681
+ }
682
+ const token = getToken();
683
+ const headers = {
684
+ "Content-Type": "application/json",
685
+ Accept: "application/graphql-response+json"
686
+ };
687
+ if (token) {
688
+ headers["Authorization"] = `Bearer ${token}`;
689
+ }
690
+ let response;
691
+ try {
692
+ response = await fetch(url, {
693
+ method: "POST",
694
+ headers,
695
+ body: JSON.stringify({
696
+ query: documentToString(document),
697
+ ...variables !== void 0 && { variables }
698
+ }),
699
+ ...options?.signal ? { signal: options.signal } : {}
700
+ });
701
+ } catch (error) {
702
+ throw createError3.network(error instanceof Error ? error : void 0);
703
+ }
704
+ if (!response.ok) {
705
+ const { status, statusText } = response;
706
+ if (status === 401) {
707
+ config.onAuthError?.();
708
+ throw createError3.unauthorized("Authentication required. Please log in again.");
709
+ }
710
+ if (status === 403) {
711
+ const body = await response.json().catch(() => null);
712
+ const refusal = body?.errors?.[0];
713
+ const forbidden = refusal?.extensions?.code === "ACCESS_SUSPENDED" ? parseGraphQLError(refusal) : createError3.forbidden("You do not have permission to perform this action.");
714
+ throw body?.errors?.length ? withResponseErrors(forbidden, null, body.errors) : forbidden;
715
+ }
716
+ if (status === 404) {
717
+ throw createError3.notFound("The requested endpoint does not exist.");
718
+ }
719
+ try {
720
+ const body = await response.json();
721
+ if (body.errors?.length) {
722
+ throw withResponseErrors(
723
+ createError3.graphql(body.errors[0].message || `Request failed: ${status}`, body.errors[0].extensions?.code),
724
+ null,
725
+ body.errors
726
+ );
727
+ }
728
+ } catch (e) {
729
+ if (e instanceof ConstructiveError) throw e;
730
+ }
731
+ throw createError3.badRequest(`Request failed: ${status} ${statusText}`);
732
+ }
733
+ const result = await response.json();
734
+ const graphqlError = parseGraphQLResponse(result, config.onAuthError);
735
+ if (graphqlError) {
736
+ const keepsData = !["UNAUTHENTICATED", "ACCESS_SUSPENDED"].includes(graphqlError.code);
737
+ throw withResponseErrors(graphqlError, keepsData ? result.data : null, result.errors ?? []);
738
+ }
739
+ return result.data;
740
+ };
741
+ }
742
+ function resolveStorageTransport(config, getToken) {
743
+ const endpoint = config.storage?.endpoint;
744
+ if (!endpoint) return void 0;
745
+ return {
746
+ endpoint,
747
+ execute: config.storage?.execute ?? createSheetsExecute({ ...config, endpoint }, getToken)
748
+ };
749
+ }
750
+ function createSheetsUpload(config, getToken) {
751
+ const transport = resolveStorageTransport(config, getToken) ?? {
752
+ endpoint: config.endpoint,
753
+ execute: config.execute ?? createSheetsExecute(config, getToken)
754
+ };
755
+ return createPresignedSheetsUpload(transport, config.upload?.bucketKey);
756
+ }
757
+
758
+ // src/hooks/query-keys.ts
759
+ function isSheetsScopeKey(value) {
760
+ if (!value || typeof value !== "object") return false;
761
+ const candidate = value;
762
+ return "databaseId" in candidate && "endpoint" in candidate && "identityKey" in candidate;
763
+ }
764
+ function reuseSheetsPlaceholderData(previousData, previousQueryKey, currentScope) {
765
+ const previousScope = previousQueryKey?.[1];
766
+ if (!isSheetsScopeKey(previousScope)) return void 0;
767
+ if (previousScope.databaseId !== currentScope.databaseId) return void 0;
768
+ if (previousScope.endpoint !== currentScope.endpoint) return void 0;
769
+ if (previousScope.identityKey !== currentScope.identityKey) return void 0;
770
+ return previousData;
771
+ }
772
+ function tableKeySegments(tableRef) {
773
+ const dot = tableRef.lastIndexOf(".");
774
+ return dot === -1 ? [tableRef] : [tableRef.slice(dot + 1), tableRef.slice(0, dot)];
775
+ }
776
+ var sheetsQueryKeys = {
777
+ root: ["sheets"],
778
+ scope: (scope) => ["sheets", scope],
779
+ meta: (scope) => [...sheetsQueryKeys.scope(scope), "meta"],
780
+ /** One table model, per `_meta` version and display override. */
781
+ tableModel: (scope, tableKey, metaVersion, displayKey) => [...sheetsQueryKeys.scope(scope), "table-model", ...tableKeySegments(tableKey), metaVersion, displayKey],
782
+ mediaUrl: (scope, endpoint, id) => [...sheetsQueryKeys.scope(scope), "media-url", endpoint, id],
783
+ relations: (scope, tableName) => [...sheetsQueryKeys.scope(scope), "relations", ...tableKeySegments(tableName)],
784
+ table: (scope, tableRef) => [...sheetsQueryKeys.scope(scope), "table", ...tableKeySegments(tableRef)],
785
+ tableRows: (scope, tableRef, options) => [...sheetsQueryKeys.table(scope, tableRef), "rows", options],
786
+ tableRow: (scope, tableRef, id) => [...sheetsQueryKeys.table(scope, tableRef), "row", id],
787
+ tableCount: (scope, tableRef, where) => [...sheetsQueryKeys.table(scope, tableRef), "count", where],
788
+ infiniteTable: (scope, tableRef) => [...sheetsQueryKeys.scope(scope), "infinite-table", ...tableKeySegments(tableRef)],
789
+ infiniteTablePage: (scope, tableRef, pageIndex, options) => [...sheetsQueryKeys.infiniteTable(scope, tableRef), "page", pageIndex, options],
790
+ infiniteTableTotalCount: (scope, tableRef, where) => [...sheetsQueryKeys.infiniteTable(scope, tableRef), "totalCount", where],
791
+ cursorTable: (scope, tableRef, options) => [...sheetsQueryKeys.scope(scope), "cursor-table", ...tableKeySegments(tableRef), options]
792
+ };
793
+ var sheetsMutationKeys = {
794
+ /** Every mutation of a table, or one operation of it when `operation` is given. */
795
+ table: (scope, tableRef, operation, ...detail) => operation === void 0 ? [...sheetsQueryKeys.table(scope, tableRef), "mutation"] : [...sheetsQueryKeys.table(scope, tableRef), "mutation", operation, ...detail]
796
+ };
797
+
798
+ // src/utils/sheets-logger.ts
799
+ var defaultLogger = {
800
+ warn: (...a) => console.warn(...a),
801
+ error: (...a) => console.error(...a)
802
+ // debug omitted = no-op
803
+ };
804
+ var active = defaultLogger;
805
+ function setSheetsLogger(l) {
806
+ active = l ? { ...defaultLogger, ...l } : defaultLogger;
807
+ }
808
+ function sheetsLogger() {
809
+ return active;
810
+ }
811
+
812
+ export {
813
+ discoverSoleUploadCapability,
814
+ requestDiscoveredUpload,
815
+ createPresignedSheetsUpload,
816
+ fetchMediaDownloadUrls,
817
+ resolveDownloadUrl,
818
+ UPLOAD_PAYLOAD_FIELDS,
819
+ unfinishedUploadOf,
820
+ withUnfinishedUpload,
821
+ readUploadPayload,
822
+ isAbortError,
823
+ transferFile,
824
+ withResponseErrors,
825
+ responseErrorsOf,
826
+ partialResultOf,
827
+ createSheetsExecute,
828
+ resolveStorageTransport,
829
+ createSheetsUpload,
830
+ ConstructiveError2 as ConstructiveError,
831
+ setSheetsLogger,
832
+ sheetsLogger,
833
+ isSheetsScopeKey,
834
+ reuseSheetsPlaceholderData,
835
+ tableKeySegments,
836
+ sheetsQueryKeys,
837
+ sheetsMutationKeys
838
+ };
839
+ //# sourceMappingURL=chunk-MBSHDF55.js.map