@koolbase/core 11.1.0 → 11.2.0

package/dist/cjs/database-errors.d.ts

@@ -41,6 +41,25 @@ export declare class KoolbaseDataError extends KoolbaseError {
  *   }
  * }
  */
+/**
+ * An upsert whose filter matched more than one record.
+ *
+ * Refused rather than resolved: picking one of several would be a silent
+ * guess about which row the caller meant, and the wrong guess overwrites data
+ * nobody asked to change. Narrow the filter, or add a unique constraint over
+ * the fields you are matching on so the ambiguity cannot arise.
+ */
+export declare class KoolbaseAmbiguousMatchError extends KoolbaseDataError {
+    constructor(message?: string);
+}
+/** A unique constraint already covers those fields. */
+export declare class KoolbaseConstraintExistsError extends KoolbaseDataError {
+    constructor(message?: string);
+}
+/** No such unique constraint. */
+export declare class KoolbaseConstraintNotFoundError extends KoolbaseDataError {
+    constructor(message?: string);
+}
 export declare class KoolbaseConflictError extends KoolbaseDataError {
     field?: string;
     constructor(message?: string, field?: string);
@@ -51,20 +70,43 @@ export declare class KoolbaseConflictError extends KoolbaseDataError {
  * `collection_not_found`.
  */
 export declare class KoolbaseNotFoundError extends KoolbaseDataError {
-    constructor(message?: string);
+    /**
+     * The code is carried rather than fixed, because the server distinguishes
+     * what was missing — a record, a collection, a vector field — and an app
+     * reading e.code should get that answer rather than the category. Catching
+     * the class still works for anyone who only cares that something was
+     * absent.
+     */
+    constructor(message?: string, code?: 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);
+    /**
+     * Carries its code for the same reason KoolbaseNotFoundError does: a
+     * dimension the platform does not support and a vector pointed at the wrong
+     * collection are both validation failures, and an app should still be able
+     * to tell which without reading the message.
+     */
+    constructor(message?: string, code?: 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).
  */
+/**
+ * Authenticated, and not permitted to do this — distinct from a rule denying
+ * access to a record. Its own class rather than folding into
+ * KoolbasePermissionError, which hardcodes permission_denied: an error
+ * reporting a code the server did not send is a small lie, and apps that
+ * branch on e.code rather than instanceof would act on it.
+ */
+export declare class KoolbaseInsufficientAuthorityError extends KoolbaseDataError {
+    constructor(message?: string);
+}
 export declare class KoolbasePermissionError extends KoolbaseDataError {
     constructor(message?: string);
 }

package/dist/cjs/database-errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KoolbaseVectorDimensionMismatchError = exports.KoolbaseRateLimitError = exports.KoolbasePermissionError = exports.KoolbaseValidationError = exports.KoolbaseNotFoundError = exports.KoolbaseConflictError = exports.KoolbaseDataError = void 0;
+exports.KoolbaseVectorDimensionMismatchError = exports.KoolbaseRateLimitError = exports.KoolbasePermissionError = exports.KoolbaseInsufficientAuthorityError = exports.KoolbaseValidationError = exports.KoolbaseNotFoundError = exports.KoolbaseConflictError = exports.KoolbaseConstraintNotFoundError = exports.KoolbaseConstraintExistsError = exports.KoolbaseAmbiguousMatchError = exports.KoolbaseDataError = void 0;
 exports.koolbaseDataError = koolbaseDataError;
 const errors_js_1 = require("./errors.js");
 /**
@@ -44,6 +44,40 @@ exports.KoolbaseDataError = KoolbaseDataError;
  *   }
  * }
  */
+/**
+ * An upsert whose filter matched more than one record.
+ *
+ * Refused rather than resolved: picking one of several would be a silent
+ * guess about which row the caller meant, and the wrong guess overwrites data
+ * nobody asked to change. Narrow the filter, or add a unique constraint over
+ * the fields you are matching on so the ambiguity cannot arise.
+ */
+class KoolbaseAmbiguousMatchError extends KoolbaseDataError {
+    constructor(message) {
+        super(message ?? 'Upsert match resolved to more than one record', 'ambiguous_match');
+        this.name = 'KoolbaseAmbiguousMatchError';
+        Object.setPrototypeOf(this, KoolbaseAmbiguousMatchError.prototype);
+    }
+}
+exports.KoolbaseAmbiguousMatchError = KoolbaseAmbiguousMatchError;
+/** A unique constraint already covers those fields. */
+class KoolbaseConstraintExistsError extends KoolbaseDataError {
+    constructor(message) {
+        super(message ?? 'A unique constraint already exists for these fields', 'constraint_exists');
+        this.name = 'KoolbaseConstraintExistsError';
+        Object.setPrototypeOf(this, KoolbaseConstraintExistsError.prototype);
+    }
+}
+exports.KoolbaseConstraintExistsError = KoolbaseConstraintExistsError;
+/** No such unique constraint. */
+class KoolbaseConstraintNotFoundError extends KoolbaseDataError {
+    constructor(message) {
+        super(message ?? 'Unique constraint not found', 'constraint_not_found');
+        this.name = 'KoolbaseConstraintNotFoundError';
+        Object.setPrototypeOf(this, KoolbaseConstraintNotFoundError.prototype);
+    }
+}
+exports.KoolbaseConstraintNotFoundError = KoolbaseConstraintNotFoundError;
 class KoolbaseConflictError extends KoolbaseDataError {
     constructor(message, field) {
         super(message ?? 'Value violates a unique constraint', 'unique_violation');
@@ -59,8 +93,15 @@ exports.KoolbaseConflictError = KoolbaseConflictError;
  * `collection_not_found`.
  */
 class KoolbaseNotFoundError extends KoolbaseDataError {
-    constructor(message) {
-        super(message ?? 'The requested resource was not found', 'not_found');
+    /**
+     * The code is carried rather than fixed, because the server distinguishes
+     * what was missing — a record, a collection, a vector field — and an app
+     * reading e.code should get that answer rather than the category. Catching
+     * the class still works for anyone who only cares that something was
+     * absent.
+     */
+    constructor(message, code = 'not_found') {
+        super(message ?? 'The requested resource was not found', code);
         this.name = 'KoolbaseNotFoundError';
         Object.setPrototypeOf(this, KoolbaseNotFoundError.prototype);
     }
@@ -71,8 +112,14 @@ exports.KoolbaseNotFoundError = KoolbaseNotFoundError;
  * 400 and code `validation_error`.
  */
 class KoolbaseValidationError extends KoolbaseDataError {
-    constructor(message) {
-        super(message ?? 'The request was invalid', 'validation_error');
+    /**
+     * Carries its code for the same reason KoolbaseNotFoundError does: a
+     * dimension the platform does not support and a vector pointed at the wrong
+     * collection are both validation failures, and an app should still be able
+     * to tell which without reading the message.
+     */
+    constructor(message, code = 'validation_error') {
+        super(message ?? 'The request was invalid', code);
         this.name = 'KoolbaseValidationError';
         Object.setPrototypeOf(this, KoolbaseValidationError.prototype);
     }
@@ -83,6 +130,21 @@ exports.KoolbaseValidationError = KoolbaseValidationError;
  * operation — the server responds with 403 and code `permission_denied`
  * (typically a collection access rule rejecting the read/write).
  */
+/**
+ * Authenticated, and not permitted to do this — distinct from a rule denying
+ * access to a record. Its own class rather than folding into
+ * KoolbasePermissionError, which hardcodes permission_denied: an error
+ * reporting a code the server did not send is a small lie, and apps that
+ * branch on e.code rather than instanceof would act on it.
+ */
+class KoolbaseInsufficientAuthorityError extends KoolbaseDataError {
+    constructor(message) {
+        super(message ?? 'You do not have the authority to perform this action', 'insufficient_authority');
+        this.name = 'KoolbaseInsufficientAuthorityError';
+        Object.setPrototypeOf(this, KoolbaseInsufficientAuthorityError.prototype);
+    }
+}
+exports.KoolbaseInsufficientAuthorityError = KoolbaseInsufficientAuthorityError;
 class KoolbasePermissionError extends KoolbaseDataError {
     constructor(message) {
         super(message ?? 'You do not have permission to perform this action', 'permission_denied');
@@ -155,12 +217,20 @@ function koolbaseDataError(status, body, fallbackMessage = 'Request failed') {
     switch (code) {
         case 'unique_violation':
             return attach(new KoolbaseConflictError(message, field));
+        case 'ambiguous_match':
+            return attach(new KoolbaseAmbiguousMatchError(message));
+        case 'constraint_exists':
+            return attach(new KoolbaseConstraintExistsError(message));
+        case 'constraint_not_found':
+            return attach(new KoolbaseConstraintNotFoundError(message));
+        case 'insufficient_authority':
+            return attach(new KoolbaseInsufficientAuthorityError(message));
         case 'not_found':
         case 'record_not_found':
         case 'collection_not_found':
         case 'vector_not_found':
         case 'vector_field_not_found':
-            return attach(new KoolbaseNotFoundError(message));
+            return attach(new KoolbaseNotFoundError(message, code));
         case 'unauthenticated':
         case 'session_expired':
         case 'invalid_token':
@@ -172,7 +242,7 @@ function koolbaseDataError(status, body, fallbackMessage = 'Request failed') {
         case 'validation_error':
         case 'vector_collection_mismatch':
         case 'unsupported_dimension':
-            return attach(new KoolbaseValidationError(message));
+            return attach(new KoolbaseValidationError(message, code));
         case 'vector_dimension_mismatch':
             return attach(new KoolbaseVectorDimensionMismatchError(message));
     }

package/dist/cjs/function-errors.d.ts

@@ -47,5 +47,24 @@ export declare class FunctionQuotaExceededError extends FunctionInvokeError {
 export declare class FunctionExecutionError extends FunctionInvokeError {
     constructor(message: string, statusCode?: number);
 }
+/**
+ * The function ran past its timeout and was killed.
+ *
+ * Its own type because the remedy is different from a function that threw:
+ * a timeout means retry, or raise the function's timeout at deploy, or move
+ * the slow part elsewhere. Without this it arrived as FunctionExecutionError
+ * — indistinguishable from an exception, which is the one thing it is not.
+ * The server already tells them apart; it logs 504 as "timeout".
+ */
+export declare class FunctionTimeoutError extends FunctionInvokeError {
+    constructor(message: string);
+}
+/**
+ * Too many invocations, too fast. Distinct from a quota being spent: this one
+ * clears by waiting.
+ */
+export declare class FunctionRateLimitError extends FunctionInvokeError {
+    constructor(message: string);
+}
 /** Builds the right error for a failed invocation. */
 export declare function functionInvokeError(status: number, message: string): KoolbaseError;

package/dist/cjs/function-errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionExecutionError = exports.FunctionQuotaExceededError = exports.FunctionValidationError = exports.FunctionPermissionError = exports.FunctionNotFoundError = exports.FunctionInvokeError = void 0;
+exports.FunctionRateLimitError = exports.FunctionTimeoutError = exports.FunctionExecutionError = exports.FunctionQuotaExceededError = exports.FunctionValidationError = exports.FunctionPermissionError = exports.FunctionNotFoundError = exports.FunctionInvokeError = void 0;
 exports.functionInvokeError = functionInvokeError;
 const errors_js_1 = require("./errors.js");
 /**
@@ -81,6 +81,35 @@ class FunctionExecutionError extends FunctionInvokeError {
     }
 }
 exports.FunctionExecutionError = FunctionExecutionError;
+/**
+ * The function ran past its timeout and was killed.
+ *
+ * Its own type because the remedy is different from a function that threw:
+ * a timeout means retry, or raise the function's timeout at deploy, or move
+ * the slow part elsewhere. Without this it arrived as FunctionExecutionError
+ * — indistinguishable from an exception, which is the one thing it is not.
+ * The server already tells them apart; it logs 504 as "timeout".
+ */
+class FunctionTimeoutError extends FunctionInvokeError {
+    constructor(message) {
+        super(message, 504, 'timeout');
+        this.name = 'FunctionTimeoutError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.FunctionTimeoutError = FunctionTimeoutError;
+/**
+ * Too many invocations, too fast. Distinct from a quota being spent: this one
+ * clears by waiting.
+ */
+class FunctionRateLimitError extends FunctionInvokeError {
+    constructor(message) {
+        super(message, 429, 'rate_limit');
+        this.name = 'FunctionRateLimitError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.FunctionRateLimitError = FunctionRateLimitError;
 /** Builds the right error for a failed invocation. */
 function functionInvokeError(status, message) {
     switch (status) {
@@ -96,6 +125,11 @@ function functionInvokeError(status, message) {
             return new FunctionValidationError(message);
         case 402:
             return new FunctionQuotaExceededError(message);
+        case 429:
+            return new FunctionRateLimitError(message);
+        case 504:
+            // Before the generic 5xx branch: a timeout is not an exception.
+            return new FunctionTimeoutError(message);
     }
     if (status >= 500)
         return new FunctionExecutionError(message, status);

package/dist/cjs/storage-errors.d.ts

@@ -76,6 +76,24 @@ export declare class KoolbaseStoragePermissionError extends KoolbaseStorageError
  * 409 but means "path collides"); branch on the error type via
  * `instanceof`, not on status.
  */
+/**
+ * The presigned upload was confirmed after its window closed.
+ *
+ * An upload URL has a lifetime. A user who picks a file, gets distracted and
+ * comes back twenty minutes later hits this — so it is a retry, not a
+ * failure: presign again and send the same bytes. Worth catching rather than
+ * showing "upload failed" to someone whose file was fine.
+ */
+export declare class KoolbaseUploadExpiredError extends KoolbaseStorageError {
+    constructor(message?: string);
+}
+/**
+ * A bucket cap set below what the bucket already holds. A dashboard
+ * operation rather than an app one, mapped so it does not arrive untyped.
+ */
+export declare class KoolbaseCapBelowUsageError extends KoolbaseStorageError {
+    constructor(message?: string);
+}
 export declare class KoolbaseStorageQuotaError extends KoolbaseStorageError {
     constructor(message?: string);
 }

package/dist/cjs/storage-errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KoolbaseStorageMetadataInvalidError = 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.KoolbaseCapBelowUsageError = exports.KoolbaseUploadExpiredError = exports.KoolbaseStoragePermissionError = exports.KoolbaseStorageValidationError = exports.KoolbaseStorageNotFoundError = exports.KoolbaseStorageConflictError = exports.KoolbaseStorageError = void 0;
 exports.koolbaseStorageError = koolbaseStorageError;
 exports.koolbaseStorageErrorFromResponse = koolbaseStorageErrorFromResponse;
 const errors_js_1 = require("./errors.js");
@@ -106,6 +106,34 @@ exports.KoolbaseStoragePermissionError = KoolbaseStoragePermissionError;
  * 409 but means "path collides"); branch on the error type via
  * `instanceof`, not on status.
  */
+/**
+ * The presigned upload was confirmed after its window closed.
+ *
+ * An upload URL has a lifetime. A user who picks a file, gets distracted and
+ * comes back twenty minutes later hits this — so it is a retry, not a
+ * failure: presign again and send the same bytes. Worth catching rather than
+ * showing "upload failed" to someone whose file was fine.
+ */
+class KoolbaseUploadExpiredError extends KoolbaseStorageError {
+    constructor(message) {
+        super(message ?? 'This upload is past the confirmation window — please re-upload', 'upload_expired');
+        this.name = 'KoolbaseUploadExpiredError';
+        Object.setPrototypeOf(this, KoolbaseUploadExpiredError.prototype);
+    }
+}
+exports.KoolbaseUploadExpiredError = KoolbaseUploadExpiredError;
+/**
+ * A bucket cap set below what the bucket already holds. A dashboard
+ * operation rather than an app one, mapped so it does not arrive untyped.
+ */
+class KoolbaseCapBelowUsageError extends KoolbaseStorageError {
+    constructor(message) {
+        super(message ?? 'The cap is below the bucket\'s current usage', 'cap_below_usage');
+        this.name = 'KoolbaseCapBelowUsageError';
+        Object.setPrototypeOf(this, KoolbaseCapBelowUsageError.prototype);
+    }
+}
+exports.KoolbaseCapBelowUsageError = KoolbaseCapBelowUsageError;
 class KoolbaseStorageQuotaError extends KoolbaseStorageError {
     constructor(message) {
         super(message ?? 'Bucket quota exceeded', 'quota_exceeded');
@@ -209,6 +237,10 @@ function koolbaseStorageError(status, body, fallbackMessage = 'Storage request f
             return new KoolbaseStorageConflictError(message, body?.path);
         case 'quota_exceeded':
             return new KoolbaseStorageQuotaError(message);
+        case 'upload_expired':
+            return new KoolbaseUploadExpiredError(message);
+        case 'cap_below_usage':
+            return new KoolbaseCapBelowUsageError(message);
         case 'file_too_large':
             return new KoolbaseStorageFileTooLargeError(message);
         case 'mime_not_allowed':

package/dist/esm/database-errors.d.ts

@@ -41,6 +41,25 @@ export declare class KoolbaseDataError extends KoolbaseError {
  *   }
  * }
  */
+/**
+ * An upsert whose filter matched more than one record.
+ *
+ * Refused rather than resolved: picking one of several would be a silent
+ * guess about which row the caller meant, and the wrong guess overwrites data
+ * nobody asked to change. Narrow the filter, or add a unique constraint over
+ * the fields you are matching on so the ambiguity cannot arise.
+ */
+export declare class KoolbaseAmbiguousMatchError extends KoolbaseDataError {
+    constructor(message?: string);
+}
+/** A unique constraint already covers those fields. */
+export declare class KoolbaseConstraintExistsError extends KoolbaseDataError {
+    constructor(message?: string);
+}
+/** No such unique constraint. */
+export declare class KoolbaseConstraintNotFoundError extends KoolbaseDataError {
+    constructor(message?: string);
+}
 export declare class KoolbaseConflictError extends KoolbaseDataError {
     field?: string;
     constructor(message?: string, field?: string);
@@ -51,20 +70,43 @@ export declare class KoolbaseConflictError extends KoolbaseDataError {
  * `collection_not_found`.
  */
 export declare class KoolbaseNotFoundError extends KoolbaseDataError {
-    constructor(message?: string);
+    /**
+     * The code is carried rather than fixed, because the server distinguishes
+     * what was missing — a record, a collection, a vector field — and an app
+     * reading e.code should get that answer rather than the category. Catching
+     * the class still works for anyone who only cares that something was
+     * absent.
+     */
+    constructor(message?: string, code?: 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);
+    /**
+     * Carries its code for the same reason KoolbaseNotFoundError does: a
+     * dimension the platform does not support and a vector pointed at the wrong
+     * collection are both validation failures, and an app should still be able
+     * to tell which without reading the message.
+     */
+    constructor(message?: string, code?: 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).
  */
+/**
+ * Authenticated, and not permitted to do this — distinct from a rule denying
+ * access to a record. Its own class rather than folding into
+ * KoolbasePermissionError, which hardcodes permission_denied: an error
+ * reporting a code the server did not send is a small lie, and apps that
+ * branch on e.code rather than instanceof would act on it.
+ */
+export declare class KoolbaseInsufficientAuthorityError extends KoolbaseDataError {
+    constructor(message?: string);
+}
 export declare class KoolbasePermissionError extends KoolbaseDataError {
     constructor(message?: string);
 }

package/dist/esm/database-errors.js

@@ -39,6 +39,37 @@ export class KoolbaseDataError extends KoolbaseError {
  *   }
  * }
  */
+/**
+ * An upsert whose filter matched more than one record.
+ *
+ * Refused rather than resolved: picking one of several would be a silent
+ * guess about which row the caller meant, and the wrong guess overwrites data
+ * nobody asked to change. Narrow the filter, or add a unique constraint over
+ * the fields you are matching on so the ambiguity cannot arise.
+ */
+export class KoolbaseAmbiguousMatchError extends KoolbaseDataError {
+    constructor(message) {
+        super(message ?? 'Upsert match resolved to more than one record', 'ambiguous_match');
+        this.name = 'KoolbaseAmbiguousMatchError';
+        Object.setPrototypeOf(this, KoolbaseAmbiguousMatchError.prototype);
+    }
+}
+/** A unique constraint already covers those fields. */
+export class KoolbaseConstraintExistsError extends KoolbaseDataError {
+    constructor(message) {
+        super(message ?? 'A unique constraint already exists for these fields', 'constraint_exists');
+        this.name = 'KoolbaseConstraintExistsError';
+        Object.setPrototypeOf(this, KoolbaseConstraintExistsError.prototype);
+    }
+}
+/** No such unique constraint. */
+export class KoolbaseConstraintNotFoundError extends KoolbaseDataError {
+    constructor(message) {
+        super(message ?? 'Unique constraint not found', 'constraint_not_found');
+        this.name = 'KoolbaseConstraintNotFoundError';
+        Object.setPrototypeOf(this, KoolbaseConstraintNotFoundError.prototype);
+    }
+}
 export class KoolbaseConflictError extends KoolbaseDataError {
     constructor(message, field) {
         super(message ?? 'Value violates a unique constraint', 'unique_violation');
@@ -53,8 +84,15 @@ export class KoolbaseConflictError extends KoolbaseDataError {
  * `collection_not_found`.
  */
 export class KoolbaseNotFoundError extends KoolbaseDataError {
-    constructor(message) {
-        super(message ?? 'The requested resource was not found', 'not_found');
+    /**
+     * The code is carried rather than fixed, because the server distinguishes
+     * what was missing — a record, a collection, a vector field — and an app
+     * reading e.code should get that answer rather than the category. Catching
+     * the class still works for anyone who only cares that something was
+     * absent.
+     */
+    constructor(message, code = 'not_found') {
+        super(message ?? 'The requested resource was not found', code);
         this.name = 'KoolbaseNotFoundError';
         Object.setPrototypeOf(this, KoolbaseNotFoundError.prototype);
     }
@@ -64,8 +102,14 @@ export class KoolbaseNotFoundError extends KoolbaseDataError {
  * 400 and code `validation_error`.
  */
 export class KoolbaseValidationError extends KoolbaseDataError {
-    constructor(message) {
-        super(message ?? 'The request was invalid', 'validation_error');
+    /**
+     * Carries its code for the same reason KoolbaseNotFoundError does: a
+     * dimension the platform does not support and a vector pointed at the wrong
+     * collection are both validation failures, and an app should still be able
+     * to tell which without reading the message.
+     */
+    constructor(message, code = 'validation_error') {
+        super(message ?? 'The request was invalid', code);
         this.name = 'KoolbaseValidationError';
         Object.setPrototypeOf(this, KoolbaseValidationError.prototype);
     }
@@ -75,6 +119,20 @@ export class KoolbaseValidationError extends KoolbaseDataError {
  * operation — the server responds with 403 and code `permission_denied`
  * (typically a collection access rule rejecting the read/write).
  */
+/**
+ * Authenticated, and not permitted to do this — distinct from a rule denying
+ * access to a record. Its own class rather than folding into
+ * KoolbasePermissionError, which hardcodes permission_denied: an error
+ * reporting a code the server did not send is a small lie, and apps that
+ * branch on e.code rather than instanceof would act on it.
+ */
+export class KoolbaseInsufficientAuthorityError extends KoolbaseDataError {
+    constructor(message) {
+        super(message ?? 'You do not have the authority to perform this action', 'insufficient_authority');
+        this.name = 'KoolbaseInsufficientAuthorityError';
+        Object.setPrototypeOf(this, KoolbaseInsufficientAuthorityError.prototype);
+    }
+}
 export class KoolbasePermissionError extends KoolbaseDataError {
     constructor(message) {
         super(message ?? 'You do not have permission to perform this action', 'permission_denied');
@@ -144,12 +202,20 @@ export function koolbaseDataError(status, body, fallbackMessage = 'Request faile
     switch (code) {
         case 'unique_violation':
             return attach(new KoolbaseConflictError(message, field));
+        case 'ambiguous_match':
+            return attach(new KoolbaseAmbiguousMatchError(message));
+        case 'constraint_exists':
+            return attach(new KoolbaseConstraintExistsError(message));
+        case 'constraint_not_found':
+            return attach(new KoolbaseConstraintNotFoundError(message));
+        case 'insufficient_authority':
+            return attach(new KoolbaseInsufficientAuthorityError(message));
         case 'not_found':
         case 'record_not_found':
         case 'collection_not_found':
         case 'vector_not_found':
         case 'vector_field_not_found':
-            return attach(new KoolbaseNotFoundError(message));
+            return attach(new KoolbaseNotFoundError(message, code));
         case 'unauthenticated':
         case 'session_expired':
         case 'invalid_token':
@@ -161,7 +227,7 @@ export function koolbaseDataError(status, body, fallbackMessage = 'Request faile
         case 'validation_error':
         case 'vector_collection_mismatch':
         case 'unsupported_dimension':
-            return attach(new KoolbaseValidationError(message));
+            return attach(new KoolbaseValidationError(message, code));
         case 'vector_dimension_mismatch':
             return attach(new KoolbaseVectorDimensionMismatchError(message));
     }

package/dist/esm/function-errors.d.ts

@@ -47,5 +47,24 @@ export declare class FunctionQuotaExceededError extends FunctionInvokeError {
 export declare class FunctionExecutionError extends FunctionInvokeError {
     constructor(message: string, statusCode?: number);
 }
+/**
+ * The function ran past its timeout and was killed.
+ *
+ * Its own type because the remedy is different from a function that threw:
+ * a timeout means retry, or raise the function's timeout at deploy, or move
+ * the slow part elsewhere. Without this it arrived as FunctionExecutionError
+ * — indistinguishable from an exception, which is the one thing it is not.
+ * The server already tells them apart; it logs 504 as "timeout".
+ */
+export declare class FunctionTimeoutError extends FunctionInvokeError {
+    constructor(message: string);
+}
+/**
+ * Too many invocations, too fast. Distinct from a quota being spent: this one
+ * clears by waiting.
+ */
+export declare class FunctionRateLimitError extends FunctionInvokeError {
+    constructor(message: string);
+}
 /** Builds the right error for a failed invocation. */
 export declare function functionInvokeError(status: number, message: string): KoolbaseError;

package/dist/esm/function-errors.js

@@ -71,6 +71,33 @@ export class FunctionExecutionError extends FunctionInvokeError {
         Object.setPrototypeOf(this, new.target.prototype);
     }
 }
+/**
+ * The function ran past its timeout and was killed.
+ *
+ * Its own type because the remedy is different from a function that threw:
+ * a timeout means retry, or raise the function's timeout at deploy, or move
+ * the slow part elsewhere. Without this it arrived as FunctionExecutionError
+ * — indistinguishable from an exception, which is the one thing it is not.
+ * The server already tells them apart; it logs 504 as "timeout".
+ */
+export class FunctionTimeoutError extends FunctionInvokeError {
+    constructor(message) {
+        super(message, 504, 'timeout');
+        this.name = 'FunctionTimeoutError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/**
+ * Too many invocations, too fast. Distinct from a quota being spent: this one
+ * clears by waiting.
+ */
+export class FunctionRateLimitError extends FunctionInvokeError {
+    constructor(message) {
+        super(message, 429, 'rate_limit');
+        this.name = 'FunctionRateLimitError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
 /** Builds the right error for a failed invocation. */
 export function functionInvokeError(status, message) {
     switch (status) {
@@ -86,6 +113,11 @@ export function functionInvokeError(status, message) {
             return new FunctionValidationError(message);
         case 402:
             return new FunctionQuotaExceededError(message);
+        case 429:
+            return new FunctionRateLimitError(message);
+        case 504:
+            // Before the generic 5xx branch: a timeout is not an exception.
+            return new FunctionTimeoutError(message);
     }
     if (status >= 500)
         return new FunctionExecutionError(message, status);

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

@@ -76,6 +76,24 @@ export declare class KoolbaseStoragePermissionError extends KoolbaseStorageError
  * 409 but means "path collides"); branch on the error type via
  * `instanceof`, not on status.
  */
+/**
+ * The presigned upload was confirmed after its window closed.
+ *
+ * An upload URL has a lifetime. A user who picks a file, gets distracted and
+ * comes back twenty minutes later hits this — so it is a retry, not a
+ * failure: presign again and send the same bytes. Worth catching rather than
+ * showing "upload failed" to someone whose file was fine.
+ */
+export declare class KoolbaseUploadExpiredError extends KoolbaseStorageError {
+    constructor(message?: string);
+}
+/**
+ * A bucket cap set below what the bucket already holds. A dashboard
+ * operation rather than an app one, mapped so it does not arrive untyped.
+ */
+export declare class KoolbaseCapBelowUsageError extends KoolbaseStorageError {
+    constructor(message?: string);
+}
 export declare class KoolbaseStorageQuotaError extends KoolbaseStorageError {
     constructor(message?: string);
 }

package/dist/esm/storage-errors.js

@@ -96,6 +96,32 @@ export class KoolbaseStoragePermissionError extends KoolbaseStorageError {
  * 409 but means "path collides"); branch on the error type via
  * `instanceof`, not on status.
  */
+/**
+ * The presigned upload was confirmed after its window closed.
+ *
+ * An upload URL has a lifetime. A user who picks a file, gets distracted and
+ * comes back twenty minutes later hits this — so it is a retry, not a
+ * failure: presign again and send the same bytes. Worth catching rather than
+ * showing "upload failed" to someone whose file was fine.
+ */
+export class KoolbaseUploadExpiredError extends KoolbaseStorageError {
+    constructor(message) {
+        super(message ?? 'This upload is past the confirmation window — please re-upload', 'upload_expired');
+        this.name = 'KoolbaseUploadExpiredError';
+        Object.setPrototypeOf(this, KoolbaseUploadExpiredError.prototype);
+    }
+}
+/**
+ * A bucket cap set below what the bucket already holds. A dashboard
+ * operation rather than an app one, mapped so it does not arrive untyped.
+ */
+export class KoolbaseCapBelowUsageError extends KoolbaseStorageError {
+    constructor(message) {
+        super(message ?? 'The cap is below the bucket\'s current usage', 'cap_below_usage');
+        this.name = 'KoolbaseCapBelowUsageError';
+        Object.setPrototypeOf(this, KoolbaseCapBelowUsageError.prototype);
+    }
+}
 export class KoolbaseStorageQuotaError extends KoolbaseStorageError {
     constructor(message) {
         super(message ?? 'Bucket quota exceeded', 'quota_exceeded');
@@ -195,6 +221,10 @@ export function koolbaseStorageError(status, body, fallbackMessage = 'Storage re
             return new KoolbaseStorageConflictError(message, body?.path);
         case 'quota_exceeded':
             return new KoolbaseStorageQuotaError(message);
+        case 'upload_expired':
+            return new KoolbaseUploadExpiredError(message);
+        case 'cap_below_usage':
+            return new KoolbaseCapBelowUsageError(message);
         case 'file_too_large':
             return new KoolbaseStorageFileTooLargeError(message);
         case 'mime_not_allowed':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koolbase/core",
-  "version": "11.1.0",
+  "version": "11.2.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",