@qelos/sdk 3.8.1 → 3.8.3

package/test/base-sdk-exceptions.test.ts

@@ -0,0 +1,197 @@
+import * as assert from 'node:assert/strict';
+import { test } from 'node:test';
+import BaseSDK from '../src/base-sdk';
+import { QelosSDKOptions } from '../src/types';
+
+/**
+ * Tests for BaseSDK exception handling in callJsonApi method
+ * 
+ * These tests verify that the BaseSDK correctly handles various error scenarios:
+ * - Errors during initial API call
+ * - Errors during response parsing
+ * - Errors during token refresh
+ * - Errors when calling onFailedRefreshToken
+ * - Non-JSON responses with error status
+ */
+test('BaseSDK exception handling', async (t) => {
+  // Mock response factory to simulate different responses
+  const createMockResponse = (status: number, data: any, contentType = 'application/json') => {
+    const body = typeof data === 'string' ? data : JSON.stringify(data);
+    const res = new Response(body);
+    Object.defineProperty(res, 'status', { value: status });
+    Object.defineProperty(res, 'ok', { value: status >= 200 && status < 300 });
+    res.headers.set('Content-Type', contentType);
+    return res;
+  };
+
+  // Setup function to create BaseSDK instances with different configurations
+  const setup = (config: {
+    failInitialCall?: boolean;
+    failExtraHeaders?: boolean;
+    failRefreshToken?: boolean;
+    failOnFailedRefreshToken?: boolean;
+    invalidJsonResponse?: boolean;
+    nonJsonErrorResponse?: boolean;
+    forceRefresh?: boolean;
+  } = {}) => {
+    // Mock fetch function that returns different responses based on configuration
+    const mockFetch = async (input: RequestInfo, init?: RequestInit) => {
+      const url = input.toString();
+      // Simulate network failure for initial API call
+      if (config.failInitialCall) {
+        throw new Error('Network error');
+      }
+
+      // Return different responses based on URL and configuration
+      if (url.includes('/api/test-endpoint')) {
+        if (config.invalidJsonResponse) {
+          return createMockResponse(200, '{invalid-json}', 'application/json');
+        }
+        if (config.nonJsonErrorResponse) {
+          return createMockResponse(400, 'Bad request error message', 'text/plain');
+        }
+        return createMockResponse(401, { error: 'Unauthorized' });
+      }
+
+      if (url.includes('/api/token/refresh')) {
+        if (config.failRefreshToken) {
+          return createMockResponse(401, { error: 'Invalid refresh token' });
+        }
+        return createMockResponse(200, {
+          payload: {
+            token: 'new-access-token',
+            refreshToken: 'new-refresh-token',
+            user: { _id: 'user123', username: 'testuser' }
+          }
+        });
+      }
+
+      return createMockResponse(404, { error: 'Not found' });
+    };
+
+    // Create extraHeaders function based on configuration
+    const extraHeaders = async (relativeUrl: string, forceRefresh = false): Promise<{ [key: string]: string }> => {
+      if (config.failExtraHeaders) {
+        throw new Error('could not get extra headers');
+      }
+      // For token refresh tests, don't return authorization header if it's a refresh attempt
+      if (forceRefresh && config.failRefreshToken) {
+        return {}; // Empty object but still conforms to the expected return type
+      }
+      return { authorization: 'Bearer test-token' };
+    };
+
+    // Create onFailedRefreshToken function based on configuration
+    const onFailedRefreshToken = async () => {
+      if (config.failOnFailedRefreshToken) {
+        throw new Error('Failed to handle refresh token');
+      }
+    };
+
+    // Initialize SDK options
+    const options: QelosSDKOptions = {
+      appUrl: 'http://localhost:3000',
+      fetch: mockFetch,
+      extraHeaders,
+      forceRefresh: config.forceRefresh !== false,
+      onFailedRefreshToken: config.failOnFailedRefreshToken !== undefined ? onFailedRefreshToken : undefined
+    };
+
+    return new BaseSDK(options);
+  };
+
+  await t.test('should handle network errors during initial API call', async () => {
+    const sdk = setup({ failInitialCall: true });
+
+    try {
+      await sdk.callJsonApi('/api/test-endpoint');
+      assert.fail('Should have thrown an error for network failure');
+    } catch (error) {
+      assert.ok(error instanceof Error);
+      assert.equal(error.message, 'Network error');
+    }
+  });
+
+  await t.test('should handle errors during extraHeaders call', async () => {
+    const sdk = setup({ failExtraHeaders: true });
+
+    try {
+      await sdk.callJsonApi('/api/test-endpoint');
+      assert.fail('Should have thrown an error for extraHeaders failure');
+    } catch (error) {
+      assert.ok(error instanceof Error);
+      // The BaseSDK implementation will try to refresh the token when extraHeaders fails
+      // and then throw 'could not able to refresh token' if no onFailedRefreshToken is provided
+      assert.equal(error.message, 'could not able to refresh token');
+    }
+  });
+
+  await t.test('should handle failed token refresh', async () => {
+    const sdk = setup({ failRefreshToken: true, forceRefresh: true });
+
+    try {
+      await sdk.callJsonApi('/api/test-endpoint');
+      assert.fail('Should have thrown an error when token refresh fails');
+    } catch (error) {
+      assert.ok(error instanceof Error);
+      // When token refresh fails and no onFailedRefreshToken is provided
+      assert.equal(error.message, 'could not able to refresh token');
+    }
+  });
+
+  await t.test('should handle errors in onFailedRefreshToken callback', async () => {
+    const sdk = setup({ 
+      failRefreshToken: true, 
+      failOnFailedRefreshToken: true,
+      forceRefresh: true 
+    });
+
+    try {
+      await sdk.callJsonApi('/api/test-endpoint');
+      assert.fail('Should have thrown an error when onFailedRefreshToken fails');
+    } catch (error) {
+      assert.ok(error instanceof Error);
+      assert.equal(error.message, 'could not handle failed refresh token');
+    }
+  });
+
+  await t.test('should handle invalid JSON responses', async () => {
+    const sdk = setup({ invalidJsonResponse: true });
+
+    try {
+      await sdk.callJsonApi('/api/test-endpoint');
+      assert.fail('Should have thrown an error for invalid JSON');
+    } catch (error) {
+      assert.ok(error instanceof Error);
+      assert.ok(error.message.includes('JSON'));
+    }
+  });
+
+  await t.test('should handle non-JSON error responses', async () => {
+    const sdk = setup({ nonJsonErrorResponse: true });
+
+    try {
+      await sdk.callJsonApi('/api/test-endpoint');
+      assert.fail('Should have thrown an error for non-JSON error response');
+    } catch (error) {
+      assert.ok(error instanceof Error);
+      assert.equal(error.message, 'Bad request error message');
+    }
+  });
+
+  await t.test('should handle errors during token refresh after extraHeaders error', async () => {
+    const sdk = setup({ 
+      failExtraHeaders: true,
+      failRefreshToken: true,
+      forceRefresh: true 
+    });
+
+    try {
+      await sdk.callJsonApi('/api/test-endpoint');
+      assert.fail('Should have thrown an error');
+    } catch (error) {
+      assert.ok(error instanceof Error);
+      assert.equal(error.message, 'could not able to refresh token');
+    }
+  });
+});

package/test/base-sdk.test.ts

@@ -0,0 +1,80 @@
+import * as assert from 'node:assert/strict';
+import { test } from 'node:test';
+import BaseSDK from '../src/base-sdk';
+import { QelosSDKOptions } from '../src/types';
+
+test('BaseSDK', async (t) => {
+  let options: QelosSDKOptions;
+  let sdk: BaseSDK;
+  let fetchCalls: Array<[string, RequestInit]> = [];
+
+  // Setup before each test
+  const setup = () => {
+    fetchCalls = [];
+    // Initialize SDK with mocked fetch function
+    options = {
+      appUrl: 'http://localhost:3000',
+      fetch: async (url, init) => {
+        fetchCalls.push([url.toString(), init]);
+        const res = new Response(JSON.stringify({ success: true }));
+        res.headers.set('Content-Type', 'application/json');
+        return res;
+      },
+      extraHeaders: async () => ({
+        'x-test-header': 'test-value'
+      })
+    };
+
+    sdk = new BaseSDK(options);
+  };
+
+  await t.test('should normalize appUrl by removing trailing slash', () => {
+    setup();
+    const optionsWithTrailingSlash = {
+      ...options,
+      appUrl: 'http://localhost:3000/'
+    };
+    const sdkWithTrailingSlash = new BaseSDK(optionsWithTrailingSlash);
+    
+    return sdkWithTrailingSlash.callApi('/test').then(() => {
+      assert.equal(fetchCalls[0][0], 'http://localhost:3000/test');
+    });
+  });
+
+  await t.test('should call API with correct URL and headers', () => {
+    setup();
+    return sdk.callApi('/test').then(() => {
+      assert.equal(fetchCalls[0][0], 'http://localhost:3000/test');
+      assert.equal(fetchCalls[0][1].headers['x-test-header'], 'test-value');
+    });
+  });
+
+  await t.test('should parse JSON response correctly', () => {
+    setup();
+    return sdk.callJsonApi('/test').then(data => {
+      assert.deepEqual(data, { success: true });
+    });
+  });
+
+  await t.test('should handle query parameters correctly', () => {
+    setup();
+    const params = { foo: 'bar', baz: 'qux' };
+    const queryString = sdk.getQueryParams(params);
+    assert.equal(queryString, '?foo=bar&baz=qux');
+  });
+
+  await t.test('should handle empty query parameters', () => {
+    setup();
+    const queryString = sdk.getQueryParams();
+    assert.equal(queryString, '');
+  });
+
+  await t.test('should handle extraQueryParams option', () => {
+    setup();
+    options.extraQueryParams = () => ({ global: 'param' });
+    const sdkWithExtraParams = new BaseSDK(options);
+    
+    const queryString = sdkWithExtraParams.getQueryParams({ local: 'param' });
+    assert.equal(queryString, '?global=param&local=param');
+  });
+});

package/test/index.test.ts

@@ -0,0 +1,85 @@
+import * as assert from 'node:assert/strict';
+import { test } from 'node:test';
+import QelosSDK from '../src/index';
+import { QelosSDKOptions } from '../src/types';
+
+test('QelosSDK', async (t) => {
+  let options: QelosSDKOptions;
+  let sdk: QelosSDK;
+
+  // Setup before each test
+  const setup = () => {
+    // Initialize SDK with mocked options
+    options = {
+      appUrl: 'http://localhost:3000',
+      fetch: async () => {
+        const res = new Response(JSON.stringify({ success: true }));
+        res.headers.set('Content-Type', 'application/json');
+        return res;
+      },
+      refreshToken: 'mock-refresh-token'
+    };
+
+    sdk = new QelosSDK(options);
+  };
+
+  await t.test('should initialize QelosSDK with all required properties', () => {
+    setup();
+    assert.ok(sdk);
+    assert.ok(sdk.blocks);
+    assert.ok(sdk.layouts);
+    assert.ok(sdk.appConfigurations);
+    assert.ok(sdk.authentication);
+    assert.ok(sdk.workspaces);
+    assert.ok(sdk.invites);
+    assert.ok(sdk.blueprints);
+  });
+
+  await t.test('should set and remove custom headers', async () => {
+    setup();
+    // Mock the authentication.accessToken to prevent token-related errors
+    Object.defineProperty(sdk.authentication, 'accessToken', {
+      get: () => 'mock-access-token'
+    });
+    
+    // Set a custom header
+    sdk.setCustomHeader('x-test-header', 'test-value');
+    
+    // Test that the header is included in extraHeaders
+    const headersWithCustom = await options.extraHeaders('/api/test');
+    assert.equal(headersWithCustom['x-test-header'], 'test-value');
+
+    // Remove the custom header
+    sdk.removeCustomHeader('x-test-header');
+    
+    // Test that the header is no longer included
+    const headersWithoutCustom = await options.extraHeaders('/api/test');
+    assert.equal(headersWithoutCustom['x-test-header'], undefined);
+  });
+
+  await t.test('should not include authorization header for specific URLs', async () => {
+    setup();
+    // Test URLs that should not have authorization headers
+    const noAuthUrls = [
+      '/api/token/refresh',
+      '/api/signin',
+      '/api/signup'
+    ];
+
+    for (const url of noAuthUrls) {
+      const headers = await options.extraHeaders(url);
+      assert.equal(headers.authorization, undefined);
+    }
+  });
+
+  await t.test('should include authorization header for regular URLs', async () => {
+    setup();
+    // Mock the authentication.accessToken
+    Object.defineProperty(sdk.authentication, 'accessToken', {
+      get: () => 'mock-access-token'
+    });
+
+    const headers = await options.extraHeaders('/api/regular-endpoint');
+    assert.equal(headers.authorization, 'Bearer mock-access-token');
+  });
+});

package/test/qelos-sdk-edge-cases.test.ts

@@ -0,0 +1,301 @@
+import { test } from 'node:test';
+import * as assert from 'node:assert';
+import QelosSDK from '../src';
+import { QelosSDKOptions } from '../src/types';
+import { FetchLike } from '../src/types';
+
+type ApiCall = {
+  url: string;
+  init?: RequestInit;
+};
+
+const apiCalls: ApiCall[] = [];
+
+// Create a simplified mock Response that works with our SDK
+function createMockResponse(status: number, body: any, headers: Record<string, string> = {}): Response {
+  const defaultHeaders = {
+    'Content-Type': 'application/json',
+    ...headers
+  };
+  
+  // Create a partial Response object with just the properties we need
+  const mockResponse = {
+    status,
+    ok: status >= 200 && status < 300,
+    headers: {
+      get: (name: string) => defaultHeaders[name.toLowerCase()] || null
+    },
+    json: async () => body,
+    text: async () => JSON.stringify(body),
+    redirected: false,
+    statusText: status === 200 ? 'OK' : 'Error',
+    type: 'basic' as ResponseType,
+    url: '',
+    bodyUsed: false
+  };
+  
+  // Cast to Response type - this is safe for our tests since we only use these properties
+  return mockResponse as unknown as Response;
+}
+
+function setup(options: {
+  networkFailure?: boolean;
+  malformedResponse?: boolean;
+  concurrentRequests?: boolean;
+  nonJsonResponse?: boolean;
+  raceCondition?: boolean;
+  retryTransient?: boolean;
+  statusCode?: number;
+} = {}) {
+  apiCalls.length = 0;
+  let tokenRefreshInProgress = false;
+  let tokenRefreshCompleted = false;
+  let requestCount = 0;
+  
+  const mockFetch: FetchLike = async (url: string, init?: RequestInit) => {
+    apiCalls.push({ url: url.toString(), init });
+    
+    // Simulate network failure
+    if (options.networkFailure) {
+      throw new Error('Network error');
+    }
+    
+    // Simulate race condition during token refresh
+    if (options.raceCondition && url.toString().includes('/api/test-endpoint')) {
+      if (tokenRefreshInProgress && !tokenRefreshCompleted) {
+        // This simulates a request that happens during token refresh
+        return createMockResponse(401, { error: 'Unauthorized during refresh' });
+      }
+    }
+    
+    if (url.toString().includes('/api/token/refresh')) {
+      tokenRefreshInProgress = true;
+      
+      // Simulate a delay in token refresh
+      if (options.raceCondition) {
+        await new Promise(resolve => setTimeout(resolve, 50));
+      }
+      
+      tokenRefreshCompleted = true;
+      
+      return createMockResponse(200, {
+        payload: {
+          token: 'new-access-token',
+          refreshToken: 'new-refresh-token',
+          user: { _id: 'user123', username: 'testuser' }
+        }
+      });
+    }
+    
+    if (url.toString().includes('/api/test-endpoint')) {
+      requestCount++;
+      
+      // For testing retrying transient errors
+      if (options.retryTransient && requestCount === 1) {
+        return createMockResponse(503, { error: 'Service Unavailable' });
+      }
+      
+      // For testing specific status codes
+      if (options.statusCode) {
+        return createMockResponse(options.statusCode, { error: `Status code ${options.statusCode}` });
+      }
+      
+      // For the first request, return 401 to trigger token refresh
+      if (requestCount === 1) {
+        return createMockResponse(401, { error: 'Unauthorized' });
+      }
+      
+      // For malformed response test
+      if (options.malformedResponse) {
+        const headers = options.nonJsonResponse 
+          ? { 'Content-Type': 'text/plain' }
+          : { 'Content-Type': 'application/json' };
+        
+        // Create a malformed response that will cause JSON parsing to fail
+        const malformedResponse = createMockResponse(200, {});
+        // Override the json method to throw an error
+        Object.defineProperty(malformedResponse, 'json', {
+          value: async () => { throw new Error('Invalid JSON'); }
+        });
+        // Override the text method to return invalid JSON
+        Object.defineProperty(malformedResponse, 'text', {
+          value: async () => options.nonJsonResponse ? 'Not a JSON response' : '{malformed json'
+        });
+        
+        return malformedResponse;
+      }
+      
+      // Normal successful response
+      return createMockResponse(200, { success: true, data: 'test data' });
+    }
+    
+    return createMockResponse(404, { error: 'Not found' });
+  };
+  
+  const sdkOptions: QelosSDKOptions = {
+    appUrl: 'http://localhost:3000',
+    fetch: mockFetch,
+    refreshToken: 'initial-refresh-token',
+    accessToken: 'initial-access-token',
+    forceRefresh: true
+  };
+  
+  const sdk = new QelosSDK(sdkOptions);
+  
+  return {
+    sdk,
+    sdkOptions,
+    requestCount
+  };
+}
+
+test('QelosSDK edge cases', async (t) => {
+  await t.test('should handle network failures gracefully', async () => {
+    const { sdk } = setup({ networkFailure: true });
+    
+    try {
+      await sdk.appConfigurations.callJsonApi('/api/test-endpoint');
+      assert.fail('Should have thrown a network error');
+    } catch (error) {
+      assert.ok(error instanceof Error);
+      assert.ok(
+        error.message.includes('Network error'),
+        `Error should be network related, got: ${error.message}`
+      );
+    }
+  });
+  
+  await t.test('should handle malformed JSON responses', async () => {
+    const { sdk } = setup({ malformedResponse: true });
+    
+    try {
+      await sdk.appConfigurations.callJsonApi('/api/test-endpoint');
+      assert.fail('Should have thrown an error for malformed JSON');
+    } catch (error) {
+      assert.ok(error instanceof Error);
+    }
+  });
+  
+  await t.test('should handle non-JSON responses correctly', async () => {
+    const { sdk } = setup({ nonJsonResponse: true, malformedResponse: true });
+    
+    try {
+      await sdk.appConfigurations.callJsonApi('/api/test-endpoint');
+      assert.fail('Should have thrown an error for non-JSON response');
+    } catch (error) {
+      assert.ok(error instanceof Error);
+    }
+  });
+  
+  await t.test('should handle various HTTP status codes appropriately', async () => {
+    // Test a range of status codes - we'll test these individually
+    const statusCodes = [400, 403, 404, 500, 502, 503];
+    
+    for (const statusCode of statusCodes) {
+      // For each status code, we need a fresh setup
+      apiCalls.length = 0;
+      
+      // Create a custom mock fetch that directly returns the status code we want to test
+      // This bypasses the token refresh logic which complicates testing
+      const mockFetch: FetchLike = async (url: string, init?: RequestInit) => {
+        apiCalls.push({ url: url.toString(), init });
+        return createMockResponse(statusCode, { error: `Error with status code ${statusCode}` });
+      };
+      
+      const options: QelosSDKOptions = {
+        appUrl: 'http://localhost:3000',
+        fetch: mockFetch,
+        refreshToken: 'test-refresh-token',
+        accessToken: 'test-access-token',
+        // Disable token refresh for this test to focus on status code handling
+        forceRefresh: false
+      };
+      
+      const sdk = new QelosSDK(options);
+      
+      try {
+        await sdk.appConfigurations.callJsonApi('/api/test-endpoint');
+        assert.fail(`Should have thrown an error for status code ${statusCode}`);
+      } catch (error) {
+        assert.ok(error instanceof Error, `Error should be an instance of Error for status ${statusCode}`);
+        // The SDK might wrap the error, so we just verify we got an error
+        assert.ok(error.message, `Error should have a message for status ${statusCode}`);
+      }
+    }
+  });
+  
+  await t.test('should handle URL encoding in query parameters', async () => {
+    const { sdk } = setup();
+    
+    // Create complex query parameters with special characters
+    const complexQuery = {
+      'complex key': 'value with spaces',
+      'special&chars': 'value+with&special=chars',
+      'array': ['value1', 'value2'],
+      'unicode': 'üñîçødé',
+      'empty': '',
+      'null': null
+    };
+    
+    // Reset API calls
+    apiCalls.length = 0;
+    
+    // Make a request with complex query parameters
+    try {
+      // Since RequestInit doesn't have a query property, we need to manually construct the URL
+      // Convert the complex query object to a format URLSearchParams can handle
+      const queryParams: Record<string, string> = {};
+      Object.entries(complexQuery).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          // Convert arrays to comma-separated strings
+          queryParams[key] = value.join(',');
+        } else if (value === null) {
+          queryParams[key] = '';
+        } else {
+          queryParams[key] = String(value);
+        }
+      });
+      const queryString = new URLSearchParams(queryParams).toString();
+      await sdk.appConfigurations.callJsonApi(`/api/test-endpoint?${queryString}`, {
+        method: 'GET'
+      });
+    } catch (error) {
+      // We expect this to fail with 401 and then retry, but we're just checking the URL encoding
+    }
+    
+    // Check that the URL was properly encoded
+    const firstCall = apiCalls[0];
+    assert.ok(firstCall.url.includes('/api/test-endpoint'), 'URL should include the endpoint');
+    
+    // Verify that special characters are properly encoded
+    assert.ok(firstCall.url.includes('complex+key='), 'Should encode spaces in keys');
+    assert.ok(firstCall.url.includes('value+with+spaces'), 'Should encode spaces in values');
+    assert.ok(firstCall.url.includes('special%26chars='), 'Should encode & in keys');
+    assert.ok(firstCall.url.includes('value%2Bwith%26special%3Dchars'), 'Should encode special chars in values');
+    assert.ok(firstCall.url.includes('%C3%BC%C3%B1%C3%AE%C3%A7%C3%B8d%C3%A9'), 'Should encode unicode characters');
+  });
+  
+  await t.test('should handle concurrent requests during token refresh', async () => {
+    const { sdk } = setup({ raceCondition: true });
+    
+    // Reset API calls
+    apiCalls.length = 0;
+    
+    // Make two concurrent requests
+    const request1 = sdk.appConfigurations.callJsonApi('/api/test-endpoint');
+    const request2 = sdk.appConfigurations.callJsonApi('/api/test-endpoint');
+    
+    // Wait for both requests to complete
+    const results = await Promise.allSettled([request1, request2]);
+    
+    // At least one request should succeed
+    assert.ok(
+      results.some(result => result.status === 'fulfilled'),
+      'At least one request should succeed'
+    );
+    
+    // Check that token refresh was only called once
+    const refreshCalls = apiCalls.filter(call => call.url.includes('/api/token/refresh'));
+    assert.ok(refreshCalls.length >= 1, 'Token refresh should be called at least once');
+  });
+});