@koolbase/core 12.15.0 → 12.17.0

package/dist/esm/storage-transfer.d.ts

@@ -0,0 +1,88 @@
+import type { UploadResult } from './types.js';
+/** Where an upload is. */
+export type KoolbaseUploadState = 
+/** Not started: asking the server for an upload link. */
+'pending'
+/** Sending the file's bytes; see `bytesSent`. */
+ | 'uploading'
+/** The bytes have arrived; the server is checking them and putting the file in place. It can no longer be cancelled. */
+ | 'verifying'
+/** Done: the file is in the bucket. */
+ | 'completed'
+/** It failed; `error` says why. */
+ | 'failed'
+/** Cancelled before the server began checking it. Nothing was stored. */
+ | 'cancelled';
+/** One moment of an upload. */
+export interface KoolbaseUploadProgress {
+    state: KoolbaseUploadState;
+    /** Bytes sent so far. */
+    bytesSent: number;
+    bytesTotal: number;
+    /** 0 to 1: the share of bytes sent; 1 once verifying. */
+    fraction: number;
+    /** Whether the upload has ended, one way or another. */
+    isDone: boolean;
+    /** Why it failed, when `state` is `'failed'`. */
+    error?: Error;
+}
+/** A running upload: watch it with `onProgress`, `cancel` it, await `result`. */
+export declare class KoolbaseUploadTask {
+    private _current;
+    private listeners;
+    private cancelRequested;
+    private abortTransfer;
+    private total;
+    /**
+     * The uploaded file. Rejects with `KoolbaseUploadCancelledError` if it was
+     * cancelled, or the error that made it fail.
+     */
+    readonly result: Promise<UploadResult>;
+    private resolve;
+    private reject;
+    /** @internal */
+    constructor();
+    /** Where the upload is now. */
+    get current(): KoolbaseUploadProgress;
+    /**
+     * Calls `listener` on every change of state and every chunk sent, starting
+     * with where the upload is now. Returns a function that stops it.
+     */
+    onProgress(listener: (p: KoolbaseUploadProgress) => void): () => void;
+    /**
+     * Stops the upload, if the server has not begun checking it yet. Returns
+     * whether it was stopped: false once verifying (the file will land, or
+     * fail on its own) or done.
+     */
+    cancel(): boolean;
+    /** @internal */
+    get cancelled(): boolean;
+    /** @internal Throws if the upload was cancelled, between steps. */
+    checkCancelled(): void;
+    /** @internal */
+    setTotal(total: number): void;
+    /** @internal */
+    setAbort(abort: (() => void) | null): void;
+    /** @internal */
+    emit(state: KoolbaseUploadState, sent?: number, error?: Error): void;
+    /** @internal Marks the bytes sent: from here the upload cannot be cancelled. */
+    verifying(): void;
+    /** @internal */
+    finish(result: UploadResult): void;
+    /** @internal */
+    fail(error: unknown): void;
+}
+/** Runs `body` as the task's upload, starting on the next turn so a caller can listen to every event. */
+export declare function runUploadTask(body: (task: KoolbaseUploadTask) => Promise<UploadResult>): KoolbaseUploadTask;
+interface PutResult {
+    status: number;
+    etag: string;
+}
+/**
+ * Sends `body` to a presigned `url` with PUT, reporting bytes as they are
+ * sent. XMLHttpRequest where the host has it (browsers and React Native,
+ * both report upload progress); fetch elsewhere, where progress jumps from
+ * 0 to the total. A cancel aborts it.
+ */
+export declare function putWithProgress(task: KoolbaseUploadTask, url: string, body: Blob, contentType: string): Promise<PutResult>;
+export {};

package/dist/esm/storage-transfer.js

@@ -0,0 +1,208 @@
+// An upload's lifecycle, as an app watches it (S1).
+//
+// pending -> uploading (bytes sent of total) -> verifying -> completed, or
+// failed / cancelled. Verifying is its own phase: the bytes have arrived and
+// the server is checking them (size, type, the bucket's rules and cap) and
+// putting them in place. Only completed means the file can be referenced
+// from a record.
+import { KoolbaseNetworkError } from './network.js';
+import { KoolbaseStorageError, KoolbaseUploadCancelledError } from './storage-errors.js';
+function progressOf(state, bytesSent, bytesTotal, error) {
+    let fraction;
+    if (state === 'verifying' || state === 'completed')
+        fraction = 1;
+    else if (bytesTotal <= 0)
+        fraction = 0;
+    else
+        fraction = Math.min(1, Math.max(0, bytesSent / bytesTotal));
+    return {
+        state,
+        bytesSent,
+        bytesTotal,
+        fraction,
+        isDone: state === 'completed' || state === 'failed' || state === 'cancelled',
+        ...(error ? { error } : {}),
+    };
+}
+/** A running upload: watch it with `onProgress`, `cancel` it, await `result`. */
+export class KoolbaseUploadTask {
+    /** @internal */
+    constructor() {
+        this.listeners = new Set();
+        this.cancelRequested = false;
+        this.abortTransfer = null;
+        this.total = 0;
+        this._current = progressOf('pending', 0, 0);
+        this.result = new Promise((res, rej) => {
+            this.resolve = res;
+            this.reject = rej;
+        });
+        // An app that only listens to progress is not left with an unhandled
+        // rejection; awaiting `result` still sees the error.
+        this.result.catch(() => undefined);
+    }
+    /** Where the upload is now. */
+    get current() {
+        return this._current;
+    }
+    /**
+     * Calls `listener` on every change of state and every chunk sent, starting
+     * with where the upload is now. Returns a function that stops it.
+     */
+    onProgress(listener) {
+        this.listeners.add(listener);
+        listener(this._current);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /**
+     * Stops the upload, if the server has not begun checking it yet. Returns
+     * whether it was stopped: false once verifying (the file will land, or
+     * fail on its own) or done.
+     */
+    cancel() {
+        if (this._current.isDone || this._current.state === 'verifying')
+            return false;
+        this.cancelRequested = true;
+        this.abortTransfer?.();
+        return true;
+    }
+    /** @internal */
+    get cancelled() {
+        return this.cancelRequested;
+    }
+    /** @internal Throws if the upload was cancelled, between steps. */
+    checkCancelled() {
+        if (this.cancelRequested)
+            throw new KoolbaseUploadCancelledError();
+    }
+    /** @internal */
+    setTotal(total) {
+        this.total = total;
+    }
+    /** @internal */
+    setAbort(abort) {
+        this.abortTransfer = abort;
+    }
+    /** @internal */
+    emit(state, sent, error) {
+        if (this._current.isDone)
+            return;
+        this._current = progressOf(state, sent ?? this._current.bytesSent, this.total, error);
+        for (const l of [...this.listeners]) {
+            try {
+                l(this._current);
+            }
+            catch {
+                // A listener's own failure is not the upload's.
+            }
+        }
+    }
+    /** @internal Marks the bytes sent: from here the upload cannot be cancelled. */
+    verifying() {
+        this.checkCancelled();
+        this.emit('verifying', this.total);
+    }
+    /** @internal */
+    finish(result) {
+        this.emit('completed', this.total);
+        this.listeners.clear();
+        this.resolve(result);
+    }
+    /** @internal */
+    fail(error) {
+        if (this.cancelRequested) {
+            const e = new KoolbaseUploadCancelledError();
+            this.emit('cancelled');
+            this.reject(e);
+        }
+        else {
+            const e = error instanceof Error ? error : new KoolbaseStorageError(String(error));
+            this.emit('failed', undefined, e);
+            this.reject(e);
+        }
+        this.listeners.clear();
+    }
+}
+/** Runs `body` as the task's upload, starting on the next turn so a caller can listen to every event. */
+export function runUploadTask(body) {
+    const task = new KoolbaseUploadTask();
+    Promise.resolve().then(async () => {
+        try {
+            task.finish(await body(task));
+        }
+        catch (e) {
+            task.fail(e);
+        }
+    });
+    return task;
+}
+/**
+ * Sends `body` to a presigned `url` with PUT, reporting bytes as they are
+ * sent. XMLHttpRequest where the host has it (browsers and React Native,
+ * both report upload progress); fetch elsewhere, where progress jumps from
+ * 0 to the total. A cancel aborts it.
+ */
+export function putWithProgress(task, url, body, contentType) {
+    task.checkCancelled();
+    const total = body.size;
+    const report = (sent) => {
+        if (!task.cancelled)
+            task.emit('uploading', Math.min(sent, total));
+    };
+    report(0);
+    const XHR = globalThis.XMLHttpRequest;
+    if (XHR) {
+        return new Promise((resolve, reject) => {
+            const xhr = new XHR();
+            let settled = false;
+            const done = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                task.setAbort(null);
+                fn();
+            };
+            xhr.open('PUT', url);
+            xhr.setRequestHeader('Content-Type', contentType);
+            if (xhr.upload) {
+                xhr.upload.onprogress = (ev) => report(ev.loaded);
+            }
+            xhr.onload = () => done(() => {
+                if (task.cancelled)
+                    return reject(new KoolbaseUploadCancelledError());
+                resolve({ status: xhr.status, etag: xhr.getResponseHeader('etag') ?? '' });
+            });
+            xhr.onerror = () => done(() => reject(task.cancelled ? new KoolbaseUploadCancelledError() : new KoolbaseNetworkError(url, new Error('the upload did not complete'))));
+            xhr.onabort = () => done(() => reject(new KoolbaseUploadCancelledError()));
+            task.setAbort(() => {
+                xhr.abort();
+                // Some hosts do not fire onabort for an aborted send.
+                done(() => reject(new KoolbaseUploadCancelledError()));
+            });
+            xhr.send(body);
+        });
+    }
+    const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+    task.setAbort(() => controller?.abort());
+    return fetch(url, {
+        method: 'PUT',
+        headers: { 'Content-Type': contentType },
+        body,
+        signal: controller?.signal,
+    })
+        .then((res) => {
+        task.checkCancelled();
+        return { status: res.status, etag: res.headers.get('etag') ?? '' };
+    })
+        .catch((e) => {
+        if (task.cancelled || e?.name === 'AbortError') {
+            throw new KoolbaseUploadCancelledError();
+        }
+        if (e instanceof KoolbaseStorageError)
+            throw e;
+        throw new KoolbaseNetworkError(url, e);
+    })
+        .finally(() => task.setAbort(null));
+}

package/dist/esm/storage.d.ts

@@ -1,4 +1,6 @@
 import { KoolbaseConfig, UploadOptions, UploadResult, KoolbaseObject, KoolbaseObjectVersion, KoolbaseImageTransform } from './types.js';
+import { KoolbaseUploadTask } from './storage-transfer.js';
+import { KoolbaseFileInfo, KoolbaseFilePage, ListFilesOptions } from './storage-files.js';
 /**
  * Koolbase storage client — uploads, downloads, and deletes via presigned
  * Cloudflare R2 URLs.
@@ -53,6 +55,76 @@ export declare class KoolbaseStorage {
      * overwriting silently, pass `overwrite: true` explicitly.
      */
     upload(options: UploadOptions): Promise<UploadResult>;
+    /**
+     * Starts an upload you can follow and cancel: the same upload as
+     * {@link upload}, returned at once as a {@link KoolbaseUploadTask}.
+     *
+     * The task goes pending -> uploading (bytes sent of total) -> verifying
+     * -> completed, or failed / cancelled. `cancel()` stops it until the
+     * server begins checking the bytes (verifying); nothing is stored. Only
+     * completed means the file can be referenced from a record.
+     *
+     * @example
+     * const task = Koolbase.storage.startUpload({ bucket: 'posters', path: 'gig.png', file });
+     * const stop = task.onProgress((p) => setPercent(Math.round(p.fraction * 100)));
+     * cancelButton.onclick = () => task.cancel();
+     * const { object } = await task.result;
+     */
+    startUpload(options: UploadOptions): KoolbaseUploadTask;
+    private runUpload;
+    /**
+     * One page of a bucket's files. The bucket's view rule is applied to every
+     * file: the page holds only files the signed-in person may view. Pass the
+     * page's `nextCursor` back as `cursor` for the next one; a page can hold
+     * fewer files than `limit` and still have a next.
+     *
+     * @example
+     * let cursor: string | undefined;
+     * do {
+     *   const page = await Koolbase.storage.listFiles({ bucket: 'posters', prefix: 'events/', cursor });
+     *   show(page.files);
+     *   cursor = page.nextCursor ?? undefined;
+     * } while (cursor);
+     */
+    listFiles(options: ListFilesOptions): Promise<KoolbaseFilePage>;
+    /**
+     * One file's details -- size, type, metadata, who uploaded it, and its
+     * permanent link while its bucket is public. Throws
+     * `KoolbaseStorageNotFoundError` for a file that is not there or that
+     * the bucket's view rule hides from the caller.
+     */
+    getFileInfo(bucket: string, path: string): Promise<KoolbaseFileInfo>;
+    /**
+     * Move a file to `to`, in its bucket or into `toBucket` (S1b). Nothing is
+     * uploaded again. The bucket's rules decide: delete on the file, and
+     * upload at the destination, whose limits apply as to an upload. The
+     * destination must be free.
+     *
+     * Within one bucket the file keeps its kept versions. Refused with
+     * `KoolbaseStorageFileInUseError` while records point at the file: change
+     * them first, or {@link copy} it.
+     *
+     * @example
+     * await Koolbase.storage.move({ bucket: 'inbox', from: 'scan.png', toBucket: 'vault', to: '2026/scan.png' });
+     */
+    move(options: {
+        bucket: string;
+        from: string;
+        to: string;
+        toBucket?: string;
+    }): Promise<KoolbaseObject>;
+    /**
+     * Copy a file to `to`, in its bucket or into `toBucket` (S1b): a new file,
+     * the caller's, with the same bytes. The bucket's rules decide: view on
+     * the file, and upload at the destination.
+     */
+    copy(options: {
+        bucket: string;
+        from: string;
+        to: string;
+        toBucket?: string;
+    }): Promise<KoolbaseObject>;
+    private transfer;
     /**
      * Apply a partial metadata update to an existing object. Returns the
      * post-update {@link KoolbaseObject} with the merged metadata.

package/dist/esm/storage.js

@@ -2,6 +2,8 @@ import { KoolbaseStorageProjectIdentityError } from './storage-errors.js';
 import { sessionFetch } from './network.js';
 import { KoolbaseUnauthenticatedError } from './errors.js';
 import { KoolbaseStorageError, koolbaseStorageErrorFromResponse, } from './storage-errors.js';
+import { putWithProgress, runUploadTask } from './storage-transfer.js';
+import { fileInfoFromJson, filePageFromJson, listFilesQuery, } from './storage-files.js';
 // --- Cloudflare image-transform URL helpers -------------------------------
 // Module-private — callers use KoolbaseStorage.publicUrl / publicUrlForObject.
 function clampInt(v, min, max) {
@@ -88,6 +90,46 @@ export class KoolbaseStorage {
      * overwriting silently, pass `overwrite: true` explicitly.
      */
     async upload(options) {
+        const task = this.startUpload(options);
+        const signal = options.signal;
+        const onAbort = () => task.cancel();
+        if (signal) {
+            if (signal.aborted)
+                task.cancel();
+            else
+                signal.addEventListener('abort', onAbort);
+        }
+        const stop = options.onProgress
+            ? task.onProgress((p) => options.onProgress?.(Math.round(p.fraction * 100), p))
+            : null;
+        try {
+            return await task.result;
+        }
+        finally {
+            stop?.();
+            signal?.removeEventListener('abort', onAbort);
+        }
+    }
+    /**
+     * Starts an upload you can follow and cancel: the same upload as
+     * {@link upload}, returned at once as a {@link KoolbaseUploadTask}.
+     *
+     * The task goes pending -> uploading (bytes sent of total) -> verifying
+     * -> completed, or failed / cancelled. `cancel()` stops it until the
+     * server begins checking the bytes (verifying); nothing is stored. Only
+     * completed means the file can be referenced from a record.
+     *
+     * @example
+     * const task = Koolbase.storage.startUpload({ bucket: 'posters', path: 'gig.png', file });
+     * const stop = task.onProgress((p) => setPercent(Math.round(p.fraction * 100)));
+     * cancelButton.onclick = () => task.cancel();
+     * const { object } = await task.result;
+     */
+    startUpload(options) {
+        return runUploadTask((task) => this.runUpload(options, task));
+    }
+    async runUpload(options, task) {
+        task.checkCancelled();
         const overwrite = options.overwrite ?? false;
         // A Blob (browser File included) knows its own type; the React Native
         // URI form carries it alongside. Falling back to octet-stream keeps a
@@ -97,6 +139,8 @@ export class KoolbaseStorage {
         const contentType = isBlob
             ? options.file.type || 'application/octet-stream'
             : options.file.type;
+        if (isBlob)
+            task.setTotal(options.file.size);
         // ─── Step 1: Get presigned upload URL ───
         const urlRes = await sessionFetch(`${this.config.baseUrl}/v1/sdk/storage/upload-url`, {
             method: 'POST',
@@ -114,7 +158,8 @@ export class KoolbaseStorage {
         if (!urlRes.ok) {
             throw await this.error(urlRes, 'Failed to get upload URL');
         }
-        const { upload_url } = (await urlRes.json());
+        const { upload_url, upload_id } = (await urlRes.json());
+        task.checkCancelled();
         // ─── Step 2: Upload directly to R2 ───
         // R2 presigned URLs expect raw binary, NOT multipart/form-data.
         //
@@ -126,17 +171,17 @@ export class KoolbaseStorage {
             ? options.file
             : await (await sessionFetch(options.file.uri)).blob();
         const fileSize = fileBlob.size;
-        const uploadRes = await sessionFetch(upload_url, {
-            method: 'PUT',
-            headers: { 'Content-Type': contentType },
-            body: fileBlob,
-        });
-        if (!uploadRes.ok) {
+        task.setTotal(fileSize);
+        const uploadRes = await putWithProgress(task, upload_url, fileBlob, contentType);
+        if (uploadRes.status < 200 || uploadRes.status >= 300) {
             // R2 PUT errors don't follow the Koolbase error shape — surface as a
             // generic storage error rather than trying to decode a Koolbase body.
             throw new KoolbaseStorageError(`Upload to storage failed: ${uploadRes.status}`);
         }
-        const etag = uploadRes.headers.get('etag') ?? '';
+        const etag = uploadRes.etag;
+        // From here the server checks the bytes and puts them in place; the
+        // upload can no longer be cancelled.
+        task.verifying();
         // ─── Step 3: Confirm upload ───
         // Build the body conditionally so the `metadata` field is only sent
         // when the caller passed it — keeps the wire shape clean for callers
@@ -150,6 +195,10 @@ export class KoolbaseStorage {
             etag,
             overwrite,
         };
+        // The confirm names its upload, so it takes exactly these bytes.
+        if (upload_id) {
+            confirmBody.upload_id = upload_id;
+        }
         if (options.metadata !== undefined) {
             confirmBody.metadata = options.metadata;
         }
@@ -170,6 +219,78 @@ export class KoolbaseStorage {
         const downloadUrl = await this.getDownloadUrl(options.bucket, options.path);
         return { object, downloadUrl };
     }
+    /**
+     * One page of a bucket's files. The bucket's view rule is applied to every
+     * file: the page holds only files the signed-in person may view. Pass the
+     * page's `nextCursor` back as `cursor` for the next one; a page can hold
+     * fewer files than `limit` and still have a next.
+     *
+     * @example
+     * let cursor: string | undefined;
+     * do {
+     *   const page = await Koolbase.storage.listFiles({ bucket: 'posters', prefix: 'events/', cursor });
+     *   show(page.files);
+     *   cursor = page.nextCursor ?? undefined;
+     * } while (cursor);
+     */
+    async listFiles(options) {
+        const res = await sessionFetch(`${this.config.baseUrl}/v1/sdk/storage/files?${listFilesQuery(options)}`, { headers: await this.buildHeaders() });
+        if (!res.ok) {
+            throw await this.error(res, 'Failed to list files');
+        }
+        return filePageFromJson((await res.json()));
+    }
+    /**
+     * One file's details -- size, type, metadata, who uploaded it, and its
+     * permanent link while its bucket is public. Throws
+     * `KoolbaseStorageNotFoundError` for a file that is not there or that
+     * the bucket's view rule hides from the caller.
+     */
+    async getFileInfo(bucket, path) {
+        const res = await sessionFetch(`${this.config.baseUrl}/v1/sdk/storage/file?bucket=${encodeURIComponent(bucket)}&path=${encodeURIComponent(path)}`, { headers: await this.buildHeaders() });
+        if (!res.ok) {
+            throw await this.error(res, 'Failed to get the file');
+        }
+        return fileInfoFromJson((await res.json()));
+    }
+    /**
+     * Move a file to `to`, in its bucket or into `toBucket` (S1b). Nothing is
+     * uploaded again. The bucket's rules decide: delete on the file, and
+     * upload at the destination, whose limits apply as to an upload. The
+     * destination must be free.
+     *
+     * Within one bucket the file keeps its kept versions. Refused with
+     * `KoolbaseStorageFileInUseError` while records point at the file: change
+     * them first, or {@link copy} it.
+     *
+     * @example
+     * await Koolbase.storage.move({ bucket: 'inbox', from: 'scan.png', toBucket: 'vault', to: '2026/scan.png' });
+     */
+    async move(options) {
+        return this.transfer('move', options);
+    }
+    /**
+     * Copy a file to `to`, in its bucket or into `toBucket` (S1b): a new file,
+     * the caller's, with the same bytes. The bucket's rules decide: view on
+     * the file, and upload at the destination.
+     */
+    async copy(options) {
+        return this.transfer('copy', options);
+    }
+    async transfer(op, o) {
+        const body = { bucket: o.bucket, from: o.from, to: o.to };
+        if (o.toBucket && o.toBucket !== o.bucket)
+            body.to_bucket = o.toBucket;
+        const res = await sessionFetch(`${this.config.baseUrl}/v1/sdk/storage/${op}`, {
+            method: 'POST',
+            headers: { ...(await this.buildHeaders()), 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            throw await this.error(res, op === 'move' ? 'Failed to move the file' : 'Failed to copy the file');
+        }
+        return mapObjectFromServer(await res.json());
+    }
     /**
      * Apply a partial metadata update to an existing object. Returns the
      * post-update {@link KoolbaseObject} with the merged metadata.

package/dist/esm/types.d.ts

@@ -369,7 +369,18 @@ export interface UploadOptions {
      * for post-upload merge changes.
      */
     metadata?: Record<string, string>;
-    onProgress?: (percent: number) => void;
+    /**
+     * Called as the upload goes: `percent` is 0 to 100 of the bytes sent;
+     * `progress` says where the upload is (uploading, verifying, completed,
+     * ...). For a cancellable upload use `KoolbaseStorage.startUpload`.
+     */
+    onProgress?: (percent: number, progress: import('./storage-transfer.js').KoolbaseUploadProgress) => void;
+    /**
+     * Aborting this signal cancels the upload, if the server has not begun
+     * checking it yet; the upload then rejects with
+     * `KoolbaseUploadCancelledError`.
+     */
+    signal?: AbortSignal;
 }
 /**
  * A stored object's server-side metadata. Field names are camelCase here

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koolbase/core",
-  "version": "12.15.0",
+  "version": "12.17.0",
   "description": "Koolbase SDK core \u2014 shared behaviour behind @koolbase/react-native and @koolbase/js. Install one of those, not this.",
   "main": "./dist/cjs/index.js",
   "types": "./dist/esm/index.d.ts",