@techfinityedge/koolbase-react-native 5.1.0 → 5.2.0

package/dist/storage-errors.d.ts

@@ -10,7 +10,7 @@ export declare class KoolbaseStorageError extends Error {
 /**
  * Thrown when an upload is rejected because an object already exists at
  * the requested path — the server responds with 409 Conflict and code
- * `PATH_CONFLICT`. Catch it to give the user an "overwrite this file?"
+ * `path_conflict`. Catch it to give the user an "overwrite this file?"
  * prompt, then retry the upload with `overwrite: true`.
  *
  * `path` is the colliding path the server rejected, surfaced from the
@@ -67,7 +67,7 @@ export declare class KoolbaseStoragePermissionError extends KoolbaseStorageError
 /**
  * Thrown when an upload would push the bucket past its configured
  * `max_size_bytes` quota — the server responds with 409 Conflict and code
- * `QUOTA_EXCEEDED`. The server cleans up the underlying R2 object before
+ * `quota_exceeded`. The server cleans up the underlying R2 object before
  * returning; nothing leaks. Catch this to surface a "bucket is full"
  * message or prompt the caller to delete older files. The per-bucket
  * quota is set at bucket creation time and is currently immutable.
@@ -82,7 +82,7 @@ export declare class KoolbaseStorageQuotaError extends KoolbaseStorageError {
 /**
  * Thrown when a single file exceeds the bucket's configured
  * `max_file_size_bytes` — the server responds with 413 Payload Too Large
- * and code `FILE_TOO_LARGE`. The server cleans up the underlying R2
+ * and code `file_too_large`. The server cleans up the underlying R2
  * object before returning. The configured per-file limit lives on the
  * bucket record; check `Bucket.maxFileSizeBytes` to surface a clear
  * "files must be under X MB" message at the call site.
@@ -93,7 +93,7 @@ export declare class KoolbaseStorageFileTooLargeError extends KoolbaseStorageErr
 /**
  * Thrown when an upload's content-type isn't in the bucket's configured
  * `allowed_mime_types` allowlist — the server responds with 415
- * Unsupported Media Type and code `MIME_NOT_ALLOWED`. The check runs at
+ * Unsupported Media Type and code `mime_not_allowed`. The check runs at
  * presign time, so no bytes are transferred before rejection.
  *
  * Allowlists support `type/*` wildcards (e.g. `image/*` matches every
@@ -103,14 +103,54 @@ export declare class KoolbaseStorageFileTooLargeError extends KoolbaseStorageErr
 export declare class KoolbaseStorageMimeTypeError extends KoolbaseStorageError {
     constructor(message?: string);
 }
+/**
+ * Thrown when an object metadata payload (either at upload-confirm time
+ * or via `updateMetadata`) fails server-side validation — the server
+ * responds with 400 and code `metadata_invalid`.
+ *
+ * The `detail` field carries the specific reason from the server — e.g.
+ * `'key "foo bar": must match [a-z0-9_]+'`, `'exceeds 50 keys (got 53)'`,
+ * or `'exceeds 8192 bytes total (sum of all key + value lengths)'`. The
+ * detail names the failing key and rule so callers can fix the offending
+ * entry without guessing what shape rule was violated.
+ *
+ * Validation rules (enforced server-side):
+ * - At most 50 keys per object.
+ * - At most 8KB total (sum of byte lengths across all keys + values).
+ * - Keys: 1–64 chars, must match `[a-z0-9_]+`.
+ * - Keys with a leading underscore are reserved for system use.
+ * - Values: at most 1024 chars each.
+ *
+ * @example
+ * try {
+ *   await Koolbase.storage.updateMetadata('photos', 'sunset.jpg', {
+ *     tag: 'sunset',
+ *     'BAD KEY': 'oops',
+ *   });
+ * } catch (e) {
+ *   if (e instanceof KoolbaseStorageMetadataInvalidError) {
+ *     console.warn('Metadata rejected:', e.detail);
+ *     // -> 'Metadata rejected: key "BAD KEY": must match [a-z0-9_]+'
+ *   }
+ * }
+ */
+export declare class KoolbaseStorageMetadataInvalidError extends KoolbaseStorageError {
+    /**
+     * The specific validation failure reported by the server. Names the
+     * failing key (when applicable) and the rule that was violated.
+     * Surface this directly to developer logs or user-facing UI.
+     */
+    detail?: string;
+    constructor(message?: string, detail?: string);
+}
 /**
  * Maps a non-2xx storage-layer response to a typed
  * {@link KoolbaseStorageError}, preferring the server's stable `code` and
  * falling back to the HTTP status for older or uncoded responses. Always
  * returns an error to throw.
  *
- * Status-fallback note: HTTP 409 covers both PATH_CONFLICT and
- * QUOTA_EXCEEDED. Without a `code` field, the mapper defaults 409 to
+ * Status-fallback note: HTTP 409 covers both path_conflict and
+ * quota_exceeded. Without a `code` field, the mapper defaults 409 to
  * {@link KoolbaseStorageConflictError} since path collisions are the more
  * common case. Modern Koolbase servers always emit `code`, so this only
  * matters for very old API responses or non-Koolbase 409s.

package/dist/storage-errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KoolbaseStorageMimeTypeError = exports.KoolbaseStorageFileTooLargeError = exports.KoolbaseStorageQuotaError = exports.KoolbaseStoragePermissionError = exports.KoolbaseStorageValidationError = exports.KoolbaseStorageNotFoundError = exports.KoolbaseStorageConflictError = exports.KoolbaseStorageError = void 0;
+exports.KoolbaseStorageMetadataInvalidError = exports.KoolbaseStorageMimeTypeError = exports.KoolbaseStorageFileTooLargeError = exports.KoolbaseStorageQuotaError = exports.KoolbaseStoragePermissionError = exports.KoolbaseStorageValidationError = exports.KoolbaseStorageNotFoundError = exports.KoolbaseStorageConflictError = exports.KoolbaseStorageError = void 0;
 exports.koolbaseStorageError = koolbaseStorageError;
 exports.koolbaseStorageErrorFromResponse = koolbaseStorageErrorFromResponse;
 /**
@@ -20,7 +20,7 @@ exports.KoolbaseStorageError = KoolbaseStorageError;
 /**
  * Thrown when an upload is rejected because an object already exists at
  * the requested path — the server responds with 409 Conflict and code
- * `PATH_CONFLICT`. Catch it to give the user an "overwrite this file?"
+ * `path_conflict`. Catch it to give the user an "overwrite this file?"
  * prompt, then retry the upload with `overwrite: true`.
  *
  * `path` is the colliding path the server rejected, surfaced from the
@@ -49,7 +49,7 @@ exports.KoolbaseStorageError = KoolbaseStorageError;
  */
 class KoolbaseStorageConflictError extends KoolbaseStorageError {
     constructor(message, path) {
-        super(message ?? 'An object already exists at this path', 'PATH_CONFLICT');
+        super(message ?? 'An object already exists at this path', 'path_conflict');
         this.path = path;
         this.name = 'KoolbaseStorageConflictError';
         Object.setPrototypeOf(this, KoolbaseStorageConflictError.prototype);
@@ -97,7 +97,7 @@ exports.KoolbaseStoragePermissionError = KoolbaseStoragePermissionError;
 /**
  * Thrown when an upload would push the bucket past its configured
  * `max_size_bytes` quota — the server responds with 409 Conflict and code
- * `QUOTA_EXCEEDED`. The server cleans up the underlying R2 object before
+ * `quota_exceeded`. The server cleans up the underlying R2 object before
  * returning; nothing leaks. Catch this to surface a "bucket is full"
  * message or prompt the caller to delete older files. The per-bucket
  * quota is set at bucket creation time and is currently immutable.
@@ -108,7 +108,7 @@ exports.KoolbaseStoragePermissionError = KoolbaseStoragePermissionError;
  */
 class KoolbaseStorageQuotaError extends KoolbaseStorageError {
     constructor(message) {
-        super(message ?? 'Bucket quota exceeded', 'QUOTA_EXCEEDED');
+        super(message ?? 'Bucket quota exceeded', 'quota_exceeded');
         this.name = 'KoolbaseStorageQuotaError';
         Object.setPrototypeOf(this, KoolbaseStorageQuotaError.prototype);
     }
@@ -117,14 +117,14 @@ exports.KoolbaseStorageQuotaError = KoolbaseStorageQuotaError;
 /**
  * Thrown when a single file exceeds the bucket's configured
  * `max_file_size_bytes` — the server responds with 413 Payload Too Large
- * and code `FILE_TOO_LARGE`. The server cleans up the underlying R2
+ * and code `file_too_large`. The server cleans up the underlying R2
  * object before returning. The configured per-file limit lives on the
  * bucket record; check `Bucket.maxFileSizeBytes` to surface a clear
  * "files must be under X MB" message at the call site.
  */
 class KoolbaseStorageFileTooLargeError extends KoolbaseStorageError {
     constructor(message) {
-        super(message ?? 'File exceeds the bucket maximum file size', 'FILE_TOO_LARGE');
+        super(message ?? 'File exceeds the bucket maximum file size', 'file_too_large');
         this.name = 'KoolbaseStorageFileTooLargeError';
         Object.setPrototypeOf(this, KoolbaseStorageFileTooLargeError.prototype);
     }
@@ -133,7 +133,7 @@ exports.KoolbaseStorageFileTooLargeError = KoolbaseStorageFileTooLargeError;
 /**
  * Thrown when an upload's content-type isn't in the bucket's configured
  * `allowed_mime_types` allowlist — the server responds with 415
- * Unsupported Media Type and code `MIME_NOT_ALLOWED`. The check runs at
+ * Unsupported Media Type and code `mime_not_allowed`. The check runs at
  * presign time, so no bytes are transferred before rejection.
  *
  * Allowlists support `type/*` wildcards (e.g. `image/*` matches every
@@ -142,20 +142,60 @@ exports.KoolbaseStorageFileTooLargeError = KoolbaseStorageFileTooLargeError;
  */
 class KoolbaseStorageMimeTypeError extends KoolbaseStorageError {
     constructor(message) {
-        super(message ?? 'Content-type not allowed for this bucket', 'MIME_NOT_ALLOWED');
+        super(message ?? 'Content-type not allowed for this bucket', 'mime_not_allowed');
         this.name = 'KoolbaseStorageMimeTypeError';
         Object.setPrototypeOf(this, KoolbaseStorageMimeTypeError.prototype);
     }
 }
 exports.KoolbaseStorageMimeTypeError = KoolbaseStorageMimeTypeError;
+/**
+ * Thrown when an object metadata payload (either at upload-confirm time
+ * or via `updateMetadata`) fails server-side validation — the server
+ * responds with 400 and code `metadata_invalid`.
+ *
+ * The `detail` field carries the specific reason from the server — e.g.
+ * `'key "foo bar": must match [a-z0-9_]+'`, `'exceeds 50 keys (got 53)'`,
+ * or `'exceeds 8192 bytes total (sum of all key + value lengths)'`. The
+ * detail names the failing key and rule so callers can fix the offending
+ * entry without guessing what shape rule was violated.
+ *
+ * Validation rules (enforced server-side):
+ * - At most 50 keys per object.
+ * - At most 8KB total (sum of byte lengths across all keys + values).
+ * - Keys: 1–64 chars, must match `[a-z0-9_]+`.
+ * - Keys with a leading underscore are reserved for system use.
+ * - Values: at most 1024 chars each.
+ *
+ * @example
+ * try {
+ *   await Koolbase.storage.updateMetadata('photos', 'sunset.jpg', {
+ *     tag: 'sunset',
+ *     'BAD KEY': 'oops',
+ *   });
+ * } catch (e) {
+ *   if (e instanceof KoolbaseStorageMetadataInvalidError) {
+ *     console.warn('Metadata rejected:', e.detail);
+ *     // -> 'Metadata rejected: key "BAD KEY": must match [a-z0-9_]+'
+ *   }
+ * }
+ */
+class KoolbaseStorageMetadataInvalidError extends KoolbaseStorageError {
+    constructor(message, detail) {
+        super(message ?? 'Metadata payload is invalid', 'metadata_invalid');
+        this.detail = detail;
+        this.name = 'KoolbaseStorageMetadataInvalidError';
+        Object.setPrototypeOf(this, KoolbaseStorageMetadataInvalidError.prototype);
+    }
+}
+exports.KoolbaseStorageMetadataInvalidError = KoolbaseStorageMetadataInvalidError;
 /**
  * Maps a non-2xx storage-layer response to a typed
  * {@link KoolbaseStorageError}, preferring the server's stable `code` and
  * falling back to the HTTP status for older or uncoded responses. Always
  * returns an error to throw.
  *
- * Status-fallback note: HTTP 409 covers both PATH_CONFLICT and
- * QUOTA_EXCEEDED. Without a `code` field, the mapper defaults 409 to
+ * Status-fallback note: HTTP 409 covers both path_conflict and
+ * quota_exceeded. Without a `code` field, the mapper defaults 409 to
  * {@link KoolbaseStorageConflictError} since path collisions are the more
  * common case. Modern Koolbase servers always emit `code`, so this only
  * matters for very old API responses or non-Koolbase 409s.
@@ -165,14 +205,16 @@ function koolbaseStorageError(status, body, fallbackMessage = 'Storage request f
     const message = body?.error ?? fallbackMessage;
     // ─── code-first ───
     switch (code) {
-        case 'PATH_CONFLICT':
+        case 'path_conflict':
             return new KoolbaseStorageConflictError(message, body?.path);
-        case 'QUOTA_EXCEEDED':
+        case 'quota_exceeded':
             return new KoolbaseStorageQuotaError(message);
-        case 'FILE_TOO_LARGE':
+        case 'file_too_large':
             return new KoolbaseStorageFileTooLargeError(message);
-        case 'MIME_NOT_ALLOWED':
+        case 'mime_not_allowed':
             return new KoolbaseStorageMimeTypeError(message);
+        case 'metadata_invalid':
+            return new KoolbaseStorageMetadataInvalidError(message, body?.detail);
     }
     // ─── status fallback (pre-code servers or uncoded paths) ───
     switch (status) {

package/dist/storage.d.ts

@@ -1,4 +1,4 @@
-import { KoolbaseConfig, UploadOptions, UploadResult } from './types';
+import { KoolbaseConfig, UploadOptions, UploadResult, KoolbaseObject } from './types';
 /**
  * Koolbase storage client — uploads, downloads, and deletes via presigned
  * Cloudflare R2 URLs.
@@ -23,11 +23,52 @@ export declare class KoolbaseStorage {
      * Set `overwrite: true` for true upsert semantics — silently replace any
      * existing object at this path.
      *
+     * Pass `options.metadata` to attach arbitrary user-defined key/value pairs
+     * to the object at confirm time. Subject to the limits documented on
+     * {@link KoolbaseObject.metadata}; violations throw
+     * `KoolbaseStorageMetadataInvalidError`. On the `overwrite: true` path the
+     * metadata REPLACES any prior metadata at this path (matches GCS semantics).
+     * Use {@link updateMetadata} for post-upload merge changes.
+     *
      * **Breaking change in v5.0.0**: the default flipped from silent overwrite
      * (legacy behavior) to safe-by-default. If you previously relied on uploads
      * overwriting silently, pass `overwrite: true` explicitly.
      */
     upload(options: UploadOptions): Promise<UploadResult>;
+    /**
+     * Apply a partial metadata update to an existing object. Returns the
+     * post-update {@link KoolbaseObject} with the merged metadata.
+     *
+     * **Merge semantics** (mirrors the server's JSONB merge):
+     *
+     * - Keys with a non-null string value are SET — added if missing,
+     *   replacing any existing value at the key otherwise.
+     * - Keys with `null` are DELETED from the stored metadata.
+     * - Keys ABSENT from `metadata` are untouched — pre-existing entries
+     *   for those keys remain unchanged.
+     *
+     * Validation runs server-side against the same rules as upload-time
+     * metadata; violations throw `KoolbaseStorageMetadataInvalidError`,
+     * whose `detail` field names the failing key and rule. The check is
+     * performed against the projected post-merge state, so adding a key
+     * that would push the object past the 50-key or 8KB ceiling is
+     * rejected before the row is mutated.
+     *
+     * @example
+     * // Add a tag, update an existing key, and drop another in one call:
+     * const updated = await Koolbase.storage.updateMetadata(
+     *   'photos',
+     *   'sunset.jpg',
+     *   {
+     *     category: 'landscape',  // SET or UPDATE
+     *     tag:      'sunset',     // SET or UPDATE
+     *     owner:    null,         // DELETE
+     *   }
+     * );
+     * console.log(updated.metadata);
+     * // -> { category: 'landscape', tag: 'sunset' }
+     */
+    updateMetadata(bucket: string, path: string, metadata: Record<string, string | null>): Promise<KoolbaseObject>;
     /**
      * Get a signed download URL for a file.
      */

package/dist/storage.js

@@ -33,6 +33,13 @@ class KoolbaseStorage {
      * Set `overwrite: true` for true upsert semantics — silently replace any
      * existing object at this path.
      *
+     * Pass `options.metadata` to attach arbitrary user-defined key/value pairs
+     * to the object at confirm time. Subject to the limits documented on
+     * {@link KoolbaseObject.metadata}; violations throw
+     * `KoolbaseStorageMetadataInvalidError`. On the `overwrite: true` path the
+     * metadata REPLACES any prior metadata at this path (matches GCS semantics).
+     * Use {@link updateMetadata} for post-upload merge changes.
+     *
      * **Breaking change in v5.0.0**: the default flipped from silent overwrite
      * (legacy behavior) to safe-by-default. If you previously relied on uploads
      * overwriting silently, pass `overwrite: true` explicitly.
@@ -76,20 +83,28 @@ class KoolbaseStorage {
         }
         const etag = uploadRes.headers.get('etag') ?? '';
         // ─── 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
+        // that don't care, and lets the server's omitempty path treat absent
+        // as "no metadata."
+        const confirmBody = {
+            bucket: options.bucket,
+            path: options.path,
+            size: fileSize,
+            content_type: contentType,
+            etag,
+            overwrite,
+        };
+        if (options.metadata !== undefined) {
+            confirmBody.metadata = options.metadata;
+        }
         const confirmRes = await fetch(`${this.config.baseUrl}/v1/sdk/storage/confirm`, {
             method: 'POST',
             headers: {
                 ...(await this.buildHeaders()),
                 'Content-Type': 'application/json',
             },
-            body: JSON.stringify({
-                bucket: options.bucket,
-                path: options.path,
-                size: fileSize,
-                content_type: contentType,
-                etag,
-                overwrite,
-            }),
+            body: JSON.stringify(confirmBody),
         });
         if (!confirmRes.ok) {
             throw await (0, storage_errors_1.koolbaseStorageErrorFromResponse)(confirmRes, 'Failed to confirm upload');
@@ -100,6 +115,54 @@ class KoolbaseStorage {
         const downloadUrl = await this.getDownloadUrl(options.bucket, options.path);
         return { object, downloadUrl };
     }
+    /**
+     * Apply a partial metadata update to an existing object. Returns the
+     * post-update {@link KoolbaseObject} with the merged metadata.
+     *
+     * **Merge semantics** (mirrors the server's JSONB merge):
+     *
+     * - Keys with a non-null string value are SET — added if missing,
+     *   replacing any existing value at the key otherwise.
+     * - Keys with `null` are DELETED from the stored metadata.
+     * - Keys ABSENT from `metadata` are untouched — pre-existing entries
+     *   for those keys remain unchanged.
+     *
+     * Validation runs server-side against the same rules as upload-time
+     * metadata; violations throw `KoolbaseStorageMetadataInvalidError`,
+     * whose `detail` field names the failing key and rule. The check is
+     * performed against the projected post-merge state, so adding a key
+     * that would push the object past the 50-key or 8KB ceiling is
+     * rejected before the row is mutated.
+     *
+     * @example
+     * // Add a tag, update an existing key, and drop another in one call:
+     * const updated = await Koolbase.storage.updateMetadata(
+     *   'photos',
+     *   'sunset.jpg',
+     *   {
+     *     category: 'landscape',  // SET or UPDATE
+     *     tag:      'sunset',     // SET or UPDATE
+     *     owner:    null,         // DELETE
+     *   }
+     * );
+     * console.log(updated.metadata);
+     * // -> { category: 'landscape', tag: 'sunset' }
+     */
+    async updateMetadata(bucket, path, metadata) {
+        const res = await fetch(`${this.config.baseUrl}/v1/sdk/storage/objects/metadata`, {
+            method: 'PATCH',
+            headers: {
+                ...(await this.buildHeaders()),
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ bucket, path, metadata }),
+        });
+        if (!res.ok) {
+            throw await (0, storage_errors_1.koolbaseStorageErrorFromResponse)(res, 'Failed to update metadata');
+        }
+        const raw = await res.json();
+        return mapObjectFromServer(raw);
+    }
     /**
      * Get a signed download URL for a file.
      */
@@ -135,6 +198,9 @@ class KoolbaseStorage {
 exports.KoolbaseStorage = KoolbaseStorage;
 /**
  * Maps the snake_case server JSON to the camelCase {@link KoolbaseObject}.
+ * Defensive: missing or null `metadata` (older / non-Koolbase responses)
+ * is coerced to an empty object so callers always see a typed
+ * `Record<string, string>` rather than null.
  */
 function mapObjectFromServer(raw) {
     return {
@@ -145,6 +211,7 @@ function mapObjectFromServer(raw) {
         path: raw.path,
         size: raw.size ?? 0,
         contentType: raw.content_type ?? null,
+        metadata: raw.metadata ?? {},
         createdAt: raw.created_at,
         updatedAt: raw.updated_at,
     };

package/dist/types.d.ts

@@ -161,6 +161,20 @@ export interface UploadOptions {
      * `true` to silently replace the existing object.
      */
     overwrite?: boolean;
+    /**
+     * User-defined key/value metadata to attach to the object at confirm
+     * time. Optional — when omitted, the object stores empty metadata `{}`.
+     *
+     * Subject to server-side validation (≤50 keys, ≤8KB total, keys 1–64
+     * chars matching `[a-z0-9_]+`, values ≤1024 chars, leading underscore
+     * reserved); violations throw `KoolbaseStorageMetadataInvalidError`.
+     *
+     * On the `overwrite: true` path, metadata REPLACES any prior metadata
+     * at this path (matches GCS semantics — a new upload at a path
+     * produces a new object, not a patch of the old). Use `updateMetadata`
+     * for post-upload merge changes.
+     */
+    metadata?: Record<string, string>;
     onProgress?: (percent: number) => void;
 }
 /**
@@ -175,6 +189,14 @@ export interface KoolbaseObject {
     path: string;
     size: number;
     contentType: string | null;
+    /**
+     * User-defined key/value metadata attached to this object. Always
+     * non-null — empty object when no metadata has been set (the server
+     * returns `{}` rather than `null` so callers can treat it as a
+     * guaranteed object without null checks). Set on upload via
+     * `upload({ metadata })` or mutated post-upload via `updateMetadata`.
+     */
+    metadata: Record<string, string>;
     /** ISO 8601 timestamp from the server. */
     createdAt: string;
     /** ISO 8601 timestamp from the server. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techfinityedge/koolbase-react-native",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "description": "React Native SDK for Koolbase — auth, database, storage, realtime, feature flags, and functions in one package.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",