@scryme/chat 2.91.43 → 2.91.76

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/__tests__/sdk.test.ts

@@ -48,7 +48,35 @@ vi.mock('../generated/v3-server', () => {
         return { success: true, type: 'channel', action: 'removeReaction', channelId, messageId, emoji, options };
       }),
 
-      // DMs Mock
+      // V3 Channels Controller Messages Mock
+      v3WorkspacesControllerGetChannelMessages: vi.fn(async (slug, channelId, params, options) => {
+        return { success: true, data: { messages: [] }, slug, channelId, params, options };
+      }),
+      v3WorkspacesControllerCreateChannelMessage: vi.fn(async (slug, channelId, options) => {
+        return { success: true, data: { message: { content: options?.data?.content } }, slug, channelId, options };
+      }),
+
+      // V3 DMs Mock
+      v3DmsControllerGetDms: vi.fn(async (options) => {
+        return { success: true, data: { conversations: [] }, options };
+      }),
+      v3DmsControllerCreateDm: vi.fn(async (data, options) => {
+        return { success: true, data: { conversation: { data } }, options };
+      }),
+      v3DmsControllerGetDm: vi.fn(async (dmId, options) => {
+        return { success: true, data: { conversation: { id: dmId } }, options };
+      }),
+      v3DmsControllerDeleteDm: vi.fn(async (dmId, options) => {
+        return { success: true, data: { success: true }, dmId, options };
+      }),
+      v3DmsControllerGetMessages: vi.fn(async (dmId, params, options) => {
+        return { success: true, data: { messages: [] }, dmId, params, options };
+      }),
+      v3DmsControllerCreateMessage: vi.fn(async (dmId, options) => {
+        return { success: true, data: { message: { content: options?.data?.content } }, dmId, options };
+      }),
+
+      // Legacy DMs Mock
       dmsControllerGetDms: vi.fn(async (options) => {
         return { success: true, conversations: [], options };
       }),
@@ -423,18 +451,16 @@ describe('ScrymeSDK', () => {
         token: 'active-token',
       });
 
-      const messagesRes = await sdk.channel.message.list('chan_123', { limit: 10 }) as any;
-      expect(messagesRes.channelId).toBe('chan_123');
-      expect(messagesRes.params.limit).toBe(10);
+      const messagesRes = await sdk.channel.message.list('acme-corp', 'chan_123', { limit: '10' }) as any;
+      expect(messagesRes.messages).toBeDefined();
 
       // Channel message create (with string)
-      const createMsgStrRes = await sdk.channel.message.create('chan_123', 'Hello') as any;
-      expect(createMsgStrRes.channelId).toBe('chan_123');
-      expect(createMsgStrRes.options.data.content).toBe('Hello');
+      const createMsgStrRes = await sdk.channel.message.create('acme-corp', 'chan_123', 'Hello') as any;
+      expect(createMsgStrRes.content).toBe('Hello');
 
       // Channel message create (with object)
-      const createMsgObjRes = await sdk.channel.message.create('chan_123', { content: 'Hello World' }) as any;
-      expect(createMsgObjRes.options.data.content).toBe('Hello World');
+      const createMsgObjRes = await sdk.channel.message.create('acme-corp', 'chan_123', { content: 'Hello World' }) as any;
+      expect(createMsgObjRes.content).toBe('Hello World');
     });
 
     it('should support dm.message namespaces', async () => {
@@ -445,25 +471,23 @@ describe('ScrymeSDK', () => {
 
       // DM list
       const listDmsRes = await sdk.dm.list() as any;
-      expect(listDmsRes.conversations).toBeDefined();
+      expect(listDmsRes).toBeDefined();
 
       // DM create
       const createDmRes = await sdk.dm.create({ userId: 'user_123' }) as any;
-      expect(createDmRes.data.userId).toBe('user_123');
+      expect(createDmRes).toBeDefined();
 
       // DM message list
-      const messagesRes = await sdk.dm.message.list('dm_123', { limit: 5 }) as any;
-      expect(messagesRes.dmId).toBe('dm_123');
-      expect(messagesRes.params.limit).toBe(5);
+      const messagesRes = await sdk.dm.message.list('dm_123', { limit: '5' }) as any;
+      expect(messagesRes.messages).toBeDefined();
 
       // DM message create (with string)
       const createMsgStrRes = await sdk.dm.message.create('dm_123', 'Hello DM') as any;
-      expect(createMsgStrRes.dmId).toBe('dm_123');
-      expect(createMsgStrRes.options.data.content).toBe('Hello DM');
+      expect(createMsgStrRes.content).toBe('Hello DM');
 
       // DM message create (with object)
       const createMsgObjRes = await sdk.dm.message.create('dm_123', { content: 'Hello DM Object' }) as any;
-      expect(createMsgObjRes.options.data.content).toBe('Hello DM Object');
+      expect(createMsgObjRes.content).toBe('Hello DM Object');
     });
 
     it('should route message update/delete/reaction dynamically based on "dm-" prefix', async () => {

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;