@superblocksteam/sabs-client 0.0.1-demo-databricks-deploy

package/src/errors.test.ts

@@ -0,0 +1,341 @@
+import {
+  BadRequestError,
+  InternalServerError,
+  NotFoundError,
+  ConflictError,
+  UnauthorizedError,
+  ForbiddenError,
+  HttpError,
+  createErrorFromStatusCode,
+  createClientError,
+  createNetworkError
+} from './errors';
+
+describe('errors', () => {
+  describe('HttpError for unhandled status codes', () => {
+    test('creates error with correct properties', () => {
+      const status = 418;
+      const message = 'I am a teapot';
+
+      const error = new HttpError(status, message);
+
+      expect(error).toBeInstanceOf(Error);
+      expect(error).toBeInstanceOf(HttpError);
+      expect(error.name).toBe('Error');
+      expect(error.message).toBe(message);
+      expect(error.status).toBe(status);
+      expect(error.title).toBeUndefined(); // HttpError doesn't set title by default
+    });
+
+    test('has consistent interface with other error types', () => {
+      const error = new HttpError(422, 'Test message');
+
+      expect(error.message).toBe('Test message');
+      expect(error.status).toBe(422);
+
+      // Should have the same interface as other HttpError types
+      expect('status' in error).toBe(true);
+      expect('message' in error).toBe(true);
+    });
+
+    test('has proper stack trace', () => {
+      const error = new HttpError(500, 'Test error');
+      expect(error.stack).toBeDefined();
+      expect(error.stack).toContain('Test error');
+    });
+  });
+
+  describe('createErrorFromStatusCode', () => {
+    test('creates BadRequestError for status 400', () => {
+      const message = 'Invalid request';
+      const error = createErrorFromStatusCode(400, message);
+
+      expect(error).toBeInstanceOf(BadRequestError);
+      expect(error.message).toBe('SABS API Error (400): Invalid request');
+    });
+
+    test('creates UnauthorizedError for status 401', () => {
+      const message = 'Invalid credentials';
+      const error = createErrorFromStatusCode(401, message);
+
+      expect(error).toBeInstanceOf(UnauthorizedError);
+      expect(error.message).toBe('SABS API Error (401): Invalid credentials');
+    });
+
+    test('creates ForbiddenError for status 403', () => {
+      const message = 'Access denied';
+      const error = createErrorFromStatusCode(403, message);
+
+      expect(error).toBeInstanceOf(ForbiddenError);
+      expect(error.message).toBe('SABS API Error (403): Access denied');
+    });
+
+    test('creates NotFoundError for status 404', () => {
+      const message = 'Resource not found';
+      const error = createErrorFromStatusCode(404, message);
+
+      expect(error).toBeInstanceOf(NotFoundError);
+      expect(error.message).toBe('SABS API Error (404): Resource not found');
+    });
+
+    test('creates ConflictError for status 409', () => {
+      const message = 'Resource conflict';
+      const error = createErrorFromStatusCode(409, message);
+
+      expect(error).toBeInstanceOf(ConflictError);
+      expect(error.message).toBe('SABS API Error (409): Resource conflict');
+    });
+
+    test.each([500, 502, 503, 504])('creates InternalServerError for status %s', (statusCode) => {
+      const message = 'Server error';
+      const error = createErrorFromStatusCode(statusCode, message);
+
+      expect(error).toBeInstanceOf(InternalServerError);
+      expect(error.message).toBe(`SABS API Error (${statusCode}): Server error`);
+    });
+
+    test('creates HttpError for unhandled status codes', () => {
+      const statusCode = 418; // I'm a teapot
+      const message = 'Teapot error';
+
+      const error = createErrorFromStatusCode(statusCode, message);
+
+      expect(error).toBeInstanceOf(HttpError);
+      expect(error.message).toBe('SABS API Error (418): Teapot error');
+
+      if (error instanceof HttpError) {
+        expect(error.status).toBe(statusCode);
+      }
+    });
+
+    test('handles edge case status codes', () => {
+      // Test some edge cases
+      const testCases = [
+        { status: 100, expected: HttpError },
+        { status: 200, expected: HttpError },
+        { status: 300, expected: HttpError },
+        { status: 451, expected: HttpError }, // Unavailable For Legal Reasons
+        { status: 999, expected: HttpError }
+      ];
+
+      testCases.forEach(({ status, expected }) => {
+        const error = createErrorFromStatusCode(status, 'Test message');
+        expect(error).toBeInstanceOf(expected);
+      });
+    });
+
+    test('all error types have consistent HttpError interface', () => {
+      const testCases = [
+        { statusCode: 400, expectedType: BadRequestError, expectedTitle: 'Bad request' },
+        { statusCode: 500, expectedType: InternalServerError, expectedTitle: 'Internal server error' },
+        { statusCode: 418, expectedType: HttpError, expectedTitle: undefined }
+      ];
+
+      testCases.forEach(({ statusCode, expectedType, expectedTitle }) => {
+        const error = createErrorFromStatusCode(statusCode, 'Test message');
+
+        expect(error).toBeInstanceOf(expectedType);
+        expect(error.message).toBe(`SABS API Error (${statusCode}): Test message`);
+
+        // All error types should have consistent HttpError interface
+        expect('status' in error).toBe(true);
+        if ('status' in error) {
+          expect(error.status).toBe(statusCode);
+        }
+        if ('title' in error) {
+          expect(error.title).toBe(expectedTitle);
+        }
+      });
+    });
+
+    test('returns standard error types for known status codes', () => {
+      const testCases = [
+        { status: 400, expectedType: BadRequestError },
+        { status: 401, expectedType: UnauthorizedError },
+        { status: 403, expectedType: ForbiddenError },
+        { status: 404, expectedType: NotFoundError },
+        { status: 409, expectedType: ConflictError },
+        { status: 500, expectedType: InternalServerError },
+        { status: 502, expectedType: InternalServerError },
+        { status: 503, expectedType: InternalServerError },
+        { status: 504, expectedType: InternalServerError }
+      ];
+
+      testCases.forEach(({ status, expectedType }) => {
+        const error = createErrorFromStatusCode(status, 'Test message');
+
+        expect(error).toBeInstanceOf(Error);
+        expect(error).toBeInstanceOf(expectedType);
+        expect(error.name).toBe('Error'); // Shared library errors use 'Error' as name
+        expect(error.message).toBe(`SABS API Error (${status}): Test message`);
+      });
+    });
+  });
+
+  describe('createClientError', () => {
+    test('creates BadRequestError with client error prefix', () => {
+      const message = 'Missing required parameter';
+      const error = createClientError(message);
+
+      expect(error).toBeInstanceOf(BadRequestError);
+      expect(error.message).toBe('SABS Client Error: Missing required parameter');
+    });
+
+    test('handles empty message', () => {
+      const error = createClientError('');
+      expect(error.message).toBe('SABS Client Error: ');
+    });
+
+    test('handles special characters in message', () => {
+      const message = 'Invalid characters: <>&"\'';
+      const error = createClientError(message);
+      expect(error.message).toBe(`SABS Client Error: ${message}`);
+    });
+  });
+
+  describe('createNetworkError', () => {
+    test('creates InternalServerError with network error prefix', () => {
+      const message = 'Connection refused';
+      const error = createNetworkError(message);
+
+      expect(error).toBeInstanceOf(InternalServerError);
+      expect(error.message).toBe('SABS Network Error: Connection refused');
+    });
+
+    test('includes original error message when provided', () => {
+      const message = 'Request failed';
+      const originalError = new Error('ECONNREFUSED');
+      const error = createNetworkError(message, originalError);
+
+      expect(error).toBeInstanceOf(InternalServerError);
+      expect(error.message).toBe('SABS Network Error: Request failed (caused by: ECONNREFUSED)');
+    });
+
+    test('handles original error without message', () => {
+      const message = 'Network issue';
+      const originalError = new Error(); // Empty message
+      const error = createNetworkError(message, originalError);
+
+      expect(error.message).toBe('SABS Network Error: Network issue (caused by: )');
+    });
+
+    test('handles null original error', () => {
+      const message = 'Unknown network error';
+      const error = createNetworkError(message, undefined);
+
+      expect(error.message).toBe('SABS Network Error: Unknown network error');
+    });
+  });
+
+  describe('error inheritance and instanceof checks', () => {
+    test('all error types are instances of Error', () => {
+      const errors = [
+        createErrorFromStatusCode(400, 'Bad Request'),
+        createErrorFromStatusCode(401, 'Unauthorized'),
+        createErrorFromStatusCode(403, 'Forbidden'),
+        createErrorFromStatusCode(404, 'Not Found'),
+        createErrorFromStatusCode(409, 'Conflict'),
+        createErrorFromStatusCode(500, 'Internal Server Error'),
+        createErrorFromStatusCode(418, 'Teapot'),
+        createClientError('Client error'),
+        createNetworkError('Network error'),
+        new HttpError(422, 'Custom error')
+      ];
+
+      errors.forEach((error) => {
+        expect(error).toBeInstanceOf(Error);
+        expect(error.message).toBeDefined();
+        expect(typeof error.message).toBe('string');
+        expect(error.name).toBeDefined();
+      });
+    });
+
+    test('error types can be distinguished via instanceof', () => {
+      const badRequestError = createErrorFromStatusCode(400, 'Bad Request');
+      const unauthorizedError = createErrorFromStatusCode(401, 'Unauthorized');
+      const notFoundError = createErrorFromStatusCode(404, 'Not Found');
+      const httpError = createErrorFromStatusCode(418, 'Teapot');
+
+      // All errors extend HttpError, so they're all instances of HttpError
+      expect(badRequestError).toBeInstanceOf(BadRequestError);
+      expect(badRequestError).toBeInstanceOf(HttpError);
+      expect(badRequestError).not.toBeInstanceOf(UnauthorizedError);
+
+      expect(unauthorizedError).toBeInstanceOf(UnauthorizedError);
+      expect(unauthorizedError).toBeInstanceOf(HttpError);
+      expect(unauthorizedError).not.toBeInstanceOf(BadRequestError);
+
+      expect(notFoundError).toBeInstanceOf(NotFoundError);
+      expect(notFoundError).toBeInstanceOf(HttpError);
+      expect(notFoundError).not.toBeInstanceOf(BadRequestError);
+
+      expect(httpError).toBeInstanceOf(HttpError);
+      expect(httpError).not.toBeInstanceOf(BadRequestError);
+    });
+  });
+
+  describe('error serialization and JSON handling', () => {
+    test('errors can be converted to JSON for logging', () => {
+      const error = new HttpError(422, 'Test error');
+
+      // Test that error properties are accessible for logging
+      const logObject = {
+        message: error.message,
+        name: error.name,
+        status: error.status,
+        title: error.title
+      };
+
+      expect(logObject.message).toBe('Test error');
+      expect(logObject.name).toBe('Error');
+      expect(logObject.status).toBe(422);
+      expect(logObject.title).toBeUndefined();
+    });
+
+    test('shared error types have basic error properties', () => {
+      const error = createErrorFromStatusCode(400, 'Validation failed');
+
+      const logObject = {
+        message: error.message,
+        name: error.name,
+        stack: error.stack
+      };
+
+      expect(logObject.message).toBe('SABS API Error (400): Validation failed');
+      expect(logObject.name).toBeDefined();
+      expect(logObject.stack).toBeDefined();
+    });
+  });
+
+  describe('edge cases and error conditions', () => {
+    test('handles undefined and null inputs gracefully', () => {
+      // These should not throw, but create errors with undefined/null content
+      expect(() => createErrorFromStatusCode(400, undefined as any)).not.toThrow();
+      expect(() => createErrorFromStatusCode(400, null as any)).not.toThrow();
+      expect(() => createClientError(undefined as any)).not.toThrow();
+      expect(() => createNetworkError(undefined as any)).not.toThrow();
+    });
+
+    test('handles very large status codes', () => {
+      const error = createErrorFromStatusCode(999999, 'Large status code');
+      expect(error).toBeInstanceOf(HttpError);
+      if (error instanceof HttpError) {
+        expect(error.status).toBe(999999);
+      }
+    });
+
+    test('handles negative status codes', () => {
+      const error = createErrorFromStatusCode(-1, 'Negative status code');
+      expect(error).toBeInstanceOf(HttpError);
+      if (error instanceof HttpError) {
+        expect(error.status).toBe(-1);
+      }
+    });
+
+    test('handles very long error messages', () => {
+      const longMessage = 'x'.repeat(10000);
+      const error = createErrorFromStatusCode(400, longMessage);
+      expect(error.message).toContain(longMessage);
+    });
+  });
+});

package/src/errors.ts

@@ -0,0 +1,60 @@
+import {
+  BadRequestError,
+  InternalServerError,
+  NotFoundError,
+  ConflictError,
+  UnauthorizedError,
+  ForbiddenError,
+  HttpError
+} from '@superblocksteam/shared';
+
+// Re-export all error types from @superblocksteam/shared for convenience
+export { BadRequestError, InternalServerError, NotFoundError, ConflictError, UnauthorizedError, ForbiddenError, HttpError };
+
+/**
+ * Internal factory function to create appropriate error types based on HTTP status codes
+ * @internal
+ */
+export function createErrorFromStatusCode(statusCode: number, message: string): Error {
+  const baseMessage = `SABS API Error (${statusCode}): ${message}`;
+
+  switch (statusCode) {
+    case 400:
+      return new BadRequestError(baseMessage);
+    case 401:
+      return new UnauthorizedError(baseMessage);
+    case 403:
+      return new ForbiddenError(baseMessage);
+    case 404:
+      return new NotFoundError(baseMessage);
+    case 409:
+      return new ConflictError(baseMessage);
+    case 500:
+    case 502:
+    case 503:
+    case 504:
+      return new InternalServerError(baseMessage);
+    default:
+      // For any other status codes, use the generic HttpError
+      return new HttpError(statusCode, baseMessage);
+  }
+}
+
+/**
+ * Internal function to create a client-side error (treated as BadRequestError with 400 status)
+ * @internal
+ */
+export function createClientError(message: string): BadRequestError {
+  return new BadRequestError(`SABS Client Error: ${message}`);
+}
+
+/**
+ * Internal function to create a network/unknown error (treated as InternalServerError with 500 status)
+ * @internal
+ */
+export function createNetworkError(message: string, originalError?: Error): InternalServerError {
+  const errorMessage = originalError
+    ? `SABS Network Error: ${message} (caused by: ${originalError.message})`
+    : `SABS Network Error: ${message}`;
+  return new InternalServerError(errorMessage);
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './sabs';
+export { BadRequestError, InternalServerError, NotFoundError, ConflictError, UnauthorizedError, ForbiddenError, HttpError } from './errors';