@scryme/chat 2.91.43 → 2.91.76

package/dist/custom-instance.d.ts

@@ -1,7 +1,27 @@
-import { AxiosRequestConfig, AxiosError } from 'axios';
+import { AxiosRequestConfig } from 'axios';
 export declare const setGlobalToken: (token: string | null) => void;
 export declare const getGlobalToken: () => string | null;
+/**
+ * Custom SDK Error class for meaningful, developer-friendly error messages and structured error details.
+ */
+export declare class ScrymeSDKError extends Error {
+    readonly status?: number;
+    readonly code?: string;
+    readonly data?: any;
+    readonly rawError?: any;
+    constructor(message: string, options?: {
+        status?: number;
+        code?: string;
+        data?: any;
+        rawError?: any;
+    });
+}
+export { ScrymeSDKError as ScrymeError };
+/**
+ * Parses any error (AxiosError, Error, or unknown object) into a clean, meaningful ScrymeSDKError.
+ */
+export declare function parseSDKError(error: any): ScrymeSDKError;
 export declare const AXIOS_INSTANCE: import("axios").AxiosInstance;
 export declare const customInstance: <T>(config: AxiosRequestConfig, options?: AxiosRequestConfig) => Promise<T>;
-export type ErrorType<Error> = AxiosError<Error>;
+export type ErrorType<Error> = ScrymeSDKError;
 export type BodyType<Body> = Body;

package/dist/custom-instance.js

@@ -1,3 +1,18 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -46,11 +61,100 @@ export var setGlobalToken = function (token) {
     globalToken = token;
 };
 export var getGlobalToken = function () { return globalToken; };
+/**
+ * Custom SDK Error class for meaningful, developer-friendly error messages and structured error details.
+ */
+var ScrymeSDKError = /** @class */ (function (_super) {
+    __extends(ScrymeSDKError, _super);
+    function ScrymeSDKError(message, options) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, message) || this;
+        _this.name = 'ScrymeSDKError';
+        _this.status = options === null || options === void 0 ? void 0 : options.status;
+        _this.code = options === null || options === void 0 ? void 0 : options.code;
+        _this.data = options === null || options === void 0 ? void 0 : options.data;
+        _this.rawError = options === null || options === void 0 ? void 0 : options.rawError;
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return ScrymeSDKError;
+}(Error));
+export { ScrymeSDKError };
+export { ScrymeSDKError as ScrymeError };
+/**
+ * Parses any error (AxiosError, Error, or unknown object) into a clean, meaningful ScrymeSDKError.
+ */
+export function parseSDKError(error) {
+    if (error instanceof ScrymeSDKError) {
+        return error;
+    }
+    if (axios.isAxiosError(error)) {
+        var response = error.response;
+        var status_1 = response === null || response === void 0 ? void 0 : response.status;
+        var responseData = response === null || response === void 0 ? void 0 : response.data;
+        var code = error.code || (responseData && typeof responseData === 'object' ? responseData.code : undefined);
+        var message = void 0;
+        if (responseData) {
+            if (typeof responseData === 'string' && responseData.trim()) {
+                message = responseData;
+            }
+            else if (typeof responseData === 'object' && responseData !== null) {
+                if (Array.isArray(responseData.message)) {
+                    message = responseData.message.filter(Boolean).join('; ');
+                }
+                else if (typeof responseData.message === 'string' && responseData.message.trim()) {
+                    message = responseData.message;
+                }
+                else if (typeof responseData.error === 'string' && responseData.error.trim()) {
+                    message = responseData.error;
+                }
+                else if (responseData.error && typeof responseData.error === 'object' && typeof responseData.error.message === 'string') {
+                    message = responseData.error.message;
+                }
+                else if (typeof responseData.detail === 'string' && responseData.detail.trim()) {
+                    message = responseData.detail;
+                }
+            }
+        }
+        if (!message) {
+            if (response === null || response === void 0 ? void 0 : response.statusText) {
+                message = "HTTP ".concat(status_1, ": ").concat(response.statusText);
+            }
+            else if (error.message && !error.message.startsWith('Request failed with status code')) {
+                message = error.message;
+            }
+            else if (status_1) {
+                message = "Request failed with status code ".concat(status_1);
+            }
+            else if (error.message) {
+                message = error.message;
+            }
+            else {
+                message = 'An unexpected error occurred during API request';
+            }
+        }
+        return new ScrymeSDKError(message, {
+            status: status_1,
+            code: code,
+            data: responseData,
+            rawError: error,
+        });
+    }
+    if (error instanceof Error) {
+        return new ScrymeSDKError(error.message, {
+            rawError: error,
+        });
+    }
+    return new ScrymeSDKError(typeof error === 'string' ? error : 'An unexpected error occurred', {
+        rawError: error,
+    });
+}
 export var AXIOS_INSTANCE = axios.create({
     baseURL: getBaseURL(),
     timeout: 10000,
     withCredentials: true,
 });
+AXIOS_INSTANCE.interceptors.response.use(function (response) { return response; }, function (error) { return Promise.reject(parseSDKError(error)); });
 AXIOS_INSTANCE.interceptors.request.use(function (config) {
     if (!config.baseURL) {
         config.baseURL = getBaseURL();
@@ -118,9 +222,13 @@ export var customInstance = function (config, options) {
     var source = axios.CancelToken.source();
     // Merge headers carefully so that options.headers does not overwrite config.headers completely
     var mergedHeaders = __assign(__assign({}, config.headers), options === null || options === void 0 ? void 0 : options.headers);
-    var promise = AXIOS_INSTANCE(__assign(__assign(__assign({}, config), options), { headers: mergedHeaders, cancelToken: source.token })).then(function (_a) {
+    var promise = AXIOS_INSTANCE(__assign(__assign(__assign({}, config), options), { headers: mergedHeaders, cancelToken: source.token }))
+        .then(function (_a) {
         var data = _a.data;
         return data;
+    })
+        .catch(function (error) {
+        throw parseSDKError(error);
     });
     // @ts-ignore
     promise.cancel = function () {