@scryme/chat 2.91.61 → 2.91.87

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 () {

package/dist/sdk.js

@@ -55,7 +55,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import axios from 'axios';
-import { setGlobalToken } from './custom-instance';
+import { setGlobalToken, parseSDKError } from './custom-instance';
 import { getSkyrmeChatAPI } from './generated/v3-server';
 /**
  * The primary client SDK class for accessing the Scryme Chat platform APIs.
@@ -173,7 +173,7 @@ var ScrymeSDK = /** @class */ (function () {
                     case 3:
                         error_1 = _e.sent();
                         console.error('ScrymeSDK failed to authenticate via client_credentials:', error_1);
-                        throw error_1;
+                        throw parseSDKError(error_1);
                     case 4: return [2 /*return*/, this.token];
                 }
             });
@@ -217,7 +217,7 @@ var ScrymeSDK = /** @class */ (function () {
                                 args[_i] = arguments[_i];
                             }
                             return __awaiter(_this, void 0, void 0, function () {
-                                var config, arity, cleanArgs, lastArg, isLastArgOptions, userOptions;
+                                var config, arity, cleanArgs, lastArg, isLastArgOptions, userOptions, error_2;
                                 return __generator(this, function (_a) {
                                     switch (_a.label) {
                                         case 0: return [4 /*yield*/, this.getRequestConfig()];
@@ -242,7 +242,15 @@ var ScrymeSDK = /** @class */ (function () {
                                                 }
                                                 cleanArgs.push(config);
                                             }
-                                            return [2 /*return*/, originalMethod.apply(void 0, cleanArgs)];
+                                            _a.label = 2;
+                                        case 2:
+                                            _a.trys.push([2, 4, , 5]);
+                                            return [4 /*yield*/, originalMethod.apply(void 0, cleanArgs)];
+                                        case 3: return [2 /*return*/, _a.sent()];
+                                        case 4:
+                                            error_2 = _a.sent();
+                                            throw parseSDKError(error_2);
+                                        case 5: return [2 /*return*/];
                                     }
                                 });
                             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scryme/chat",
-  "version": "2.91.61",
+  "version": "2.91.87",
   "private": false,
   "publishConfig": {
     "access": "public"

package/src/__tests__/sdk-error.test.ts

@@ -0,0 +1,229 @@
+import { describe, it, expect, vi } from 'vitest';
+import axios, { AxiosError } from 'axios';
+import { ScrymeSDKError, ScrymeError, parseSDKError } from '../custom-instance';
+import { ScrymeSDK } from '../sdk';
+
+describe('ScrymeSDKError & parseSDKError', () => {
+  it('should construct ScrymeSDKError with status, code, data, and rawError', () => {
+    const rawErr = new Error('Raw');
+    const err = new ScrymeSDKError('Something went wrong', {
+      status: 400,
+      code: 'BAD_REQUEST',
+      data: { details: 'Invalid field' },
+      rawError: rawErr,
+    });
+
+    expect(err).toBeInstanceOf(Error);
+    expect(err).toBeInstanceOf(ScrymeSDKError);
+    expect(err).toBeInstanceOf(ScrymeError);
+    expect(err.name).toBe('ScrymeSDKError');
+    expect(err.message).toBe('Something went wrong');
+    expect(err.status).toBe(400);
+    expect(err.code).toBe('BAD_REQUEST');
+    expect(err.data).toEqual({ details: 'Invalid field' });
+    expect(err.rawError).toBe(rawErr);
+  });
+
+  it('should return existing ScrymeSDKError as is', () => {
+    const original = new ScrymeSDKError('Already parsed');
+    const result = parseSDKError(original);
+    expect(result).toBe(original);
+  });
+
+  it('should parse NestJS validation error arrays into joined message', () => {
+    const axiosError = new AxiosError(
+      'Request failed with status code 400',
+      'ERR_BAD_REQUEST',
+      undefined,
+      {},
+      {
+        status: 400,
+        statusText: 'Bad Request',
+        headers: {},
+        config: {} as any,
+        data: {
+          statusCode: 400,
+          error: 'Bad Request',
+          message: ['email must be an email', 'password is too short'],
+        },
+      }
+    );
+
+    const parsed = parseSDKError(axiosError);
+    expect(parsed).toBeInstanceOf(ScrymeSDKError);
+    expect(parsed.message).toBe('email must be an email; password is too short');
+    expect(parsed.status).toBe(400);
+    expect(parsed.code).toBe('ERR_BAD_REQUEST');
+    expect(parsed.data).toEqual({
+      statusCode: 400,
+      error: 'Bad Request',
+      message: ['email must be an email', 'password is too short'],
+    });
+  });
+
+  it('should parse standard NestJS error response with string message', () => {
+    const axiosError = new AxiosError(
+      'Request failed with status code 404',
+      'ERR_BAD_REQUEST',
+      undefined,
+      {},
+      {
+        status: 404,
+        statusText: 'Not Found',
+        headers: {},
+        config: {} as any,
+        data: {
+          statusCode: 404,
+          error: 'Not Found',
+          message: "Workspace 'acme' not found",
+        },
+      }
+    );
+
+    const parsed = parseSDKError(axiosError);
+    expect(parsed.message).toBe("Workspace 'acme' not found");
+    expect(parsed.status).toBe(404);
+  });
+
+  it('should parse error object format { error: "Unauthorized" }', () => {
+    const axiosError = new AxiosError(
+      'Request failed with status code 401',
+      'ERR_BAD_REQUEST',
+      undefined,
+      {},
+      {
+        status: 401,
+        statusText: 'Unauthorized',
+        headers: {},
+        config: {} as any,
+        data: {
+          error: 'Invalid session token',
+        },
+      }
+    );
+
+    const parsed = parseSDKError(axiosError);
+    expect(parsed.message).toBe('Invalid session token');
+    expect(parsed.status).toBe(401);
+  });
+
+  it('should parse nested error object format { error: { message: "Token expired" } }', () => {
+    const axiosError = new AxiosError(
+      'Request failed with status code 401',
+      'ERR_BAD_REQUEST',
+      undefined,
+      {},
+      {
+        status: 401,
+        statusText: 'Unauthorized',
+        headers: {},
+        config: {} as any,
+        data: {
+          error: {
+            message: 'Token expired',
+            code: 'TOKEN_EXPIRED',
+          },
+        },
+      }
+    );
+
+    const parsed = parseSDKError(axiosError);
+    expect(parsed.message).toBe('Token expired');
+    expect(parsed.status).toBe(401);
+  });
+
+  it('should parse string response data', () => {
+    const axiosError = new AxiosError(
+      'Request failed with status code 502',
+      'ERR_BAD_GATEWAY',
+      undefined,
+      {},
+      {
+        status: 502,
+        statusText: 'Bad Gateway',
+        headers: {},
+        config: {} as any,
+        data: 'Bad Gateway Error from Upstream',
+      }
+    );
+
+    const parsed = parseSDKError(axiosError);
+    expect(parsed.message).toBe('Bad Gateway Error from Upstream');
+    expect(parsed.status).toBe(502);
+  });
+
+  it('should handle network errors without response object', () => {
+    const axiosError = new AxiosError(
+      'Network Error',
+      'ERR_NETWORK',
+      undefined,
+      {},
+      undefined
+    );
+
+    const parsed = parseSDKError(axiosError);
+    expect(parsed.message).toBe('Network Error');
+    expect(parsed.status).toBeUndefined();
+    expect(parsed.code).toBe('ERR_NETWORK');
+  });
+
+  it('should handle timeout errors without response object', () => {
+    const axiosError = new AxiosError(
+      'timeout of 10000ms exceeded',
+      'ECONNABORTED',
+      undefined,
+      {},
+      undefined
+    );
+
+    const parsed = parseSDKError(axiosError);
+    expect(parsed.message).toBe('timeout of 10000ms exceeded');
+    expect(parsed.code).toBe('ECONNABORTED');
+  });
+
+  it('should handle standard non-Axios Error objects', () => {
+    const standardError = new TypeError('Failed to fetch');
+    const parsed = parseSDKError(standardError);
+
+    expect(parsed).toBeInstanceOf(ScrymeSDKError);
+    expect(parsed.message).toBe('Failed to fetch');
+  });
+
+  it('should handle primitive string errors', () => {
+    const parsed = parseSDKError('Custom error string');
+
+    expect(parsed).toBeInstanceOf(ScrymeSDKError);
+    expect(parsed.message).toBe('Custom error string');
+  });
+
+  it('should wrap M2M token fetch error into ScrymeSDKError', async () => {
+    const sdk = new ScrymeSDK({
+      baseURL: 'https://api.test.com',
+      clientId: 'invalid-id',
+      clientSecret: 'invalid-secret',
+    });
+
+    // Mock axios post failure
+    const postSpy = vi.spyOn(axios, 'post').mockRejectedValue(
+      new AxiosError('Request failed with status code 401', 'ERR_BAD_REQUEST', undefined, {}, {
+        status: 401,
+        statusText: 'Unauthorized',
+        headers: {},
+        config: {} as any,
+        data: { message: 'Invalid M2M client credentials' },
+      })
+    );
+
+    await expect(sdk.getOrFetchToken()).rejects.toThrow(ScrymeSDKError);
+
+    try {
+      await sdk.getOrFetchToken();
+    } catch (err: any) {
+      expect(err).toBeInstanceOf(ScrymeSDKError);
+      expect(err.message).toBe('Invalid M2M client credentials');
+      expect(err.status).toBe(401);
+    }
+
+    postSpy.mockRestore();
+  });
+});

package/src/custom-instance.ts

@@ -49,12 +49,115 @@ export const setGlobalToken = (token: string | null) => {
 
 export const getGlobalToken = () => globalToken;
 
+/**
+ * Custom SDK Error class for meaningful, developer-friendly error messages and structured error details.
+ */
+export class ScrymeSDKError extends Error {
+  public readonly status?: number;
+  public readonly code?: string;
+  public readonly data?: any;
+  public readonly rawError?: any;
+
+  constructor(
+    message: string,
+    options?: {
+      status?: number;
+      code?: string;
+      data?: any;
+      rawError?: any;
+    }
+  ) {
+    super(message);
+    this.name = 'ScrymeSDKError';
+    this.status = options?.status;
+    this.code = options?.code;
+    this.data = options?.data;
+    this.rawError = options?.rawError;
+
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export { ScrymeSDKError as ScrymeError };
+
+/**
+ * Parses any error (AxiosError, Error, or unknown object) into a clean, meaningful ScrymeSDKError.
+ */
+export function parseSDKError(error: any): ScrymeSDKError {
+  if (error instanceof ScrymeSDKError) {
+    return error;
+  }
+
+  if (axios.isAxiosError(error)) {
+    const response = error.response;
+    const status = response?.status;
+    const responseData = response?.data;
+    const code = error.code || (responseData && typeof responseData === 'object' ? responseData.code : undefined);
+
+    let message: string | undefined;
+
+    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?.statusText) {
+        message = `HTTP ${status}: ${response.statusText}`;
+      } else if (error.message && !error.message.startsWith('Request failed with status code')) {
+        message = error.message;
+      } else if (status) {
+        message = `Request failed with status code ${status}`;
+      } else if (error.message) {
+        message = error.message;
+      } else {
+        message = 'An unexpected error occurred during API request';
+      }
+    }
+
+    return new ScrymeSDKError(message, {
+      status,
+      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 const AXIOS_INSTANCE = axios.create({
   baseURL: getBaseURL(),
   timeout: 10000,
   withCredentials: true,
 });
 
+AXIOS_INSTANCE.interceptors.response.use(
+  response => response,
+  error => Promise.reject(parseSDKError(error))
+);
+
 AXIOS_INSTANCE.interceptors.request.use(config => {
   if (!config.baseURL) {
     config.baseURL = getBaseURL();
@@ -144,7 +247,11 @@ export const customInstance = <T>(
     ...options,
     headers: mergedHeaders,
     cancelToken: source.token,
-  }).then(({ data }) => data);
+  })
+    .then(({ data }) => data)
+    .catch(error => {
+      throw parseSDKError(error);
+    });
 
   // @ts-ignore
   promise.cancel = () => {
@@ -154,5 +261,5 @@ export const customInstance = <T>(
   return promise;
 };
 
-export type ErrorType<Error> = AxiosError<Error>;
+export type ErrorType<Error> = ScrymeSDKError;
 export type BodyType<Body> = Body;

package/src/sdk.ts

@@ -1,5 +1,5 @@
 import axios, { AxiosRequestConfig } from 'axios';
-import { setGlobalToken } from './custom-instance';
+import { setGlobalToken, parseSDKError } from './custom-instance';
 import { getSkyrmeChatAPI } from './generated/v3-server';
 import type {
   V3ProvisionWorkspaceDto,
@@ -724,7 +724,7 @@ export class ScrymeSDK {
         }
       } catch (error) {
         console.error('ScrymeSDK failed to authenticate via client_credentials:', error);
-        throw error;
+        throw parseSDKError(error);
       }
     }
 
@@ -788,7 +788,11 @@ export class ScrymeSDK {
               cleanArgs.push(config);
             }
 
-            return (originalMethod as (...a: unknown[]) => unknown)(...cleanArgs);
+            try {
+              return await (originalMethod as (...a: unknown[]) => unknown)(...cleanArgs);
+            } catch (error) {
+              throw parseSDKError(error);
+            }
           };
         }
         return originalMethod;