@sequenceholdings/storage 0.1.2 → 0.1.3

package/dist/client.js

@@ -1,322 +1,18 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.storageDownloadSchema = exports.StorageApiError = exports.STORAGE_SERVICE_TOKEN_HEADER = exports.STORAGE_TOKEN_HEADER = void 0;
-exports.storageClient = storageClient;
-exports.createStorageClient = createStorageClient;
-const zod_1 = require("zod");
-const contracts_js_1 = require("./contracts.js");
-const transfer_js_1 = require("./transfer.js");
-exports.STORAGE_TOKEN_HEADER = 'x-sequence-storage-token';
-exports.STORAGE_SERVICE_TOKEN_HEADER = 'x-sequence-storage-token-service';
-class StorageApiError extends Error {
-    status;
-    code;
-    constructor(status, code, message) {
-        super(message);
-        this.status = status;
-        this.code = code;
-        this.name = 'StorageApiError';
-    }
-}
-exports.StorageApiError = StorageApiError;
-/** ~5 attempts within ~10s: long enough for the outbox sweeper to catch up. */
-const PERMISSIONS_RETRY = { attempts: 5, baseDelayMs: 625 };
-/** Metadata requests fail fast so a replay-safe caller can retry them. */
-const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
-// Duck-typed so errors re-thrown by an Artifact bridge transport still match.
-function errorStatus(error) {
-    return typeof error === 'object' &&
-        error !== null &&
-        'status' in error &&
-        typeof error.status === 'number'
-        ? error.status
-        : undefined;
-}
-function errorCode(error) {
-    return typeof error === 'object' &&
-        error !== null &&
-        'code' in error &&
-        typeof error.code === 'string'
-        ? error.code
-        : undefined;
-}
-/**
- * The server's retryable 503s: a just-committed permission change is still
- * being applied (`permissions_pending`), or the workspace lock is saturated
- * (`storage_busy`). Neither leaves partial state behind for a replay-safe call.
- */
-function isRetryableConflict(error) {
-    const code = errorCode(error);
-    return (errorStatus(error) === 503 &&
-        (code === 'permissions_pending' || code === 'storage_busy'));
-}
-/**
- * A start whose reply never arrived or failed server-side may still have
- * committed. With its idempotency key it is safe to resend, and the server
- * replays the committed session instead of reserving a second one.
- */
-function isUnacknowledged(error) {
-    if (error instanceof zod_1.z.ZodError)
-        return false;
-    const status = errorStatus(error);
-    // No status: the request never got an HTTP answer (network, bridge).
-    if (status === undefined)
-        return true;
-    return status === 0 || status === 408 || status >= 500;
-}
-/**
- * Retries a replay-safe request while `retryable` says its failure may clear:
- * reads, and mutations the server deduplicates. Byte transfers never come here.
- */
-async function retryReplaySafe({ run, retry, retryable, }) {
-    const attempts = retry.attempts ?? PERMISSIONS_RETRY.attempts;
-    const baseDelayMs = retry.baseDelayMs ?? PERMISSIONS_RETRY.baseDelayMs;
-    for (let attempt = 1;; attempt++) {
-        try {
-            return await run();
-        }
-        catch (error) {
-            if (attempt >= attempts || !retryable(error))
-                throw error;
-            // Equal jitter: spread a burst of callers without retrying immediately.
-            const ceiling = baseDelayMs * 2 ** (attempt - 1);
-            await new Promise((resolve) => setTimeout(resolve, ceiling / 2 + (Math.random() * ceiling) / 2));
-        }
-    }
-}
-async function readJson(response) {
-    const text = await response.text();
-    try {
-        return { parsed: true, value: JSON.parse(text) };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    catch {
-        return { parsed: false };
-    }
-}
-function query(options) {
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries(options))
-        if (value !== undefined && value !== null)
-            params.set(key, String(value));
-    return params.size ? `?${params}` : '';
-}
-exports.storageDownloadSchema = zod_1.z.object({
-    url: zod_1.z.url(),
-    expiresAt: zod_1.z.string(),
-    preview: zod_1.z.boolean(),
-});
-/** Supply a transport for an Artifact bridge, or use createStorageClient for HTTP. */
-function storageClient(transport, { permissionsRetry = {}, } = {}) {
-    const send = async ({ method, path, schema, body, retryable, }) => {
-        const run = () => transport.request(method, `/api/storage${path}`, body);
-        try {
-            return schema.parse(retryable
-                ? await retryReplaySafe({ run, retry: permissionsRetry, retryable })
-                : await run());
-        }
-        catch (error) {
-            // A mutation can commit and then fail re-reading its result, or commit
-            // one step before a later one hits the busy lock, so neither reply
-            // proves nothing changed.
-            if (!retryable && isRetryableConflict(error))
-                throw new StorageApiError(503, errorCode(error) ?? 'permissions_pending', errorCode(error) === 'storage_busy'
-                    ? 'The workspace was busy. The change may have been applied; refresh before retrying.'
-                    : 'Permissions are still synchronizing. The change may have been applied; refresh before retrying.');
-            throw error;
-        }
-    };
-    /** Mutation: never replayed automatically. */
-    const request = (method, path, schema, body) => send({ method, path, schema, body });
-    /** Read, or a mutation the server deduplicates: retried on permissions_pending / storage_busy. */
-    const replayable = (method, path, schema, body) => send({ method, path, schema, body, retryable: isRetryableConflict });
-    return {
-        capabilities: () => replayable('GET', '/capabilities', zod_1.z.object({
-            canProvision: zod_1.z.boolean(),
-            uploadMethods: zod_1.z.array(zod_1.z.string()),
-            pendingUploads: zod_1.z.object({
-                perPrincipal: zod_1.z.number().int(),
-                perWorkspace: zod_1.z.number().int(),
-            }),
-            uploadBatchLimit: zod_1.z.number().int(),
-            importConcurrency: zod_1.z.object({
-                default: zod_1.z.number().int(),
-                max: zod_1.z.number().int(),
-            }),
-        })),
-        list: (options = {}) => replayable('GET', `/workspaces${query({ ...options })}`, (0, contracts_js_1.storagePage)(contracts_js_1.workspaceSchema)),
-        shared: (options = {}) => replayable('GET', `/shared${query({ ...options })}`, (0, contracts_js_1.storagePage)(contracts_js_1.nodeSchema)),
-        // Manifest apply converges on the named workspace, so it is replay-safe.
-        apply: (manifest) => replayable('POST', '/workspaces', contracts_js_1.workspaceSchema, contracts_js_1.workspaceManifestSchema.parse(manifest)),
-        workspace(id) {
-            const root = `/workspaces/${contracts_js_1.storageId.parse(id)}`;
-            const node = (nodeId) => `${root}/nodes/${contracts_js_1.storageId.parse(nodeId)}`;
-            const session = (uploadId) => `${root}/uploads/${contracts_js_1.storageId.parse(uploadId)}`;
-            const access = (nodeId) => `${nodeId ? node(nodeId) : root}/access`;
-            const upload = {
-                // The idempotency key makes a replayed start return the same session,
-                // so it is also resent when its reply was lost: a start that committed
-                // but timed out would otherwise hold a pending-upload slot unnamed
-                // until it expires.
-                start: (input) => send({
-                    method: 'POST',
-                    path: `${root}/uploads`,
-                    schema: contracts_js_1.uploadSessionSchema,
-                    body: contracts_js_1.startUploadSchema.parse(input),
-                    retryable: (error) => isRetryableConflict(error) || isUnacknowledged(error),
-                }),
-                get: (id) => replayable('GET', session(id), contracts_js_1.uploadSessionSchema),
-                /** `resume` passes the CRC32C it computed; pass your own when transferring bytes yourself. */
-                complete: (id, input = {}) => replayable('POST', `${session(id)}/complete`, contracts_js_1.uploadSessionSchema, contracts_js_1.completeUploadSchema.parse(input)),
-                // Abort is idempotent: an aborted session stays aborted, and a completed
-                // one deterministically rejects, so a replay cannot change the outcome.
-                abort: (id) => replayable('DELETE', session(id), contracts_js_1.uploadSessionSchema),
-                startBatch: (items) => send({
-                    method: 'POST',
-                    path: `${root}/uploads/batch`,
-                    schema: zod_1.z.object({ items: zod_1.z.array(contracts_js_1.uploadSessionSchema) }),
-                    body: contracts_js_1.startUploadBatchSchema.parse({ items }),
-                    retryable: (error) => isRetryableConflict(error) || isUnacknowledged(error),
-                }),
-                list: () => replayable('GET', `${root}/uploads`, contracts_js_1.uploadListSchema),
-                reconcile: (input = {}) => send({
-                    method: 'POST',
-                    path: `${root}/uploads/reconcile`,
-                    schema: contracts_js_1.reconcileUploadsResultSchema,
-                    body: contracts_js_1.reconcileUploadsSchema.parse(input),
-                    retryable: isRetryableConflict,
-                }),
-                async resume(id, source, options = {}) {
-                    const current = await upload.get(id);
-                    if (current.state === 'complete')
-                        return current;
-                    if (!current.uploadUrl || current.state !== 'pending')
-                        throw new StorageApiError(409, 'upload_unavailable', 'Upload is no longer pending');
-                    const { crc32c } = await (0, transfer_js_1.transferStorageUpload)({
-                        ...options,
-                        uploadUrl: current.uploadUrl,
-                        maxBytes: current.maxBytes,
-                        source,
-                    });
-                    return upload.complete(id, { crc32c });
-                },
-                /**
-                 * Start, transfer and complete in one call. A failure after the session
-                 * starts aborts it (best effort) to release its reservation; pass
-                 * `keepSessionOnFailure` to keep it for a manual `resume`.
-                 */
-                async put(input, source, { keepSessionOnFailure = false, ...options } = {}) {
-                    // One key per put: every resend of its start names the same session.
-                    const current = await upload.start({
-                        ...input,
-                        idempotencyKey: input.idempotencyKey ?? globalThis.crypto.randomUUID(),
-                        size: source instanceof Blob ? source.size : input.size,
-                    });
-                    try {
-                        return await upload.resume(current.id, source, {
-                            ...options,
-                            size: input.size,
-                        });
-                    }
-                    catch (error) {
-                        if (!keepSessionOnFailure)
-                            await upload.abort(current.id).catch(() => { });
-                        throw error;
-                    }
-                },
-            };
-            return {
-                get: () => replayable('GET', root, contracts_js_1.workspaceSchema),
-                delete: (expectedRevision) => request('DELETE', `${root}${query({ expectedRevision })}`, contracts_js_1.operationSchema),
-                list: (options = {}) => replayable('GET', `${root}/nodes${query({ ...options })}`, (0, contracts_js_1.storagePage)(contracts_js_1.nodeSchema)),
-                getNode: (id) => replayable('GET', node(id), contracts_js_1.nodeSchema),
-                /**
-                 * Keyed like upload start, so every resend (storage_busy,
-                 * permissions_pending, a lost reply) returns the one folder it made.
-                 * Pass `idempotencyKey` to extend that across your own retries.
-                 */
-                createFolder: (name, parentId = null, { idempotencyKey = globalThis.crypto.randomUUID(), } = {}) => send({
-                    method: 'POST',
-                    path: `${root}/nodes`,
-                    schema: contracts_js_1.nodeSchema,
-                    body: contracts_js_1.createFolderSchema.parse({ name, parentId, idempotencyKey }),
-                    retryable: (error) => isRetryableConflict(error) || isUnacknowledged(error),
-                }),
-                update: (id, input) => request('PATCH', node(id), contracts_js_1.nodeSchema, input),
-                trash: (id, expectedRevision) => request('POST', `${node(id)}/trash`, contracts_js_1.nodeSchema, {
-                    expectedRevision,
-                }),
-                restore: (id, expectedRevision) => request('POST', `${node(id)}/restore`, contracts_js_1.nodeSchema, {
-                    expectedRevision,
-                }),
-                purge: (id, expectedRevision) => request('POST', `${node(id)}/purge`, contracts_js_1.operationSchema, {
-                    expectedRevision,
-                }),
-                download: (id, options = {}) => replayable('POST', `${node(id)}/download`, exports.storageDownloadSchema, options),
-                versions: (id, options = {}) => replayable('GET', `${node(id)}/versions${query({ ...options })}`, zod_1.z.object({
-                    items: zod_1.z.array(contracts_js_1.versionSchema),
-                    nextRevision: zod_1.z.number().nullable(),
-                })),
-                restoreVersion: (id, versionId, expectedRevision) => request('POST', `${node(id)}/versions/${contracts_js_1.storageId.parse(versionId)}/restore`, contracts_js_1.versionSchema, { expectedRevision }),
-                deleteVersion: (id, versionId, expectedRevision) => request('DELETE', `${node(id)}/versions/${contracts_js_1.storageId.parse(versionId)}${query({ expectedRevision })}`, contracts_js_1.operationSchema),
-                access: (id) => replayable('GET', access(id), contracts_js_1.storageAccessSchema),
-                setAccess: (input, id) => request('PUT', access(id), contracts_js_1.storageAccessSchema, input),
-                transferOwner: (principal, expectedRevision) => request('PUT', `${root}/owner`, contracts_js_1.storageAccessSchema, {
-                    principal,
-                    expectedRevision,
-                }),
-                operations: (options = {}) => replayable('GET', `${root}/operations${query({ ...options })}`, (0, contracts_js_1.storagePage)(contracts_js_1.operationSchema)),
-                retryOperation: (id) => request('POST', `${root}/operations/${contracts_js_1.storageId.parse(id)}/retry`, contracts_js_1.operationSchema, {}),
-                uploads: upload,
-            };
-        },
-    };
-}
-function createStorageClient({ baseUrl, getToken, getHeaders, fetch: fetcher = globalThis.fetch, permissionsRetry, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, }) {
-    const base = baseUrl.replace(/\/$/, '');
-    return storageClient({
-        async request(method, path, body) {
-            const token = await getToken?.();
-            const signal = requestTimeoutMs > 0
-                ? AbortSignal.timeout(requestTimeoutMs)
-                : undefined;
-            const timedOut = () => new StorageApiError(0, 'request_timeout', `Storage did not answer within ${requestTimeoutMs}ms; the request may still complete`);
-            let response;
-            try {
-                response = await fetcher(`${base}${path}`, {
-                    method,
-                    redirect: 'error',
-                    signal,
-                    headers: {
-                        ...(token ? { Authorization: `Bearer ${token}` } : {}),
-                        ...(await getHeaders?.()),
-                        ...(body === undefined
-                            ? {}
-                            : { 'Content-Type': 'application/json' }),
-                    },
-                    body: body === undefined ? undefined : JSON.stringify(body),
-                });
-            }
-            catch (error) {
-                if (signal?.aborted)
-                    throw timedOut();
-                throw error;
-            }
-            // Proxies and load balancers answer some failures with HTML; check the
-            // status before trusting the body to be JSON.
-            const result = await readJson(response).catch((error) => {
-                if (signal?.aborted)
-                    throw timedOut();
-                throw error;
-            });
-            if (!response.ok) {
-                const parsed = contracts_js_1.storageErrorSchema.safeParse(result.parsed ? result.value : undefined);
-                throw new StorageApiError(response.status, parsed.success ? parsed.data.error.code : 'request_failed', parsed.success
-                    ? parsed.data.error.message
-                    : `Storage request failed (${response.status})`);
-            }
-            if (!result.parsed)
-                throw new StorageApiError(response.status, 'invalid_response', 'Storage returned a response that is not JSON');
-            return result.value;
-        },
-    }, { permissionsRetry });
-}
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** Runtime compatibility export; implementation lives in the platform SDK. */
+__exportStar(require("@sequenceholdings/platform/storage"), exports);