@buenojs/bueno 0.8.0

package/tests/unit/container.test.ts

@@ -0,0 +1,279 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { Container, Token } from '../../src/container';
+
+// Test fixtures
+interface ILogger {
+  log(message: string): void;
+}
+
+interface IDatabase {
+  query(sql: string): unknown[];
+}
+
+interface IUserService {
+  getUser(id: string): { id: string; name: string };
+}
+
+class ConsoleLogger implements ILogger {
+  log(message: string): void {
+    console.log(message);
+  }
+}
+
+class MockDatabase implements IDatabase {
+  query(sql: string): unknown[] {
+    return [{ id: 1, name: 'test' }];
+  }
+}
+
+class UserService implements IUserService {
+  constructor(
+    private logger: ILogger,
+    private db: IDatabase
+  ) {}
+
+  getUser(id: string): { id: string; name: string } {
+    this.logger.log(`Getting user ${id}`);
+    const results = this.db.query('SELECT * FROM users WHERE id = ?');
+    return { id, name: 'John' };
+  }
+}
+
+// Token definitions
+const LOGGER_TOKEN = Token<ILogger>('ILogger');
+const DATABASE_TOKEN = Token<IDatabase>('IDatabase');
+const USER_SERVICE_TOKEN = Token<IUserService>('IUserService');
+
+describe('Container', () => {
+  let container: Container;
+
+  beforeEach(() => {
+    container = new Container();
+  });
+
+  describe('Registration', () => {
+    test('should register a provider with useClass', () => {
+      container.register({
+        token: LOGGER_TOKEN,
+        useClass: ConsoleLogger,
+      });
+
+      expect(container.has(LOGGER_TOKEN)).toBe(true);
+    });
+
+    test('should register a provider with useValue', () => {
+      const logger = new ConsoleLogger();
+      container.register({
+        token: LOGGER_TOKEN,
+        useValue: logger,
+      });
+
+      expect(container.has(LOGGER_TOKEN)).toBe(true);
+    });
+
+    test('should register a provider with useFactory', () => {
+      container.register({
+        token: LOGGER_TOKEN,
+        useFactory: () => new ConsoleLogger(),
+      });
+
+      expect(container.has(LOGGER_TOKEN)).toBe(true);
+    });
+
+    test('should throw when registering duplicate token', () => {
+      container.register({
+        token: LOGGER_TOKEN,
+        useClass: ConsoleLogger,
+      });
+
+      expect(() => {
+        container.register({
+          token: LOGGER_TOKEN,
+          useClass: ConsoleLogger,
+        });
+      }).toThrow();
+    });
+  });
+
+  describe('Resolution', () => {
+    test('should resolve useClass provider', () => {
+      container.register({
+        token: LOGGER_TOKEN,
+        useClass: ConsoleLogger,
+      });
+
+      const logger = container.resolve<ILogger>(LOGGER_TOKEN);
+      expect(logger).toBeInstanceOf(ConsoleLogger);
+    });
+
+    test('should resolve useValue provider', () => {
+      const logger = new ConsoleLogger();
+      container.register({
+        token: LOGGER_TOKEN,
+        useValue: logger,
+      });
+
+      const resolved = container.resolve<ILogger>(LOGGER_TOKEN);
+      expect(resolved).toBe(logger);
+    });
+
+    test('should resolve useFactory provider', () => {
+      container.register({
+        token: LOGGER_TOKEN,
+        useFactory: () => new ConsoleLogger(),
+      });
+
+      const logger = container.resolve<ILogger>(LOGGER_TOKEN);
+      expect(logger).toBeInstanceOf(ConsoleLogger);
+    });
+
+    test('should throw when resolving unregistered token', () => {
+      expect(() => {
+        container.resolve(LOGGER_TOKEN);
+      }).toThrow();
+    });
+
+    test('should resolve dependencies via constructor injection', () => {
+      container.register({
+        token: LOGGER_TOKEN,
+        useClass: ConsoleLogger,
+      });
+
+      container.register({
+        token: DATABASE_TOKEN,
+        useClass: MockDatabase,
+      });
+
+      container.register({
+        token: USER_SERVICE_TOKEN,
+        useClass: UserService,
+        inject: [LOGGER_TOKEN, DATABASE_TOKEN],
+      });
+
+      const userService = container.resolve<IUserService>(USER_SERVICE_TOKEN);
+      expect(userService).toBeInstanceOf(UserService);
+      expect(userService.getUser('1')).toEqual({ id: '1', name: 'John' });
+    });
+
+    test('should resolve factory with injected dependencies', () => {
+      container.register({
+        token: LOGGER_TOKEN,
+        useClass: ConsoleLogger,
+      });
+
+      container.register({
+        token: DATABASE_TOKEN,
+        useClass: MockDatabase,
+      });
+
+      container.register({
+        token: USER_SERVICE_TOKEN,
+        useFactory: (logger, db) => new UserService(logger, db),
+        inject: [LOGGER_TOKEN, DATABASE_TOKEN],
+      });
+
+      const userService = container.resolve<IUserService>(USER_SERVICE_TOKEN);
+      expect(userService).toBeInstanceOf(UserService);
+    });
+  });
+
+  describe('Scopes', () => {
+    test('singleton scope should return same instance', () => {
+      container.register({
+        token: LOGGER_TOKEN,
+        useClass: ConsoleLogger,
+        scope: 'singleton',
+      });
+
+      const logger1 = container.resolve<ILogger>(LOGGER_TOKEN);
+      const logger2 = container.resolve<ILogger>(LOGGER_TOKEN);
+
+      expect(logger1).toBe(logger2);
+    });
+
+    test('transient scope should return new instances', () => {
+      container.register({
+        token: LOGGER_TOKEN,
+        useClass: ConsoleLogger,
+        scope: 'transient',
+      });
+
+      const logger1 = container.resolve<ILogger>(LOGGER_TOKEN);
+      const logger2 = container.resolve<ILogger>(LOGGER_TOKEN);
+
+      expect(logger1).not.toBe(logger2);
+    });
+
+    test('default scope should be singleton', () => {
+      container.register({
+        token: LOGGER_TOKEN,
+        useClass: ConsoleLogger,
+      });
+
+      const logger1 = container.resolve<ILogger>(LOGGER_TOKEN);
+      const logger2 = container.resolve<ILogger>(LOGGER_TOKEN);
+
+      expect(logger1).toBe(logger2);
+    });
+  });
+
+  describe('Circular Dependencies', () => {
+    test('should detect circular dependencies', () => {
+      const TOKEN_A = Token('ServiceA');
+      const TOKEN_B = Token('ServiceB');
+
+      container.register({
+        token: TOKEN_A,
+        useFactory: () => ({ b: container.resolve(TOKEN_B) }),
+      });
+
+      container.register({
+        token: TOKEN_B,
+        useFactory: () => ({ a: container.resolve(TOKEN_A) }),
+      });
+
+      // This should either throw or handle gracefully
+      // For now, we expect it to detect the circular dependency
+      // Note: Real implementation should track resolution stack
+    });
+  });
+
+  describe('Bulk Registration', () => {
+    test('should register multiple providers', () => {
+      container.registerAll([
+        { token: LOGGER_TOKEN, useClass: ConsoleLogger },
+        { token: DATABASE_TOKEN, useClass: MockDatabase },
+      ]);
+
+      expect(container.has(LOGGER_TOKEN)).toBe(true);
+      expect(container.has(DATABASE_TOKEN)).toBe(true);
+    });
+  });
+
+  describe('Clear', () => {
+    test('should clear all registrations', () => {
+      container.register({
+        token: LOGGER_TOKEN,
+        useClass: ConsoleLogger,
+      });
+
+      container.clear();
+
+      expect(container.has(LOGGER_TOKEN)).toBe(false);
+    });
+  });
+});
+
+describe('Token', () => {
+  test('should create a token with description', () => {
+    const token = Token<string>('myString');
+    expect(token.description).toBe('myString');
+  });
+
+  test('should be usable as object key', () => {
+    const token = Token<string>('myString');
+    const map = new Map();
+    map.set(token, 'value');
+    expect(map.get(token)).toBe('value');
+  });
+});

package/tests/unit/context.test.ts

@@ -0,0 +1,221 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { Context } from '../../src/context';
+import type { PathParams } from '../../src/types';
+
+describe('Context', () => {
+  let mockRequest: Request;
+  let context: Context;
+
+  beforeEach(() => {
+    mockRequest = new Request('http://localhost:3000/users/123?page=1&limit=10', {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': 'Bearer token123',
+      },
+    });
+    const params: PathParams = { id: '123' };
+    context = new Context(mockRequest, params);
+  });
+
+  describe('Request Access', () => {
+    test('should provide access to raw request', () => {
+      expect(context.req).toBe(mockRequest);
+    });
+
+    test('should provide request method', () => {
+      expect(context.method).toBe('GET');
+    });
+
+    test('should provide request URL', () => {
+      expect(context.url).toBeInstanceOf(URL);
+      expect(context.url.pathname).toBe('/users/123');
+    });
+
+    test('should provide path name', () => {
+      expect(context.path).toBe('/users/123');
+    });
+  });
+
+  describe('Parameters', () => {
+    test('should provide path parameters', () => {
+      expect(context.params).toEqual({ id: '123' });
+    });
+
+    test('should provide query parameters', () => {
+      expect(context.query.page).toBe('1');
+      expect(context.query.limit).toBe('10');
+    });
+
+    test('should handle missing query parameters', () => {
+      expect(context.query.missing).toBeUndefined();
+    });
+  });
+
+  describe('Headers', () => {
+    test('should get header value', () => {
+      expect(context.getHeader('content-type')).toBe('application/json');
+      expect(context.getHeader('authorization')).toBe('Bearer token123');
+    });
+
+    test('should be case-insensitive for headers', () => {
+      expect(context.getHeader('Content-Type')).toBe('application/json');
+      expect(context.getHeader('CONTENT-TYPE')).toBe('application/json');
+    });
+
+    test('should return undefined for missing headers', () => {
+      expect(context.getHeader('x-custom')).toBeUndefined();
+    });
+  });
+
+  describe('Cookies', () => {
+    test('should parse cookies from header', () => {
+      const requestWithCookies = new Request('http://localhost:3000/', {
+        headers: {
+          Cookie: 'session=abc123; user=john',
+        },
+      });
+      const ctx = new Context(requestWithCookies, {});
+
+      expect(ctx.getCookie('session')).toBe('abc123');
+      expect(ctx.getCookie('user')).toBe('john');
+    });
+
+    test('should return undefined for missing cookie', () => {
+      expect(context.getCookie('session')).toBeUndefined();
+    });
+  });
+
+  describe('Body Parsing', () => {
+    test('should parse JSON body', async () => {
+      const request = new Request('http://localhost:3000/', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: 'John', age: 30 }),
+      });
+      const ctx = new Context(request, {});
+
+      const body = await ctx.body();
+      expect(body).toEqual({ name: 'John', age: 30 });
+    });
+
+    test('should parse form data', async () => {
+      const request = new Request('http://localhost:3000/', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: 'name=John&age=30',
+      });
+      const ctx = new Context(request, {});
+
+      const body = await ctx.bodyFormData();
+      expect(body.get('name')).toBe('John');
+      expect(body.get('age')).toBe('30');
+    });
+
+    test('should get text body', async () => {
+      const request = new Request('http://localhost:3000/', {
+        method: 'POST',
+        body: 'plain text body',
+      });
+      const ctx = new Context(request, {});
+
+      const body = await ctx.bodyText();
+      expect(body).toBe('plain text body');
+    });
+
+    test('should cache parsed body', async () => {
+      const request = new Request('http://localhost:3000/', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: 'John' }),
+      });
+      const ctx = new Context(request, {});
+
+      const body1 = await ctx.body();
+      const body2 = await ctx.body();
+
+      expect(body1).toBe(body2);
+    });
+  });
+
+  describe('Variable Storage', () => {
+    test('should set and get variables', () => {
+      context.set('user', { id: 1, name: 'John' });
+      expect(context.get('user')).toEqual({ id: 1, name: 'John' });
+    });
+
+    test('should return undefined for missing variables', () => {
+      expect(context.get('missing')).toBeUndefined();
+    });
+
+    test('should check if variable exists', () => {
+      context.set('user', { id: 1 });
+      expect(context.has('user')).toBe(true);
+      expect(context.has('missing')).toBe(false);
+    });
+  });
+
+  describe('Response Building', () => {
+    test('should create JSON response', () => {
+      const response = context.json({ message: 'success' });
+      expect(response).toBeInstanceOf(Response);
+      expect(response.headers.get('Content-Type')).toContain('application/json');
+    });
+
+    test('should create text response', () => {
+      const response = context.text('Hello World');
+      expect(response).toBeInstanceOf(Response);
+    });
+
+    test('should create HTML response', () => {
+      const response = context.html('<h1>Hello</h1>');
+      expect(response).toBeInstanceOf(Response);
+      expect(response.headers.get('Content-Type')).toContain('text/html');
+    });
+
+    test('should create redirect response', () => {
+      const response = context.redirect('/new-location');
+      expect(response.status).toBe(302);
+      expect(response.headers.get('Location')).toBe('/new-location');
+    });
+
+    test('should create redirect with custom status', () => {
+      const response = context.redirect('/new-location', 301);
+      expect(response.status).toBe(301);
+    });
+
+    test('should set status code', () => {
+      context.status(201);
+      const response = context.json({ created: true });
+      expect(response.status).toBe(201);
+    });
+
+    test('should set response headers', () => {
+      context.setHeader('X-Custom', 'value');
+      const response = context.json({});
+      expect(response.headers.get('X-Custom')).toBe('value');
+    });
+
+    test('should create 404 response', () => {
+      const response = context.notFound('Resource not found');
+      expect(response.status).toBe(404);
+    });
+
+    test('should create error response', () => {
+      const response = context.error('Something went wrong', 500);
+      expect(response.status).toBe(500);
+    });
+  });
+
+  describe('Response Chain', () => {
+    test('should support method chaining', () => {
+      const response = context
+        .status(201)
+        .setHeader('X-Created', 'true')
+        .json({ id: 1 });
+
+      expect(response.status).toBe(201);
+      expect(response.headers.get('X-Created')).toBe('true');
+    });
+  });
+});

package/tests/unit/database.test.ts

@@ -0,0 +1,183 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { Database, detectDriver, createConnection, QueryBuilder, table } from '../../src/database';
+
+describe('Database', () => {
+  // Use SQLite for testing (no external dependencies)
+  const testDbPath = ':memory:';
+  
+  describe('detectDriver', () => {
+    test('should detect postgresql from URL', () => {
+      expect(detectDriver('postgresql://user:pass@localhost/db')).toBe('postgresql');
+    });
+
+    test('should detect mysql from URL', () => {
+      expect(detectDriver('mysql://user:pass@localhost/db')).toBe('mysql');
+    });
+
+    test('should detect sqlite from file path', () => {
+      expect(detectDriver('./test.db')).toBe('sqlite');
+      expect(detectDriver('/path/to/test.db')).toBe('sqlite');
+    });
+
+    test('should detect sqlite from sqlite:// URL', () => {
+      expect(detectDriver('sqlite://./test.db')).toBe('sqlite');
+    });
+  });
+
+  describe('Database (SQLite)', () => {
+    let db: Database;
+
+    beforeEach(async () => {
+      db = new Database({ url: testDbPath });
+      await db.connect();
+      
+      // Create test table using raw SQL
+      await db.raw(`
+        CREATE TABLE IF NOT EXISTS users (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT NOT NULL,
+          email TEXT UNIQUE
+        )
+      `);
+    });
+
+    afterEach(async () => {
+      await db.close();
+    });
+
+    test('should connect to database', () => {
+      expect(db.isConnected).toBe(true);
+    });
+
+    test('should execute queries with tagged template', async () => {
+      await db.raw("INSERT INTO users (name, email) VALUES ('John', 'john@example.com')");
+      
+      const count = await db.queryOne<{ count: number }>`SELECT COUNT(*) as count FROM users`;
+      expect(count?.count).toBe(1);
+    });
+
+    test('should query multiple rows', async () => {
+      await db.raw("INSERT INTO users (name, email) VALUES ('John', 'john@example.com')");
+      await db.raw("INSERT INTO users (name, email) VALUES ('Jane', 'jane@example.com')");
+      
+      const users = await db.query<{ id: number; name: string; email: string }>`SELECT * FROM users ORDER BY name`;
+      
+      expect(users.length).toBe(2);
+      expect(users[0].name).toBe('Jane');
+      expect(users[1].name).toBe('John');
+    });
+
+    test('should query single row', async () => {
+      await db.raw("INSERT INTO users (name, email) VALUES ('John', 'john@example.com')");
+      
+      const user = await db.queryOne<{ id: number; name: string; email: string }>`
+        SELECT * FROM users WHERE name = ${'John'}
+      `;
+      
+      expect(user).not.toBeNull();
+      expect(user?.name).toBe('John');
+    });
+
+    test('should handle transactions', async () => {
+      await db.transaction(async (tx) => {
+        await tx.execute`INSERT INTO users (name, email) VALUES (${'John'}, ${'john@example.com'})`;
+      });
+      
+      const count = await db.queryOne<{ count: number }>`SELECT COUNT(*) as count FROM users`;
+      expect(count?.count).toBe(1);
+    });
+
+    test('should rollback on error', async () => {
+      try {
+        await db.transaction(async (tx) => {
+          await tx.execute`INSERT INTO users (name, email) VALUES (${'John'}, ${'john@example.com'})`;
+          throw new Error('Test error');
+        });
+      } catch (e) {
+        // Expected
+      }
+      
+      const count = await db.queryOne<{ count: number }>`SELECT COUNT(*) as count FROM users`;
+      expect(count?.count).toBe(0);
+    });
+  });
+
+  describe('QueryBuilder', () => {
+    let db: Database;
+    let users: QueryBuilder<{ id: number; name: string; email: string }>;
+
+    beforeEach(async () => {
+      db = new Database({ url: testDbPath });
+      await db.connect();
+      
+      await db.raw(`
+        CREATE TABLE IF NOT EXISTS users (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT NOT NULL,
+          email TEXT UNIQUE
+        )
+      `);
+      
+      users = table<{ id: number; name: string; email: string }>(db, 'users');
+    });
+
+    afterEach(async () => {
+      await db.close();
+    });
+
+    test('should insert and find by id', async () => {
+      const inserted = await users.insert({ name: 'John', email: 'john@example.com' });
+      expect(inserted.name).toBe('John');
+      
+      const found = await users.findById(inserted.id);
+      expect(found?.name).toBe('John');
+    });
+
+    test('should count rows', async () => {
+      await users.insert({ name: 'John', email: 'john@example.com' });
+      await users.insert({ name: 'Jane', email: 'jane@example.com' });
+      
+      const count = await users.count();
+      expect(count).toBe(2);
+    });
+
+    test('should delete by id', async () => {
+      const inserted = await users.insert({ name: 'John', email: 'john@example.com' });
+      
+      const deleted = await users.deleteById(inserted.id);
+      expect(deleted).toBe(true);
+      
+      const found = await users.findById(inserted.id);
+      expect(found).toBeNull();
+    });
+
+    test('should update by id', async () => {
+      const inserted = await users.insert({ name: 'John', email: 'john@example.com' });
+      
+      const updated = await users.updateById(inserted.id, { name: 'Johnny' });
+      expect(updated?.name).toBe('Johnny');
+    });
+
+    test('should paginate results', async () => {
+      for (let i = 0; i < 25; i++) {
+        await users.insert({ name: `User${i}`, email: `user${i}@example.com` });
+      }
+      
+      const page1 = await users.paginate(1, 10);
+      expect(page1.data.length).toBe(10);
+      expect(page1.total).toBe(25);
+      expect(page1.totalPages).toBe(3);
+      
+      const page3 = await users.paginate(3, 10);
+      expect(page3.data.length).toBe(5);
+    });
+  });
+
+  describe('createConnection', () => {
+    test('should create and connect to database', async () => {
+      const db = await createConnection({ url: ':memory:' });
+      expect(db.isConnected).toBe(true);
+      await db.close();
+    });
+  });
+});