@vobase/core 0.9.0 → 0.11.0

package/src/infra/circuit-breaker.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, test } from 'bun:test';
+import { CircuitBreaker } from './circuit-breaker';
+
+describe('CircuitBreaker', () => {
+  test('starts closed and allows requests', () => {
+    const cb = new CircuitBreaker({ threshold: 3, resetTimeout: 100 });
+    expect(cb.isOpen()).toBe(false);
+    expect(cb.isHalfOpen()).toBe(false);
+  });
+
+  test('opens after threshold failures', () => {
+    const cb = new CircuitBreaker({ threshold: 3, resetTimeout: 100 });
+    cb.recordFailure();
+    cb.recordFailure();
+    expect(cb.isOpen()).toBe(false);
+    cb.recordFailure();
+    expect(cb.isOpen()).toBe(true);
+  });
+
+  test('transitions to half-open after resetTimeout', async () => {
+    const cb = new CircuitBreaker({ threshold: 2, resetTimeout: 50 });
+    cb.recordFailure();
+    cb.recordFailure();
+    expect(cb.isOpen()).toBe(true);
+
+    await Bun.sleep(60);
+
+    expect(cb.isOpen()).toBe(false);
+    expect(cb.isHalfOpen()).toBe(true);
+  });
+
+  test('closes on success in half-open state', async () => {
+    const cb = new CircuitBreaker({ threshold: 2, resetTimeout: 50 });
+    cb.recordFailure();
+    cb.recordFailure();
+    expect(cb.isOpen()).toBe(true);
+
+    await Bun.sleep(60);
+    expect(cb.isHalfOpen()).toBe(true);
+
+    cb.recordSuccess();
+    expect(cb.isOpen()).toBe(false);
+    expect(cb.isHalfOpen()).toBe(false);
+  });
+
+  test('re-opens on failure in half-open state', async () => {
+    const cb = new CircuitBreaker({ threshold: 2, resetTimeout: 50 });
+    cb.recordFailure();
+    cb.recordFailure();
+
+    await Bun.sleep(60);
+    expect(cb.isHalfOpen()).toBe(true);
+
+    cb.recordFailure();
+    expect(cb.isOpen()).toBe(true);
+    expect(cb.isHalfOpen()).toBe(false);
+  });
+
+  test('resets failure count on success', () => {
+    const cb = new CircuitBreaker({ threshold: 3, resetTimeout: 100 });
+    cb.recordFailure();
+    cb.recordFailure();
+    expect(cb.isOpen()).toBe(false);
+
+    cb.recordSuccess();
+
+    // After reset, need threshold failures again to open
+    cb.recordFailure();
+    cb.recordFailure();
+    expect(cb.isOpen()).toBe(false);
+    cb.recordFailure();
+    expect(cb.isOpen()).toBe(true);
+  });
+});

package/src/infra/circuit-breaker.ts

@@ -0,0 +1,57 @@
+export interface CircuitBreakerOptions {
+  threshold: number;      // failures before opening
+  resetTimeout: number;   // ms before transitioning from open to half-open
+}
+
+type CircuitState = 'closed' | 'open' | 'half-open';
+
+export class CircuitBreaker {
+  private state: CircuitState = 'closed';
+  private failures = 0;
+  private openedAt = 0;
+  private readonly threshold: number;
+  private readonly resetTimeout: number;
+
+  constructor(options: CircuitBreakerOptions) {
+    this.threshold = options.threshold;
+    this.resetTimeout = options.resetTimeout;
+  }
+
+  isOpen(): boolean {
+    if (this.state === 'open') {
+      // Check if we should transition to half-open
+      if (Date.now() - this.openedAt >= this.resetTimeout) {
+        this.state = 'half-open';
+        return false;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  isHalfOpen(): boolean {
+    // isOpen() may transition state, so call it first
+    this.isOpen();
+    return this.state === 'half-open';
+  }
+
+  recordFailure(): void {
+    if (this.state === 'half-open') {
+      // Re-open immediately from half-open
+      this.state = 'open';
+      this.openedAt = Date.now();
+      return;
+    }
+
+    this.failures++;
+    if (this.failures >= this.threshold) {
+      this.state = 'open';
+      this.openedAt = Date.now();
+    }
+  }
+
+  recordSuccess(): void {
+    this.failures = 0;
+    this.state = 'closed';
+  }
+}

package/src/infra/errors.test.ts

@@ -0,0 +1,175 @@
+import { describe, expect, it, mock } from 'bun:test';
+import type { Context } from 'hono';
+
+import {
+  conflict,
+  dbBusy,
+  ERROR_CODES,
+  errorHandler,
+  forbidden,
+  notFound,
+  unauthorized,
+  VobaseError,
+  validation,
+} from './errors';
+
+describe('VobaseError', () => {
+  it('should create an error with correct properties', () => {
+    const err = new VobaseError('Test error', 'INTERNAL', 500);
+    expect(err).toBeInstanceOf(VobaseError);
+    expect(err).toBeInstanceOf(Error);
+    expect(err.message).toBe('Test error');
+    expect(err.code).toBe('INTERNAL');
+    expect(err.statusCode).toBe(500);
+    expect(err.name).toBe('VobaseError');
+  });
+
+  it('should support details object', () => {
+    const details = { field: 'email', reason: 'invalid' };
+    const err = new VobaseError('Invalid', 'VALIDATION', 400, details);
+    expect(err.details).toEqual(details);
+  });
+});
+
+describe('Factory functions', () => {
+  it('unauthorized() should produce 401 error', () => {
+    const err = unauthorized();
+    expect(err).toBeInstanceOf(VobaseError);
+    expect(err.statusCode).toBe(401);
+    expect(err.code).toBe('UNAUTHORIZED');
+    expect(err.message).toBe('Unauthorized');
+  });
+
+  it('unauthorized() should accept custom message', () => {
+    const err = unauthorized('Access denied');
+    expect(err.message).toBe('Access denied');
+  });
+
+  it('forbidden() should produce 403 error', () => {
+    const err = forbidden();
+    expect(err.statusCode).toBe(403);
+    expect(err.code).toBe('FORBIDDEN');
+  });
+
+  it('notFound() should include resource name in message', () => {
+    const err = notFound('Invoice');
+    expect(err.statusCode).toBe(404);
+    expect(err.code).toBe('NOT_FOUND');
+    expect(err.message).toContain('Invoice');
+    expect(err.message).toBe('Invoice not found');
+  });
+
+  it('validation() should include details', () => {
+    const details = { field: 'email', reason: 'required' };
+    const err = validation(details);
+    expect(err.statusCode).toBe(400);
+    expect(err.code).toBe('VALIDATION');
+    expect(err.details).toEqual(details);
+  });
+
+  it('validation() should accept custom message', () => {
+    const err = validation({}, 'Custom validation error');
+    expect(err.message).toBe('Custom validation error');
+  });
+
+  it('conflict() should include resource name in message', () => {
+    const err = conflict('User');
+    expect(err.statusCode).toBe(409);
+    expect(err.code).toBe('CONFLICT');
+    expect(err.message).toContain('User');
+    expect(err.message).toBe('User already exists');
+  });
+
+  it('dbBusy() should produce 503 error', () => {
+    const err = dbBusy();
+    expect(err.statusCode).toBe(503);
+    expect(err.code).toBe('DB_BUSY');
+  });
+});
+
+describe('errorHandler', () => {
+  it('should handle VobaseError and return correct JSON', () => {
+    const mockContext = {
+      json: mock((data, status) => ({
+        data,
+        status,
+      })),
+    };
+
+    const err = notFound('Invoice');
+    errorHandler(err, mockContext as unknown as Context);
+
+    expect(mockContext.json).toHaveBeenCalledWith(
+      {
+        error: {
+          code: 'NOT_FOUND',
+          message: 'Invoice not found',
+          details: undefined,
+        },
+      },
+      404,
+    );
+  });
+
+  it('should include details in VobaseError response', () => {
+    const mockContext = {
+      json: mock((data, status) => ({
+        data,
+        status,
+      })),
+    };
+
+    const details = { field: 'email' };
+    const err = validation(details, 'Invalid email');
+    errorHandler(err, mockContext as unknown as Context);
+
+    expect(mockContext.json).toHaveBeenCalledWith(
+      {
+        error: {
+          code: 'VALIDATION',
+          message: 'Invalid email',
+          details,
+        },
+      },
+      400,
+    );
+  });
+
+  it('should handle unknown errors with 500', () => {
+    const mockContext = {
+      json: mock((data, status) => ({
+        data,
+        status,
+      })),
+    };
+
+    const consoleErrorMock = mock(() => {});
+    console.error = consoleErrorMock;
+
+    const err = new Error('Unknown error');
+    errorHandler(err, mockContext as unknown as Context);
+
+    expect(mockContext.json).toHaveBeenCalledWith(
+      {
+        error: {
+          code: 'INTERNAL',
+          message: 'Internal server error',
+        },
+      },
+      500,
+    );
+    expect(consoleErrorMock).toHaveBeenCalled();
+  });
+});
+
+describe('ERROR_CODES', () => {
+  it('should have all required error codes', () => {
+    expect(ERROR_CODES.UNAUTHORIZED).toBe('UNAUTHORIZED');
+    expect(ERROR_CODES.FORBIDDEN).toBe('FORBIDDEN');
+    expect(ERROR_CODES.NOT_FOUND).toBe('NOT_FOUND');
+    expect(ERROR_CODES.VALIDATION).toBe('VALIDATION');
+    expect(ERROR_CODES.CONFLICT).toBe('CONFLICT');
+    expect(ERROR_CODES.INTERNAL).toBe('INTERNAL');
+    expect(ERROR_CODES.DB_BUSY).toBe('DB_BUSY');
+  });
+});

package/src/infra/errors.ts

@@ -0,0 +1,64 @@
+import type { Context } from 'hono';
+import type { ContentfulStatusCode } from 'hono/utils/http-status';
+
+export const ERROR_CODES = {
+  UNAUTHORIZED: 'UNAUTHORIZED',
+  FORBIDDEN: 'FORBIDDEN',
+  NOT_FOUND: 'NOT_FOUND',
+  VALIDATION: 'VALIDATION',
+  CONFLICT: 'CONFLICT',
+  INTERNAL: 'INTERNAL',
+  DB_BUSY: 'DB_BUSY',
+} as const;
+
+export type ErrorCode = keyof typeof ERROR_CODES;
+
+export class VobaseError extends Error {
+  constructor(
+    message: string,
+    public readonly code: ErrorCode,
+    public readonly statusCode: ContentfulStatusCode,
+    public readonly details?: object,
+  ) {
+    super(message);
+    this.name = 'VobaseError';
+  }
+}
+
+export const unauthorized = (message = 'Unauthorized') =>
+  new VobaseError(message, 'UNAUTHORIZED', 401);
+
+export const forbidden = (message = 'Forbidden') =>
+  new VobaseError(message, 'FORBIDDEN', 403);
+
+export const notFound = (resource: string) =>
+  new VobaseError(`${resource} not found`, 'NOT_FOUND', 404);
+
+export const validation = (details: object, message = 'Validation failed') =>
+  new VobaseError(message, 'VALIDATION', 400, details);
+
+export const conflict = (resource: string) =>
+  new VobaseError(`${resource} already exists`, 'CONFLICT', 409);
+
+export const dbBusy = () =>
+  new VobaseError('Database busy, try again', 'DB_BUSY', 503);
+
+export const errorHandler = (err: Error, c: Context): Response => {
+  if (err instanceof VobaseError) {
+    return c.json(
+      {
+        error: {
+          code: err.code,
+          message: err.message,
+          details: err.details,
+        },
+      },
+      err.statusCode,
+    );
+  }
+  console.error('Unhandled error:', err);
+  return c.json(
+    { error: { code: 'INTERNAL', message: 'Internal server error' } },
+    500,
+  );
+};