@techfinityedge/koolbase-react-native 2.1.0 → 2.3.0

package/README.md

@@ -162,6 +162,20 @@ await Koolbase.db.update('record-id', { title: 'Updated' });
 await Koolbase.db.delete('record-id');
 ```
 
+### Handling unique-constraint conflicts
+
+  A write that would violate a unique constraint throws `KoolbaseConflictError`:
+
+  \`\`\`ts
+  try {
+    await koolbase.db.upsert('users', { email }, { name });
+  } catch (e) {
+    if (e instanceof KoolbaseConflictError) {
+      showError('That email is already registered.');
+    }
+  }
+  \`\`\`
+
 ### Upsert
 
 Insert a record, or update the existing one matching a filter.
@@ -388,6 +402,44 @@ await Koolbase.messaging.send({
 
 ---
 
+## Error handling
+
+Koolbase throws typed errors selected from the server's stable error `code`, so
+handling doesn't depend on message text.
+
+### Database errors
+
+All data-layer failures extend `KoolbaseDataError` (which extends `Error`):
+
+| Error | When |
+|---|---|
+| `KoolbaseConflictError` | A write violates a unique constraint (409). Exposes `.field`. |
+| `KoolbaseNotFoundError` | The record or collection doesn't exist (404). |
+| `KoolbaseValidationError` | The request was rejected as invalid (400). |
+| `KoolbasePermissionError` | An access rule denied the operation (403). |
+| `KoolbaseRateLimitError` | The caller is being rate-limited (429). |
+
+```ts
+import { KoolbaseConflictError, KoolbaseDataError } from '@techfinityedge/koolbase-react-native';
+
+try {
+  await koolbase.db.upsert('users', { email }, { name });
+} catch (e) {
+  if (e instanceof KoolbaseConflictError) {
+    showError(`That ${e.field ?? 'value'} is already taken.`);
+  } else if (e instanceof KoolbaseDataError) {
+    showError(e.message);
+  }
+}
+```
+
+> `query`, `get`, `upsert`, and `deleteWhere` throw these typed errors. `insert`,
+> `update`, and `delete` are optimistic/offline-first — they queue and sync in
+> the background, so their conflicts surface via the sync engine, not as a
+> thrown error.
+
+---
+
 ## What's included
 
 - Authentication: email + password, Apple Sign-In, phone + OTP

package/dist/auth.d.ts

@@ -110,15 +110,18 @@ export declare class KoolbaseAuth {
      */
     signInWithGoogle(params: SignInWithGoogleParams): Promise<KoolbaseSession>;
     /**
-     * Parses a /v1/sdk/auth/oauth/google response. Distinct from
-     * parseSessionResponse and parseAppleSessionResponse because OAuth
-     * error semantics differ per-provider.
+     * Parses a /v1/sdk/auth/oauth/google response. Code-first: the server
+     * emits unified OAuth codes (oauth_not_configured, invalid_oauth_token,
+     * oauth_email_required, oauth_email_conflict) for both providers; the
+     * provider distinction is made here so Google codes map to Google-specific
+     * errors. Status + message logic is retained as a fallback for older servers.
      */
     private parseGoogleSessionResponse;
     /**
-     * Parses a /v1/sdk/auth/oauth/apple response. Distinct from
-     * parseSessionResponse because OAuth error semantics differ from
-     * credential auth — status codes map to a separate error set.
+     * Parses a /v1/sdk/auth/oauth/apple response. Code-first; the provider
+     * distinction is made here so the server's unified OAuth codes map to
+     * Apple-specific errors. Status + message logic is retained as a fallback
+     * for older servers.
      */
     private parseAppleSessionResponse;
     refresh(refreshToken?: string): Promise<KoolbaseSession>;
@@ -159,8 +162,30 @@ export declare class KoolbaseAuth {
     private validatePhone;
     private _ensureValidToken;
     private mapUser;
+    /**
+     * Parse a session-returning response (login, register, refresh).
+     * Non-2xx is delegated to throwTypedError, which is code-first
+     * (reads body.code) with a status/message fallback. isRefresh only
+     * affects how a bare 401 (no code, older server) is interpreted.
+     */
     private parseSessionResponse;
     private checkResponse;
+    /**
+     * Map a non-2xx credential/session response to a typed error.
+     *
+     * Code-first: the server now emits a stable `code` on every error
+     * (contract conformance), so we switch on body.code. The status +
+     * message logic is retained as a fallback for older servers or any
+     * response that arrives without a code. isRefresh only changes how a
+     * bare 401 is interpreted in the fallback path.
+     */
     private throwTypedError;
+    /**
+     * Parse a phone-auth response. Code-first, with a phone-specific twist:
+     * the server emits the generic `rate_limit` code for the phone endpoints
+     * (they share the default 429), but phone has a dedicated server-side
+     * rate-limiter, so we surface OtpRateLimitError rather than RateLimitError.
+     * Status + message logic is retained as a fallback for older servers.
+     */
     private parsePhoneResponse;
 }

package/dist/auth.js

@@ -297,9 +297,11 @@ class KoolbaseAuth {
         return session;
     }
     /**
-     * Parses a /v1/sdk/auth/oauth/google response. Distinct from
-     * parseSessionResponse and parseAppleSessionResponse because OAuth
-     * error semantics differ per-provider.
+     * Parses a /v1/sdk/auth/oauth/google response. Code-first: the server
+     * emits unified OAuth codes (oauth_not_configured, invalid_oauth_token,
+     * oauth_email_required, oauth_email_conflict) for both providers; the
+     * provider distinction is made here so Google codes map to Google-specific
+     * errors. Status + message logic is retained as a fallback for older servers.
      */
     async parseGoogleSessionResponse(res) {
         if (res.status === 200) {
@@ -311,14 +313,31 @@ class KoolbaseAuth {
                 user: this.mapUser(data.user),
             };
         }
-        let errorMessage = '';
+        let body = {};
         try {
-            const data = await res.json();
-            errorMessage = data?.error ?? '';
+            body = await res.json();
         }
         catch {
             // best-effort error message extraction
         }
+        const code = body?.code ?? '';
+        const errorMessage = body?.error ?? '';
+        // ─── code-first ───
+        switch (code) {
+            case 'oauth_not_configured':
+                throw new auth_errors_1.GoogleSignInNotConfiguredError();
+            case 'invalid_oauth_token':
+                throw new auth_errors_1.InvalidGoogleTokenError();
+            case 'account_disabled':
+                throw new auth_errors_1.UserDisabledError();
+            case 'oauth_email_required':
+                throw new auth_errors_1.GoogleEmailRequiredError();
+            case 'oauth_email_conflict':
+                throw new auth_errors_1.OAuthEmailConflictError();
+            case 'rate_limit':
+                throw new auth_errors_1.RateLimitError(errorMessage || undefined);
+        }
+        // ─── status + message fallback (pre-code servers) ───
         if (res.status === 400) {
             if (errorMessage.includes('not configured')) {
                 throw new auth_errors_1.GoogleSignInNotConfiguredError();
@@ -339,9 +358,10 @@ class KoolbaseAuth {
         throw new auth_errors_1.KoolbaseAuthError(`google sign-in failed: ${res.status} ${errorMessage}`, `google_signin_http_${res.status}`);
     }
     /**
-     * Parses a /v1/sdk/auth/oauth/apple response. Distinct from
-     * parseSessionResponse because OAuth error semantics differ from
-     * credential auth — status codes map to a separate error set.
+     * Parses a /v1/sdk/auth/oauth/apple response. Code-first; the provider
+     * distinction is made here so the server's unified OAuth codes map to
+     * Apple-specific errors. Status + message logic is retained as a fallback
+     * for older servers.
      */
     async parseAppleSessionResponse(res) {
         if (res.status === 200) {
@@ -353,14 +373,31 @@ class KoolbaseAuth {
                 user: this.mapUser(data.user),
             };
         }
-        let errorMessage = '';
+        let body = {};
         try {
-            const data = await res.json();
-            errorMessage = data?.error ?? '';
+            body = await res.json();
         }
         catch {
             // best-effort error message extraction
         }
+        const code = body?.code ?? '';
+        const errorMessage = body?.error ?? '';
+        // ─── code-first ───
+        switch (code) {
+            case 'oauth_not_configured':
+                throw new auth_errors_1.AppleSignInNotConfiguredError();
+            case 'invalid_oauth_token':
+                throw new auth_errors_1.InvalidAppleTokenError();
+            case 'account_disabled':
+                throw new auth_errors_1.UserDisabledError();
+            case 'oauth_email_required':
+                throw new auth_errors_1.AppleEmailRequiredError();
+            case 'oauth_email_conflict':
+                throw new auth_errors_1.OAuthEmailConflictError();
+            case 'rate_limit':
+                throw new auth_errors_1.RateLimitError(errorMessage || undefined);
+        }
+        // ─── status + message fallback (pre-code servers) ───
         if (res.status === 400) {
             if (errorMessage.includes('not configured')) {
                 throw new auth_errors_1.AppleSignInNotConfiguredError();
@@ -592,16 +629,15 @@ class KoolbaseAuth {
             createdAt: raw.created_at,
         };
     }
+    /**
+     * Parse a session-returning response (login, register, refresh).
+     * Non-2xx is delegated to throwTypedError, which is code-first
+     * (reads body.code) with a status/message fallback. isRefresh only
+     * affects how a bare 401 (no code, older server) is interpreted.
+     */
     async parseSessionResponse(res, isRefresh) {
-        if (res.status === 409)
-            throw new auth_errors_1.EmailAlreadyInUseError();
-        if (res.status === 401) {
-            throw isRefresh ? new auth_errors_1.SessionExpiredError() : new auth_errors_1.InvalidCredentialsError();
-        }
-        if (res.status === 403)
-            throw new auth_errors_1.UserDisabledError();
         if (!res.ok)
-            await this.throwTypedError(res);
+            await this.throwTypedError(res, isRefresh); // never returns
         const data = await res.json();
         return {
             accessToken: data.access_token,
@@ -615,7 +651,16 @@ class KoolbaseAuth {
             return;
         await this.throwTypedError(res);
     }
-    async throwTypedError(res) {
+    /**
+     * Map a non-2xx credential/session response to a typed error.
+     *
+     * Code-first: the server now emits a stable `code` on every error
+     * (contract conformance), so we switch on body.code. The status +
+     * message logic is retained as a fallback for older servers or any
+     * response that arrives without a code. isRefresh only changes how a
+     * bare 401 is interpreted in the fallback path.
+     */
+    async throwTypedError(res, isRefresh = false) {
         let body = {};
         try {
             body = await res.json();
@@ -623,13 +668,43 @@ class KoolbaseAuth {
         catch {
             // ignore
         }
+        const code = body.code ?? '';
         const msg = body.error ?? '';
+        // ─── code-first ───
+        switch (code) {
+            case 'invalid_credentials':
+                throw new auth_errors_1.InvalidCredentialsError();
+            case 'email_in_use':
+                throw new auth_errors_1.EmailAlreadyInUseError();
+            case 'account_disabled':
+                throw new auth_errors_1.UserDisabledError();
+            case 'account_locked':
+                throw new auth_errors_1.AccountLockedError();
+            case 'invalid_refresh_token':
+                // Refresh token rejected — the session is unrecoverable; re-login.
+                throw new auth_errors_1.SessionExpiredError();
+            case 'token_revoked':
+                throw new auth_errors_1.TokenRevokedError();
+            case 'invalid_unlock_token':
+                throw new auth_errors_1.UnlockTokenInvalidError();
+            case 'rate_limit':
+                throw new auth_errors_1.RateLimitError(msg || undefined);
+        }
+        // ─── status fallback (pre-code servers) ───
+        if (res.status === 409)
+            throw new auth_errors_1.EmailAlreadyInUseError();
+        if (res.status === 401) {
+            throw isRefresh ? new auth_errors_1.SessionExpiredError() : new auth_errors_1.InvalidCredentialsError();
+        }
+        if (res.status === 403)
+            throw new auth_errors_1.UserDisabledError();
         if (res.status === 429) {
             if (msg.includes('account temporarily locked')) {
                 throw new auth_errors_1.AccountLockedError();
             }
             throw new auth_errors_1.RateLimitError(msg || undefined);
         }
+        // ─── legacy message fallback ───
         if (msg.includes('invalid or expired unlock token')) {
             throw new auth_errors_1.UnlockTokenInvalidError();
         }
@@ -638,8 +713,15 @@ class KoolbaseAuth {
             msg.includes('session has been revoked')) {
             throw new auth_errors_1.TokenRevokedError();
         }
-        throw new auth_errors_1.KoolbaseAuthError(msg || `Request failed: ${res.status}`, `http_${res.status}`);
+        throw new auth_errors_1.KoolbaseAuthError(msg || `Request failed: ${res.status}`, code || `http_${res.status}`);
     }
+    /**
+     * Parse a phone-auth response. Code-first, with a phone-specific twist:
+     * the server emits the generic `rate_limit` code for the phone endpoints
+     * (they share the default 429), but phone has a dedicated server-side
+     * rate-limiter, so we surface OtpRateLimitError rather than RateLimitError.
+     * Status + message logic is retained as a fallback for older servers.
+     */
     async parsePhoneResponse(res) {
         let body = {};
         try {
@@ -650,11 +732,31 @@ class KoolbaseAuth {
         }
         if (res.ok)
             return body;
+        const code = body.code ?? '';
         const msg = body.error ?? '';
+        // ─── code-first ───
+        switch (code) {
+            case 'invalid_phone':
+                throw new auth_errors_1.InvalidPhoneNumberError();
+            case 'otp_expired':
+                throw new auth_errors_1.OtpExpiredError();
+            case 'otp_invalid':
+                throw new auth_errors_1.OtpInvalidError();
+            case 'otp_max_attempts':
+                throw new auth_errors_1.OtpMaxAttemptsError();
+            case 'phone_in_use':
+                throw new auth_errors_1.PhoneAlreadyLinkedError();
+            case 'sms_not_configured':
+                throw new auth_errors_1.SmsConfigMissingError();
+            case 'rate_limit':
+                throw new auth_errors_1.OtpRateLimitError();
+        }
+        // ─── status fallback (pre-code servers) ───
         if (res.status === 429)
             throw new auth_errors_1.OtpRateLimitError();
         if (res.status === 409)
             throw new auth_errors_1.PhoneAlreadyLinkedError();
+        // ─── legacy message fallback ───
         if (msg.includes('E.164'))
             throw new auth_errors_1.InvalidPhoneNumberError();
         if (msg.includes('OTP has expired'))
@@ -669,7 +771,7 @@ class KoolbaseAuth {
         if (msg.includes('SMS provider not configured')) {
             throw new auth_errors_1.SmsConfigMissingError();
         }
-        throw new auth_errors_1.KoolbaseAuthError(msg || 'An unexpected error occurred');
+        throw new auth_errors_1.KoolbaseAuthError(msg || 'An unexpected error occurred', code || undefined);
     }
 }
 exports.KoolbaseAuth = KoolbaseAuth;

package/dist/database-errors.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Base class for errors surfaced by the Koolbase data layer (database reads
+ * and writes). Every data error carries a `message` and, when the server
+ * provides one, its stable `code` (e.g. `not_found`, `validation_error`,
+ * `unique_violation`).
+ *
+ * Catch this to handle any data-layer failure generically, or catch a
+ * specific subclass to branch on the kind of failure.
+ */
+export declare class KoolbaseDataError extends Error {
+    code?: string;
+    constructor(message: string, code?: string);
+}
+/**
+ * Thrown when a write is rejected because the value would violate a
+ * collection's unique constraint — the server responds with 409 Conflict.
+ * Catch it to handle duplicates, e.g. an email or username already in use.
+ *
+ * `field` names the field that collided, when the server reports it
+ * (`details.field`) — useful when a collection has more than one unique
+ * constraint and you need to know which value clashed.
+ *
+ * Currently surfaced by `upsert` (the online-only write). `insert` and
+ * `update` are optimistic/offline-first: they accept the write locally and
+ * sync in the background, so a constraint conflict on those paths is a
+ * sync-time concern rather than a thrown error.
+ *
+ * @example
+ * try {
+ *   await koolbase.db.upsert('users', { email }, { name });
+ * } catch (e) {
+ *   if (e instanceof KoolbaseConflictError) {
+ *     showError(`That ${e.field ?? 'value'} is already registered.`);
+ *   }
+ * }
+ */
+export declare class KoolbaseConflictError extends KoolbaseDataError {
+    field?: string;
+    constructor(message?: string, field?: string);
+}
+/**
+ * Thrown when the requested record or collection does not exist — the server
+ * responds with 404 and code `not_found` / `record_not_found` /
+ * `collection_not_found`.
+ */
+export declare class KoolbaseNotFoundError extends KoolbaseDataError {
+    constructor(message?: string);
+}
+/**
+ * Thrown when the request is rejected as invalid — the server responds with
+ * 400 and code `validation_error`.
+ */
+export declare class KoolbaseValidationError extends KoolbaseDataError {
+    constructor(message?: string);
+}
+/**
+ * Thrown when the caller is authenticated but not allowed to perform the
+ * operation — the server responds with 403 and code `permission_denied`
+ * (typically a collection access rule rejecting the read/write).
+ */
+export declare class KoolbasePermissionError extends KoolbaseDataError {
+    constructor(message?: string);
+}
+/**
+ * Thrown when the server is rate-limiting the caller — 429 with code
+ * `rate_limit`. Back off and retry after a short delay.
+ */
+export declare class KoolbaseRateLimitError extends KoolbaseDataError {
+    constructor(message?: string);
+}
+/**
+ * Maps a non-2xx data-layer response to a typed {@link KoolbaseDataError},
+ * preferring the server's stable `code` and falling back to the HTTP status
+ * for older or uncoded responses. Always returns an error to throw.
+ */
+export declare function koolbaseDataError(status: number, body: any, fallbackMessage?: string): KoolbaseDataError;

package/dist/database-errors.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoolbaseRateLimitError = exports.KoolbasePermissionError = exports.KoolbaseValidationError = exports.KoolbaseNotFoundError = exports.KoolbaseConflictError = exports.KoolbaseDataError = void 0;
+exports.koolbaseDataError = koolbaseDataError;
+/**
+ * Base class for errors surfaced by the Koolbase data layer (database reads
+ * and writes). Every data error carries a `message` and, when the server
+ * provides one, its stable `code` (e.g. `not_found`, `validation_error`,
+ * `unique_violation`).
+ *
+ * Catch this to handle any data-layer failure generically, or catch a
+ * specific subclass to branch on the kind of failure.
+ */
+class KoolbaseDataError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'KoolbaseDataError';
+        Object.setPrototypeOf(this, KoolbaseDataError.prototype);
+    }
+}
+exports.KoolbaseDataError = KoolbaseDataError;
+/**
+ * Thrown when a write is rejected because the value would violate a
+ * collection's unique constraint — the server responds with 409 Conflict.
+ * Catch it to handle duplicates, e.g. an email or username already in use.
+ *
+ * `field` names the field that collided, when the server reports it
+ * (`details.field`) — useful when a collection has more than one unique
+ * constraint and you need to know which value clashed.
+ *
+ * Currently surfaced by `upsert` (the online-only write). `insert` and
+ * `update` are optimistic/offline-first: they accept the write locally and
+ * sync in the background, so a constraint conflict on those paths is a
+ * sync-time concern rather than a thrown error.
+ *
+ * @example
+ * try {
+ *   await koolbase.db.upsert('users', { email }, { name });
+ * } catch (e) {
+ *   if (e instanceof KoolbaseConflictError) {
+ *     showError(`That ${e.field ?? 'value'} is already registered.`);
+ *   }
+ * }
+ */
+class KoolbaseConflictError extends KoolbaseDataError {
+    constructor(message, field) {
+        super(message ?? 'Value violates a unique constraint', 'unique_violation');
+        this.field = field;
+        this.name = 'KoolbaseConflictError';
+        Object.setPrototypeOf(this, KoolbaseConflictError.prototype);
+    }
+}
+exports.KoolbaseConflictError = KoolbaseConflictError;
+/**
+ * Thrown when the requested record or collection does not exist — the server
+ * responds with 404 and code `not_found` / `record_not_found` /
+ * `collection_not_found`.
+ */
+class KoolbaseNotFoundError extends KoolbaseDataError {
+    constructor(message) {
+        super(message ?? 'The requested resource was not found', 'not_found');
+        this.name = 'KoolbaseNotFoundError';
+        Object.setPrototypeOf(this, KoolbaseNotFoundError.prototype);
+    }
+}
+exports.KoolbaseNotFoundError = KoolbaseNotFoundError;
+/**
+ * Thrown when the request is rejected as invalid — the server responds with
+ * 400 and code `validation_error`.
+ */
+class KoolbaseValidationError extends KoolbaseDataError {
+    constructor(message) {
+        super(message ?? 'The request was invalid', 'validation_error');
+        this.name = 'KoolbaseValidationError';
+        Object.setPrototypeOf(this, KoolbaseValidationError.prototype);
+    }
+}
+exports.KoolbaseValidationError = KoolbaseValidationError;
+/**
+ * Thrown when the caller is authenticated but not allowed to perform the
+ * operation — the server responds with 403 and code `permission_denied`
+ * (typically a collection access rule rejecting the read/write).
+ */
+class KoolbasePermissionError extends KoolbaseDataError {
+    constructor(message) {
+        super(message ?? 'You do not have permission to perform this action', 'permission_denied');
+        this.name = 'KoolbasePermissionError';
+        Object.setPrototypeOf(this, KoolbasePermissionError.prototype);
+    }
+}
+exports.KoolbasePermissionError = KoolbasePermissionError;
+/**
+ * Thrown when the server is rate-limiting the caller — 429 with code
+ * `rate_limit`. Back off and retry after a short delay.
+ */
+class KoolbaseRateLimitError extends KoolbaseDataError {
+    constructor(message) {
+        super(message ?? 'Too many requests, please slow down', 'rate_limit');
+        this.name = 'KoolbaseRateLimitError';
+        Object.setPrototypeOf(this, KoolbaseRateLimitError.prototype);
+    }
+}
+exports.KoolbaseRateLimitError = KoolbaseRateLimitError;
+/**
+ * Maps a non-2xx data-layer response to a typed {@link KoolbaseDataError},
+ * preferring the server's stable `code` and falling back to the HTTP status
+ * for older or uncoded responses. Always returns an error to throw.
+ */
+function koolbaseDataError(status, body, fallbackMessage = 'Request failed') {
+    const code = body?.code;
+    const message = body?.error ?? fallbackMessage;
+    const field = body?.details?.field;
+    // ─── code-first ───
+    switch (code) {
+        case 'unique_violation':
+            return new KoolbaseConflictError(message, field);
+        case 'not_found':
+        case 'record_not_found':
+        case 'collection_not_found':
+            return new KoolbaseNotFoundError(message);
+        case 'permission_denied':
+            return new KoolbasePermissionError(message);
+        case 'rate_limit':
+            return new KoolbaseRateLimitError(message);
+        case 'validation_error':
+            return new KoolbaseValidationError(message);
+    }
+    // ─── status fallback (pre-code servers) ───
+    switch (status) {
+        case 409:
+            return new KoolbaseConflictError(message);
+        case 404:
+            return new KoolbaseNotFoundError(message);
+        case 403:
+            return new KoolbasePermissionError(message);
+        case 429:
+            return new KoolbaseRateLimitError(message);
+        case 400:
+            return new KoolbaseValidationError(message);
+    }
+    return new KoolbaseDataError(message, code);
+}

package/dist/database.js

@@ -4,6 +4,7 @@ exports.KoolbaseDatabase = void 0;
 const cache_store_1 = require("./cache-store");
 const sync_engine_1 = require("./sync-engine");
 const record_1 = require("./record");
+const database_errors_1 = require("./database-errors");
 function generateId() {
     return 'local_' + Math.random().toString(36).slice(2) + Date.now().toString(36);
 }
@@ -30,7 +31,7 @@ class KoolbaseDatabase {
         });
         const data = await res.json();
         if (!res.ok) {
-            throw new Error(data.error ?? `Request failed: ${res.status}`);
+            throw (0, database_errors_1.koolbaseDataError)(res.status, data, `Request failed: ${res.status}`);
         }
         return data;
     }
@@ -121,7 +122,7 @@ class KoolbaseDatabase {
         });
         const body = await res.json();
         if (!res.ok) {
-            throw new Error(body.error ?? `Upsert failed: ${res.status}`);
+            throw (0, database_errors_1.koolbaseDataError)(res.status, body, `Upsert failed: ${res.status}`);
         }
         const created = res.status === 201;
         const record = (0, record_1.recordFromWire)(body);
@@ -150,7 +151,7 @@ class KoolbaseDatabase {
         });
         const body = await res.json();
         if (!res.ok) {
-            throw new Error(body.error ?? `Delete failed: ${res.status}`);
+            throw (0, database_errors_1.koolbaseDataError)(res.status, body, `Delete failed: ${res.status}`);
         }
         const userId = this.getUserId() ?? 'anonymous';
         await (0, cache_store_1.invalidateCache)(userId, collection);

package/dist/index.d.ts

@@ -18,6 +18,7 @@ import { KoolbaseStorage } from './storage';
 import { KoolbaseConfig, VersionCheckResult } from './types';
 export * from './types';
 export * from './auth-errors';
+export * from './database-errors';
 export { KoolbaseAuth, KoolbaseDatabase, KoolbaseFlags, KoolbaseFunctions, KoolbaseRealtime, KoolbaseStorage };
 export declare const Koolbase: {
     initialize(config: KoolbaseConfig): Promise<void>;

package/dist/index.js

@@ -45,6 +45,7 @@ const storage_1 = require("./storage");
 Object.defineProperty(exports, "KoolbaseStorage", { enumerable: true, get: function () { return storage_1.KoolbaseStorage; } });
 __exportStar(require("./types"), exports);
 __exportStar(require("./auth-errors"), exports);
+__exportStar(require("./database-errors"), exports);
 let _auth = null;
 let _db = null;
 let _storage = null;

package/package.json

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