@unofficialbox/box-open-sdk 0.1.0

package/dist/esm/managers/users.js

@@ -0,0 +1,128 @@
+// Code generated by box-gantry. DO NOT EDIT.
+import * as runtime from '../runtime.js';
+import { pathEscape } from '../internal.js';
+/** Operations for the "users" API area. */
+export class UsersManager {
+    session;
+    constructor(session) {
+        this.session = session;
+    }
+    /** Iterate every `models.schemas.UserFull` across pages, threading the marker cursor. */
+    async *list(opts) {
+        const options = { ...opts };
+        for (;;) {
+            const page = await this.listPage(options);
+            const items = page.entries ?? [];
+            for (const item of items) {
+                yield item;
+            }
+            const cursor = page.next_marker;
+            if (cursor === undefined || cursor === null || cursor === '') {
+                return;
+            }
+            options.marker = cursor;
+        }
+    }
+    async listPage(opts) {
+        let url = this.session.baseUrl("api");
+        url += "/users";
+        let req = this.session.newRequest("GET", url);
+        const options = opts ?? {};
+        if (options.filter_term !== undefined) {
+            req = runtime.withQuery(req, "filter_term", options.filter_term);
+        }
+        if (options.user_type !== undefined) {
+            req = runtime.withQuery(req, "user_type", options.user_type);
+        }
+        if (options.external_app_user_id !== undefined) {
+            req = runtime.withQuery(req, "external_app_user_id", options.external_app_user_id);
+        }
+        if (options.fields !== undefined) {
+            req = runtime.withQuery(req, "fields", options.fields.join(','));
+        }
+        if (options.offset !== undefined) {
+            req = runtime.withQuery(req, "offset", String(options.offset));
+        }
+        if (options.limit !== undefined) {
+            req = runtime.withQuery(req, "limit", String(options.limit));
+        }
+        if (options.usemarker !== undefined) {
+            req = runtime.withQuery(req, "usemarker", String(options.usemarker));
+        }
+        if (options.marker !== undefined) {
+            req = runtime.withQuery(req, "marker", options.marker);
+        }
+        const resp = await this.session.fetch(req);
+        const data = runtime.responseBytes(resp);
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    async create(body, opts) {
+        let url = this.session.baseUrl("api");
+        url += "/users";
+        let req = this.session.newRequest("POST", url);
+        const options = opts ?? {};
+        if (options.fields !== undefined) {
+            req = runtime.withQuery(req, "fields", options.fields.join(','));
+        }
+        const payload = new TextEncoder().encode(JSON.stringify(body));
+        req = runtime.withJsonBody(req, payload);
+        const resp = await this.session.fetch(req);
+        const data = runtime.responseBytes(resp);
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    async getMe(opts) {
+        let url = this.session.baseUrl("api");
+        url += "/users";
+        url += "/me";
+        let req = this.session.newRequest("GET", url);
+        const options = opts ?? {};
+        if (options.fields !== undefined) {
+            req = runtime.withQuery(req, "fields", options.fields.join(','));
+        }
+        const resp = await this.session.fetch(req);
+        const data = runtime.responseBytes(resp);
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    async get(userId, opts) {
+        let url = this.session.baseUrl("api");
+        url += "/users";
+        url += '/' + pathEscape(userId);
+        let req = this.session.newRequest("GET", url);
+        const options = opts ?? {};
+        if (options.fields !== undefined) {
+            req = runtime.withQuery(req, "fields", options.fields.join(','));
+        }
+        const resp = await this.session.fetch(req);
+        const data = runtime.responseBytes(resp);
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    async update(userId, body, opts) {
+        let url = this.session.baseUrl("api");
+        url += "/users";
+        url += '/' + pathEscape(userId);
+        let req = this.session.newRequest("PUT", url);
+        const options = opts ?? {};
+        if (options.fields !== undefined) {
+            req = runtime.withQuery(req, "fields", options.fields.join(','));
+        }
+        const payload = new TextEncoder().encode(JSON.stringify(body));
+        req = runtime.withJsonBody(req, payload);
+        const resp = await this.session.fetch(req);
+        const data = runtime.responseBytes(resp);
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    async delete_(userId, opts) {
+        let url = this.session.baseUrl("api");
+        url += "/users";
+        url += '/' + pathEscape(userId);
+        let req = this.session.newRequest("DELETE", url);
+        const options = opts ?? {};
+        if (options.notify !== undefined) {
+            req = runtime.withQuery(req, "notify", String(options.notify));
+        }
+        if (options.force !== undefined) {
+            req = runtime.withQuery(req, "force", String(options.force));
+        }
+        await this.session.fetch(req);
+    }
+}

package/dist/esm/managers/web_links.js

@@ -0,0 +1,51 @@
+// Code generated by box-gantry. DO NOT EDIT.
+import * as runtime from '../runtime.js';
+import { pathEscape } from '../internal.js';
+/** Operations for the "web_links" API area. */
+export class WebLinksManager {
+    session;
+    constructor(session) {
+        this.session = session;
+    }
+    async create(body) {
+        let url = this.session.baseUrl("api");
+        url += "/web_links";
+        let req = this.session.newRequest("POST", url);
+        const payload = new TextEncoder().encode(JSON.stringify(body));
+        req = runtime.withJsonBody(req, payload);
+        const resp = await this.session.fetch(req);
+        const data = runtime.responseBytes(resp);
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    async get(webLinkId, opts) {
+        let url = this.session.baseUrl("api");
+        url += "/web_links";
+        url += '/' + pathEscape(webLinkId);
+        let req = this.session.newRequest("GET", url);
+        const options = opts ?? {};
+        if (options.boxapi !== undefined) {
+            req = runtime.withHeader(req, "boxapi", options.boxapi);
+        }
+        const resp = await this.session.fetch(req);
+        const data = runtime.responseBytes(resp);
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    async update(webLinkId, body) {
+        let url = this.session.baseUrl("api");
+        url += "/web_links";
+        url += '/' + pathEscape(webLinkId);
+        let req = this.session.newRequest("PUT", url);
+        const payload = new TextEncoder().encode(JSON.stringify(body));
+        req = runtime.withJsonBody(req, payload);
+        const resp = await this.session.fetch(req);
+        const data = runtime.responseBytes(resp);
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    async delete_(webLinkId) {
+        let url = this.session.baseUrl("api");
+        url += "/web_links";
+        url += '/' + pathEscape(webLinkId);
+        let req = this.session.newRequest("DELETE", url);
+        await this.session.fetch(req);
+    }
+}

package/dist/esm/managers/webhooks.js

@@ -0,0 +1,78 @@
+// Code generated by box-gantry. DO NOT EDIT.
+import * as runtime from '../runtime.js';
+import { pathEscape } from '../internal.js';
+/** Operations for the "webhooks" API area. */
+export class WebhooksManager {
+    session;
+    constructor(session) {
+        this.session = session;
+    }
+    /** Iterate every `models.schemas.WebhookMini` across pages, threading the marker cursor. */
+    async *list(opts) {
+        const options = { ...opts };
+        for (;;) {
+            const page = await this.listPage(options);
+            const items = page.entries ?? [];
+            for (const item of items) {
+                yield item;
+            }
+            const cursor = page.next_marker;
+            if (cursor === undefined || cursor === null || cursor === '') {
+                return;
+            }
+            options.marker = cursor;
+        }
+    }
+    async listPage(opts) {
+        let url = this.session.baseUrl("api");
+        url += "/webhooks";
+        let req = this.session.newRequest("GET", url);
+        const options = opts ?? {};
+        if (options.marker !== undefined) {
+            req = runtime.withQuery(req, "marker", options.marker);
+        }
+        if (options.limit !== undefined) {
+            req = runtime.withQuery(req, "limit", String(options.limit));
+        }
+        const resp = await this.session.fetch(req);
+        const data = runtime.responseBytes(resp);
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    async create(body) {
+        let url = this.session.baseUrl("api");
+        url += "/webhooks";
+        let req = this.session.newRequest("POST", url);
+        const payload = new TextEncoder().encode(JSON.stringify(body));
+        req = runtime.withJsonBody(req, payload);
+        const resp = await this.session.fetch(req);
+        const data = runtime.responseBytes(resp);
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    async get(webhookId) {
+        let url = this.session.baseUrl("api");
+        url += "/webhooks";
+        url += '/' + pathEscape(webhookId);
+        let req = this.session.newRequest("GET", url);
+        const resp = await this.session.fetch(req);
+        const data = runtime.responseBytes(resp);
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    async update(webhookId, body) {
+        let url = this.session.baseUrl("api");
+        url += "/webhooks";
+        url += '/' + pathEscape(webhookId);
+        let req = this.session.newRequest("PUT", url);
+        const payload = new TextEncoder().encode(JSON.stringify(body));
+        req = runtime.withJsonBody(req, payload);
+        const resp = await this.session.fetch(req);
+        const data = runtime.responseBytes(resp);
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    async delete_(webhookId) {
+        let url = this.session.baseUrl("api");
+        url += "/webhooks";
+        url += '/' + pathEscape(webhookId);
+        let req = this.session.newRequest("DELETE", url);
+        await this.session.fetch(req);
+    }
+}

package/dist/esm/managers/workflows.js

@@ -0,0 +1,55 @@
+// Code generated by box-gantry. DO NOT EDIT.
+import * as runtime from '../runtime.js';
+import { pathEscape } from '../internal.js';
+/** Operations for the "workflows" API area. */
+export class WorkflowsManager {
+    session;
+    constructor(session) {
+        this.session = session;
+    }
+    /** Iterate every `models.schemas.Workflow` across pages, threading the marker cursor. */
+    async *list(folderId, opts) {
+        const options = { ...opts };
+        for (;;) {
+            const page = await this.listPage(folderId, options);
+            const items = page.entries ?? [];
+            for (const item of items) {
+                yield item;
+            }
+            const cursor = page.next_marker;
+            if (cursor === undefined || cursor === null || cursor === '') {
+                return;
+            }
+            options.marker = cursor;
+        }
+    }
+    async listPage(folderId, opts) {
+        let url = this.session.baseUrl("api");
+        url += "/workflows";
+        let req = this.session.newRequest("GET", url);
+        req = runtime.withQuery(req, "folder_id", folderId);
+        const options = opts ?? {};
+        if (options.trigger_type !== undefined) {
+            req = runtime.withQuery(req, "trigger_type", options.trigger_type);
+        }
+        if (options.limit !== undefined) {
+            req = runtime.withQuery(req, "limit", String(options.limit));
+        }
+        if (options.marker !== undefined) {
+            req = runtime.withQuery(req, "marker", options.marker);
+        }
+        const resp = await this.session.fetch(req);
+        const data = runtime.responseBytes(resp);
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    async start(workflowId, body) {
+        let url = this.session.baseUrl("api");
+        url += "/workflows";
+        url += '/' + pathEscape(workflowId);
+        url += "/start";
+        let req = this.session.newRequest("POST", url);
+        const payload = new TextEncoder().encode(JSON.stringify(body));
+        req = runtime.withJsonBody(req, payload);
+        await this.session.fetch(req);
+    }
+}

package/dist/esm/managers/zip_downloads.js

@@ -0,0 +1,39 @@
+// Code generated by box-gantry. DO NOT EDIT.
+import * as runtime from '../runtime.js';
+import { pathEscape } from '../internal.js';
+/** Operations for the "zip_downloads" API area. */
+export class ZipDownloadsManager {
+    session;
+    constructor(session) {
+        this.session = session;
+    }
+    async create(body) {
+        let url = this.session.baseUrl("api");
+        url += "/zip_downloads";
+        let req = this.session.newRequest("POST", url);
+        const payload = new TextEncoder().encode(JSON.stringify(body));
+        req = runtime.withJsonBody(req, payload);
+        const resp = await this.session.fetch(req);
+        const data = runtime.responseBytes(resp);
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    async getContent(zipDownloadId) {
+        let url = this.session.baseUrl("download");
+        url += "/zip_downloads";
+        url += '/' + pathEscape(zipDownloadId);
+        url += "/content";
+        let req = this.session.newRequest("GET", url);
+        const resp = await this.session.fetch(req);
+        return runtime.responseStream(resp);
+    }
+    async getStatus(zipDownloadId) {
+        let url = this.session.baseUrl("api");
+        url += "/zip_downloads";
+        url += '/' + pathEscape(zipDownloadId);
+        url += "/status";
+        let req = this.session.newRequest("GET", url);
+        const resp = await this.session.fetch(req);
+        const data = runtime.responseBytes(resp);
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+}

package/dist/esm/models/index.js

@@ -0,0 +1,2 @@
+// Code generated by box-gantry. DO NOT EDIT.
+export * as schemas from './schemas.js';

package/dist/esm/models/schemas.js

@@ -0,0 +1,2 @@
+// Code generated by box-gantry 0.1.0 (spec ee7d55aedefe2fa0) for Box API 2024.0. DO NOT EDIT.
+export {};

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/runtime.js

@@ -0,0 +1,272 @@
+// Code generated by box-gantry (vendored from runtimes/typescript/gantryruntime/src/runtime.ts). DO NOT EDIT.
+import { BoxApiError } from './errors.js';
+export { BoxApiError } from './errors.js';
+export * from './auth.js';
+/** The default base URLs for the D-106 URL classes. */
+const DEFAULT_BASE_URLS = {
+    api: 'https://api.box.com/2.0',
+    api_root: 'https://api.box.com',
+    upload: 'https://upload.box.com/api/2.0',
+    upload_session: 'https://upload.box.com/api/2.0',
+    oauth_authorize: 'https://account.box.com/api/oauth2',
+    download: 'https://api.box.com/2.0',
+};
+/** The runtime-owned HTTP request envelope, assembled by the `with*` builders
+ * before `fetch` executes it. */
+export class Request {
+    method;
+    url;
+    headers = new Headers();
+    query = new URLSearchParams();
+    /** The buffered request body, if any (buffered so retries can replay it). */
+    body;
+    constructor(method, url) {
+        this.method = method;
+        this.url = url;
+    }
+}
+/** The runtime-owned HTTP response envelope. The body is read fully so it can be
+ * replayed as bytes or a stream, and so retries stay safe. */
+export class Response {
+    status;
+    headers;
+    bodyBytes;
+    constructor(status, headers, bodyBytes) {
+        this.status = status;
+        this.headers = headers;
+        this.bodyBytes = bodyBytes;
+    }
+}
+/** A response/request body as bytes. The platform buffers it (the manifest's
+ * `Streaming` axis allows buffering) so a retried request can replay it. */
+export class Stream {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    /** An empty stream (e.g. an absent multipart file part). */
+    static empty() {
+        return new Stream(new Uint8Array(0));
+    }
+}
+/** The runtime session: it holds the auth flow, base-URL configuration, and
+ * retry policy shared by every manager. */
+export class Client {
+    auth;
+    baseUrls;
+    maxRetries;
+    constructor(auth, options = {}) {
+        this.auth = auth;
+        const maxRetries = options.maxRetries ?? 5;
+        if (!Number.isInteger(maxRetries) || maxRetries < 0) {
+            throw new RangeError('maxRetries must be a non-negative integer');
+        }
+        this.maxRetries = maxRetries;
+        this.baseUrls = { ...DEFAULT_BASE_URLS, ...(options.baseUrls ?? {}) };
+    }
+    /** The configured base URL for a D-106 class, without a trailing slash. */
+    baseUrl(name) {
+        return this.baseUrls[name] ?? '';
+    }
+    /** A valid access token for the configured auth flow. The `signal` is
+     * accepted for contract symmetry; token acquisition is a shared refresh not
+     * bound to a single request's cancellation (mirroring the Rust runtime). */
+    async accessToken(_signal) {
+        return this.auth.accessToken();
+    }
+    /** A request envelope for a method and fully built URL. */
+    newRequest(method, url) {
+        return new Request(method, url);
+    }
+    /** Execute the request with retries: exponential backoff + full jitter, a
+     * single force-refresh on 401, and Retry-After (as a floor) on 429/5xx.
+     *
+     * Retry policy follows idempotency: a 429 (rate-limited, never processed)
+     * retries for every method; a transport error or a 5xx may have already
+     * committed a write, so those retry only for idempotent methods
+     * (GET/HEAD/PUT/DELETE/…). The 401 refresh applies to every method. */
+    async fetch(request, signal) {
+        let token = await this.auth.accessToken();
+        const query = request.query.toString();
+        const url = query ? `${request.url}?${query}` : request.url;
+        const idempotent = isIdempotent(request.method);
+        let refreshed = false;
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            const headers = new Headers(request.headers);
+            headers.set('Authorization', `Bearer ${token}`);
+            // `httpResponse` is the platform `Response` (via inference — the name is
+            // shadowed by this module's `Response` class, so it is never annotated).
+            let httpResponse;
+            try {
+                httpResponse = await fetch(url, {
+                    method: request.method,
+                    headers,
+                    // A `Uint8Array` is a valid `BodyInit` at runtime; the cast bridges
+                    // the `Uint8Array<ArrayBufferLike>` vs `BufferSource` generic gap in
+                    // the DOM lib without narrowing the contract's plain-`Uint8Array` body.
+                    body: request.body,
+                    signal,
+                });
+            }
+            catch (err) {
+                // A transport error gives no response, so a non-idempotent write may
+                // already have committed — only retry idempotent methods.
+                lastError = err;
+                if (attempt === this.maxRetries || !idempotent) {
+                    break;
+                }
+                await sleep(backoff(attempt), signal);
+                continue;
+            }
+            const bodyBytes = new Uint8Array(await httpResponse.arrayBuffer());
+            const response = new Response(httpResponse.status, httpResponse.headers, bodyBytes);
+            // A single force-refresh on 401: re-acquire past the token cache so the
+            // retry doesn't just resend the same rejected token.
+            if (response.status === 401 && !refreshed) {
+                refreshed = true;
+                token = await this.auth.forceRefresh(token);
+                continue;
+            }
+            if (shouldRetry(response.status, idempotent) && attempt < this.maxRetries) {
+                await sleep(retryDelay(response, attempt), signal);
+                continue;
+            }
+            return response;
+        }
+        throw new BoxApiError(`request failed after ${this.maxRetries + 1} attempts`, {
+            cause: lastError,
+        });
+    }
+}
+/** The safety ceiling on any single retry sleep, so a hostile server-sent
+ * Retry-After can't stall the client indefinitely. */
+const MAX_RETRY_DELAY_MS = 30_000;
+/** HTTP's idempotent methods: safe to replay after a transport error or 5xx. */
+const IDEMPOTENT_METHODS = new Set(['GET', 'HEAD', 'PUT', 'DELETE', 'OPTIONS', 'TRACE']);
+function isIdempotent(method) {
+    return IDEMPOTENT_METHODS.has(method.toUpperCase());
+}
+/** Whether a response status warrants a retry for a request of this idempotency.
+ * A 429 (rate-limited, never processed) retries for any method; a 5xx may have
+ * committed a write, so it retries only for idempotent methods. */
+function shouldRetry(status, idempotent) {
+    return status === 429 || (status >= 500 && idempotent);
+}
+/** Full-jitter exponential backoff, capped at the max retry delay. */
+function backoff(attempt) {
+    const base = Math.min(2 ** attempt * 500, MAX_RETRY_DELAY_MS);
+    return Math.random() * base;
+}
+/** The delay before the next retry: exponential backoff, raised to a
+ * (delay-seconds) Retry-After as a floor when present, and clamped to
+ * `MAX_RETRY_DELAY_MS`. HTTP-date Retry-After values fall back to backoff (the
+ * same posture as the Rust runtime). */
+function retryDelay(response, attempt) {
+    let delay = backoff(attempt);
+    const header = response.headers.get('Retry-After');
+    if (header && /^\d+$/.test(header.trim())) {
+        delay = Math.max(delay, Number(header.trim()) * 1000);
+    }
+    return Math.min(delay, MAX_RETRY_DELAY_MS);
+}
+/** Sleep for `ms`, rejecting promptly if the signal aborts. */
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(abortError(signal));
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(abortError(signal));
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+function abortError(signal) {
+    const reason = signal?.reason;
+    return reason instanceof Error
+        ? new BoxApiError(`request aborted: ${reason.message}`)
+        : new BoxApiError('request aborted');
+}
+/** Return the request with the header set. */
+export function withHeader(request, name, value) {
+    request.headers.set(name, value);
+    return request;
+}
+/** Return the request with the query parameter appended, encoded. */
+export function withQuery(request, name, value) {
+    request.query.append(name, value);
+    return request;
+}
+/** Return the request with the serialized JSON body and content type set. */
+export function withJsonBody(request, body) {
+    request.headers.set('Content-Type', 'application/json');
+    request.body = body;
+    return request;
+}
+/** Return the request with an application/x-www-form-urlencoded body (the
+ * OAuth2 token endpoints). */
+export function withFormBody(request, form) {
+    request.headers.set('Content-Type', 'application/x-www-form-urlencoded');
+    request.body = form;
+    return request;
+}
+/** Return the request with a streaming body (buffered, so retries can replay
+ * it — the manifest's `Streaming` axis permits buffering). */
+export function withStreamBody(request, body, contentType) {
+    request.headers.set('Content-Type', contentType);
+    request.body = body.data;
+    return request;
+}
+/** Return the request with a Box-style multipart body: an `attributes` JSON
+ * part plus a file part (G-7). */
+export function withMultipartBody(request, attributes, fileName, file) {
+    const boundary = `----gantryFormBoundary${Math.random().toString(36).slice(2)}`;
+    const encoder = new TextEncoder();
+    const escaped = fileName.replace(/["\r\n]/g, '_');
+    const parts = [
+        encoder.encode(`--${boundary}\r\nContent-Disposition: form-data; name="attributes"\r\n\r\n`),
+        attributes,
+        encoder.encode(`\r\n--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${escaped}"\r\n` +
+            'Content-Type: application/octet-stream\r\n\r\n'),
+        file.data,
+        encoder.encode(`\r\n--${boundary}--\r\n`),
+    ];
+    request.headers.set('Content-Type', `multipart/form-data; boundary=${boundary}`);
+    request.body = concat(parts);
+    return request;
+}
+/** Concatenate byte chunks into one buffer. */
+function concat(chunks) {
+    const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return out;
+}
+/** Read the whole response body. */
+export function responseBytes(response) {
+    return response.bodyBytes;
+}
+/** The response body as a stream, for binary downloads (FR-7.4). */
+export function responseStream(response) {
+    return new Stream(response.bodyBytes);
+}
+/** A response header value, empty when absent (redirect Location, Retry-After
+ * surfacing). */
+export function responseHeader(response, name) {
+    return response.headers.get(name) ?? '';
+}
+/** The response status code. */
+export function statusCode(response) {
+    return response.status;
+}