@tamayrp14/fire-api 0.0.0-stage → 1.0.1

package/test/auth.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'bun:test';
+import { hashPassword, verifyPassword } from '../src/auth/crypto';
+import { signJWT, verifyJWT } from '../src/auth/jwt';
+import { createAuth, requireAuth } from '../src/auth/auth';
+import { createApp } from '../src/core/app';
+
+describe('FireAPI Turnkey Auth Module (fire-api/auth)', () => {
+  it('hashes and verifies passwords securely using Web Crypto', async () => {
+    const rawPassword = 'SuperSecretPassword123!';
+    const hash = await hashPassword(rawPassword);
+
+    expect(hash).toContain(':'); // salt:hash format
+    expect(await verifyPassword(rawPassword, hash)).toBe(true);
+    expect(await verifyPassword('WrongPassword', hash)).toBe(false);
+  });
+
+  it('signs and verifies JWT tokens with expiration', async () => {
+    const secret = 'test-secret-key-super-safe';
+    const payload = { userId: 'usr_1', role: 'admin' };
+
+    const token = await signJWT(payload, secret, 3600); // 1 hour
+    expect(token.split('.').length).toBe(3);
+
+    const decoded = await verifyJWT<{ userId: string; role: string }>(token, secret);
+    expect(decoded.userId).toBe('usr_1');
+    expect(decoded.role).toBe('admin');
+  });
+
+  it('provides turnkey register and login routes', async () => {
+    const app = createApp({ database: { driver: 'memory' } });
+    const authRouter = createAuth({ jwtSecret: 'jwt-super-secret' });
+    app.use('/auth', authRouter);
+
+    // 1. Test Register
+    const regRes = await app.handle(
+      new Request('http://localhost:3000/auth/register', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          email: 'yoga@fire.dev',
+          password: 'Password123!',
+          name: 'Yoga',
+        }),
+      })
+    );
+
+    expect(regRes.status).toBe(201);
+    const regData = await regRes.json();
+    expect(regData.user.email).toBe('yoga@fire.dev');
+    expect(regData.token).toBeDefined();
+
+    // 2. Test Login (Success)
+    const loginRes = await app.handle(
+      new Request('http://localhost:3000/auth/login', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          email: 'yoga@fire.dev',
+          password: 'Password123!',
+        }),
+      })
+    );
+
+    expect(loginRes.status).toBe(200);
+    const loginData = await loginRes.json();
+    expect(loginData.token).toBeDefined();
+
+    // 3. Test Login (Invalid password)
+    const failRes = await app.handle(
+      new Request('http://localhost:3000/auth/login', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          email: 'yoga@fire.dev',
+          password: 'WrongPassword',
+        }),
+      })
+    );
+
+    expect(failRes.status).toBe(401);
+  });
+
+  it('enforces route protection with requireAuth guard', async () => {
+    const app = createApp();
+    const secret = 'jwt-guard-secret';
+
+    app.get('/protected', {
+      middlewares: [requireAuth(secret)],
+      handler: (ctx) => ctx.ok({ secretData: 'access granted', user: ctx.user }),
+    });
+
+    // Without token -> 401
+    const unauthRes = await app.handle(new Request('http://localhost:3000/protected'));
+    expect(unauthRes.status).toBe(401);
+
+    // With valid token -> 200
+    const token = await signJWT({ id: 'u1', name: 'Dev' }, secret);
+    const authRes = await app.handle(
+      new Request('http://localhost:3000/protected', {
+        headers: { Authorization: `Bearer ${token}` },
+      })
+    );
+    expect(authRes.status).toBe(200);
+    const data = await authRes.json();
+    expect(data.secretData).toBe('access granted');
+    expect(data.user.id).toBe('u1');
+  });
+});

package/test/bench.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'bun:test';
+import { runBenchmark, formatBenchmarkReport } from '../src/cli/bench';
+
+describe('FireAPI Built-in Benchmark Harness CLI', () => {
+  it('measures throughput and percentiles from mock load', async () => {
+    // Simulated fast API endpoint returning in 0.5ms - 1ms
+    const mockEndpoint = async () => {
+      await new Promise((r) => setTimeout(r, 1));
+      return new Response(JSON.stringify({ status: 'ok' }));
+    };
+
+    const stats = await runBenchmark('http://localhost:3000/mock', {
+      concurrency: 5,
+      totalRequests: 50,
+      customFetch: mockEndpoint,
+    });
+
+    expect(stats.totalRequests).toBe(50);
+    expect(stats.successfulRequests).toBe(50);
+    expect(stats.failedRequests).toBe(0);
+    expect(stats.rps).toBeGreaterThan(0);
+    expect(stats.latency.p50).toBeGreaterThanOrEqual(0);
+    expect(stats.latency.p99).toBeGreaterThanOrEqual(stats.latency.p50);
+
+    const report = formatBenchmarkReport(stats);
+    expect(report).toContain('FireAPI Benchmark Engine');
+    expect(report).toContain('Requests/sec:');
+    expect(report).toContain('P50:');
+    expect(report).toContain('P99:');
+  });
+});

package/test/cache.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'bun:test';
+import { MemoryCacheManager } from '../src/cache/cache';
+
+describe('FireAPI FireCache SWR Engine', () => {
+  it('stores and retrieves cached values with TTL', async () => {
+    const cache = new MemoryCacheManager();
+    await cache.set('user:1', { name: 'Yoga' }, 10); // 10 seconds
+
+    const item = await cache.get('user:1');
+    expect(item).toEqual({ name: 'Yoga' });
+  });
+
+  it('expires items when TTL has elapsed', async () => {
+    const cache = new MemoryCacheManager();
+    // Expire immediately (0.01s)
+    await cache.set('temp', 'gone_soon', 0.01);
+
+    await new Promise((r) => setTimeout(r, 20));
+    const item = await cache.get('temp');
+    expect(item).toBeNull();
+  });
+
+  it('invalidates cache entries by tags', async () => {
+    const cache = new MemoryCacheManager();
+    await cache.set('post:1', { title: 'First Post' }, 60, ['posts', 'author:1']);
+    await cache.set('post:2', { title: 'Second Post' }, 60, ['posts', 'author:2']);
+    await cache.set('user:1', { name: 'Author One' }, 60, ['users']);
+
+    // Invalidate 'posts' tag
+    await cache.invalidate('posts');
+
+    expect(await cache.get('post:1')).toBeNull();
+    expect(await cache.get('post:2')).toBeNull();
+    expect(await cache.get('user:1')).toEqual({ name: 'Author One' }); // untouched!
+  });
+});

package/test/cli-create.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it, afterAll } from 'bun:test';
+import { createAppProject, formatRoutesTable, createRouter } from '../src/index';
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('FireAPI CLI Scaffolding & Developer Accelerator (create-app & routes)', () => {
+  const tempProjectDir = path.resolve('./temp_scaffold_test_app');
+
+  afterAll(() => {
+    if (fs.existsSync(tempProjectDir)) {
+      fs.rmSync(tempProjectDir, { recursive: true, force: true });
+    }
+  });
+
+  it('scaffolds a complete, clean, modern FireAPI project with all files', () => {
+    const result = createAppProject({
+      name: 'test-saas-api',
+      targetDir: tempProjectDir,
+    });
+
+    expect(result.filesCreated.length).toBeGreaterThanOrEqual(10);
+    expect(fs.existsSync(path.join(tempProjectDir, 'package.json'))).toBe(true);
+    expect(fs.existsSync(path.join(tempProjectDir, 'tsconfig.json'))).toBe(true);
+    expect(fs.existsSync(path.join(tempProjectDir, '.env'))).toBe(true);
+    expect(fs.existsSync(path.join(tempProjectDir, '.gitignore'))).toBe(true);
+    expect(fs.existsSync(path.join(tempProjectDir, 'src/index.ts'))).toBe(true);
+    expect(fs.existsSync(path.join(tempProjectDir, 'src/modules/users/users.router.ts'))).toBe(true);
+    expect(fs.existsSync(path.join(tempProjectDir, 'src/modules/users/users.schema.ts'))).toBe(true);
+    expect(fs.existsSync(path.join(tempProjectDir, 'src/modules/auth/auth.router.ts'))).toBe(true);
+    expect(fs.existsSync(path.join(tempProjectDir, 'test/app.test.ts'))).toBe(true);
+
+    // Verify package.json contains correct scripts
+    const pkg = JSON.parse(fs.readFileSync(path.join(tempProjectDir, 'package.json'), 'utf-8'));
+    expect(pkg.name).toBe('test-saas-api');
+    expect(pkg.scripts.dev).toContain('bun');
+    expect(pkg.scripts.compile).toContain('fire compile');
+  });
+
+  it('renders a visual terminal route table via formatRoutesTable()', () => {
+    const router = createRouter('/api/v1');
+
+    router.get('/items', {
+      cache: { ttl: 60 },
+      ai: { description: 'Fetch all catalog items' },
+      handler: (ctx) => ctx.ok([]),
+    });
+
+    router.post('/items', {
+      idempotent: true,
+      roles: ['admin', 'manager'],
+      ai: { description: 'Create a new catalog item' },
+      handler: (ctx) => ctx.created({}),
+    });
+
+    const output = formatRoutesTable(router);
+
+    expect(output).toContain('FireAPI Route Manifest');
+    expect(output).toContain('GET');
+    expect(output).toContain('/api/v1/items');
+    expect(output).toContain('POST');
+    expect(output).toContain('admin, manager');
+    expect(output).toContain('Fetch all catalog items');
+  });
+});

package/test/client.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'bun:test';
+import { createClient } from '../src/client';
+
+describe('FireAPI FireClient E2E Type-Safe RPC', () => {
+  it('constructs correct HTTP requests from proxy path calls', async () => {
+    let capturedUrl = '';
+    let capturedMethod = '';
+    let capturedBody = '';
+
+    const mockFetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+      capturedUrl = input.toString();
+      capturedMethod = init?.method || 'GET';
+      capturedBody = init?.body ? String(init.body) : '';
+      return new Response(JSON.stringify({ ok: true, id: '123' }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    };
+
+    const client = createClient('http://localhost:3000', { fetch: mockFetch });
+
+    // Call GET /api/v1/health
+    const res1 = await client.api.v1.health.get();
+    expect(capturedUrl).toBe('http://localhost:3000/api/v1/health');
+    expect(capturedMethod).toBe('GET');
+    expect(res1.ok).toBe(true);
+    expect(res1.data).toEqual({ ok: true, id: '123' });
+
+    // Call POST /users with body
+    const res2 = await client.users.post({
+      body: { name: 'Alice', email: 'alice@fire.dev' },
+    });
+    expect(capturedUrl).toBe('http://localhost:3000/users');
+    expect(capturedMethod).toBe('POST');
+    expect(JSON.parse(capturedBody)).toEqual({ name: 'Alice', email: 'alice@fire.dev' });
+
+    // Call GET /users/:id with params substitution
+    await client.users[':id'].get({ params: { id: 'usr_99' } });
+    expect(capturedUrl).toBe('http://localhost:3000/users/usr_99');
+  });
+
+  it('handles query parameters accurately', async () => {
+    let capturedUrl = '';
+    const mockFetch = async (input: RequestInfo | URL) => {
+      capturedUrl = input.toString();
+      return new Response(JSON.stringify([]));
+    };
+
+    const client = createClient('http://localhost:3000', { fetch: mockFetch });
+    await client.posts.get({ query: { page: '2', limit: '10' } });
+
+    expect(capturedUrl).toBe('http://localhost:3000/posts?page=2&limit=10');
+  });
+});

package/test/collection-export.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'bun:test';
+import { createApp, createRouter, s } from '../src/index';
+
+describe('FireAPI One-Click Postman & Bruno Collection Exporter', () => {
+  it('serves Postman Collection v2.1.0 specification at /docs/collection.json', async () => {
+    const app = createApp({
+      docs: '/docs',
+      openapiPath: '/openapi.json',
+    });
+
+    const router = createRouter('/articles');
+    router.get('/', {
+      ai: { description: 'Get all articles' },
+      handler: (ctx) => ctx.ok([]),
+    });
+
+    router.post('/', {
+      schema: {
+        body: s.object({
+          title: s.string().min(5),
+          content: s.string().min(10),
+        }),
+      },
+      ai: { description: 'Create an article' },
+      handler: (ctx) => ctx.created(ctx.body),
+    });
+
+    app.use(router);
+
+    const res = await app.handle(new Request('http://localhost:3000/docs/collection.json'));
+    expect(res.status).toBe(200);
+
+    const collection = await res.json();
+    expect(collection.info.schema).toContain('v2.1.0');
+    expect(Array.isArray(collection.item)).toBe(true);
+
+    const getArticle = collection.item.find((i: any) => i.name === 'GET /articles');
+    expect(getArticle).toBeDefined();
+    expect(getArticle.request.method).toBe('GET');
+
+    const postArticle = collection.item.find((i: any) => i.name === 'POST /articles');
+    expect(postArticle).toBeDefined();
+    expect(postArticle.request.method).toBe('POST');
+    expect(postArticle.request.body).toBeDefined();
+    expect(postArticle.request.body.mode).toBe('raw');
+
+    // Parse the auto-generated mock body inside the collection!
+    const mockPayload = JSON.parse(postArticle.request.body.raw);
+    expect(typeof mockPayload.title).toBe('string');
+    expect(typeof mockPayload.content).toBe('string');
+  });
+});

package/test/compat.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'bun:test';
+import { fromExpress } from '../src/compat/express';
+import { createApp } from '../src/core/app';
+
+describe('FireAPI Express Compatibility Bridge (fire-api/compat)', () => {
+  it('bridges standard Express middleware that modifies headers or state', async () => {
+    const app = createApp();
+
+    // Standard Express middleware: (req, res, next)
+    const expressLogger = (req: any, res: any, next: any) => {
+      req.customId = 'exp_123';
+      res.setHeader('X-Express-Bridged', 'true');
+      next();
+    };
+
+    app.get('/test-compat', {
+      middlewares: [fromExpress(expressLogger)],
+      handler: (ctx) => {
+        return ctx.ok({ bridgedId: (ctx.req as any).customId });
+      },
+    });
+
+    const res = await app.handle(new Request('http://localhost:3000/test-compat'));
+    expect(res.status).toBe(200);
+    expect(res.headers.get('x-express-bridged')).toBe('true');
+    const data = await res.json();
+    expect(data.bridgedId).toBe('exp_123');
+  });
+
+  it('handles early termination from Express middleware (e.g. res.status().json())', async () => {
+    const app = createApp();
+
+    // Middleware that intercepts and rejects early
+    const expressBlocker = (_req: any, res: any, _next: any) => {
+      res.status(403).json({ blockedBy: 'express-guard' });
+    };
+
+    app.get('/blocked', {
+      middlewares: [fromExpress(expressBlocker)],
+      handler: (ctx) => ctx.ok({ secret: 'never reached' }),
+    });
+
+    const res = await app.handle(new Request('http://localhost:3000/blocked'));
+    expect(res.status).toBe(403);
+    const data = await res.json();
+    expect(data.blockedBy).toBe('express-guard');
+  });
+});

package/test/compress.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'bun:test';
+import { compressResponse } from '../src/shield/compress';
+
+describe('FireAPI Native HTTP Stream Compression (Gzip / Web Standard)', () => {
+  it('compresses JSON response when client accepts gzip and payload exceeds threshold', async () => {
+    // Generate JSON payload larger than 1KB
+    const largeData = { items: Array.from({ length: 100 }, (_, i) => ({ id: i, name: `Item ${i}` })) };
+    const rawResponse = new Response(JSON.stringify(largeData), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+
+    const reqWithGzip = new Request('http://localhost:3000/items', {
+      headers: { 'Accept-Encoding': 'gzip, deflate' },
+    });
+
+    const compressed = await compressResponse(rawResponse, reqWithGzip, { threshold: 100 });
+
+    expect(compressed.headers.get('Content-Encoding')).toBe('gzip');
+    expect(compressed.headers.get('Vary')).toContain('Accept-Encoding');
+
+    // Decompress with DecompressionStream to verify integrity
+    const decompressedStream = compressed.body!.pipeThrough(new DecompressionStream('gzip'));
+    const text = await new Response(decompressedStream).text();
+    expect(JSON.parse(text)).toEqual(largeData);
+  });
+
+  it('skips compression if payload is smaller than threshold', async () => {
+    const tinyResponse = new Response(JSON.stringify({ ok: true }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+    const reqWithGzip = new Request('http://localhost:3000/tiny', {
+      headers: { 'Accept-Encoding': 'gzip' },
+    });
+
+    const result = await compressResponse(tinyResponse, reqWithGzip, { threshold: 1000 });
+    expect(result.headers.get('Content-Encoding')).toBeNull();
+  });
+
+  it('skips compression if client does not accept gzip', async () => {
+    const rawResponse = new Response(JSON.stringify({ text: 'a'.repeat(2000) }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+    const reqWithoutGzip = new Request('http://localhost:3000/no-gzip');
+
+    const result = await compressResponse(rawResponse, reqWithoutGzip, { threshold: 100 });
+    expect(result.headers.get('Content-Encoding')).toBeNull();
+  });
+});

package/test/context.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'bun:test';
+import { createContext } from '../src/core/context';
+import { HttpError } from '../src/core/error';
+
+describe('FireAPI FireContext & Error Handling', () => {
+  it('parses URL, query parameters and route parameters', () => {
+    const req = new Request('http://localhost:3000/users/42?filter=active&sort=desc');
+    const ctx = createContext({
+      req,
+      params: { id: '42' },
+    });
+
+    expect(ctx.params.id).toBe('42');
+    expect(ctx.query.filter).toBe('active');
+    expect(ctx.query.sort).toBe('desc');
+  });
+
+  it('produces standard JSON responses with status codes', async () => {
+    const req = new Request('http://localhost:3000/items');
+    const ctx = createContext({ req });
+
+    const okRes = ctx.ok({ success: true });
+    expect(okRes.status).toBe(200);
+    expect(await okRes.json()).toEqual({ success: true });
+
+    const createdRes = ctx.created({ id: 'new_1' });
+    expect(createdRes.status).toBe(201);
+    expect(await createdRes.json()).toEqual({ id: 'new_1' });
+
+    const notFoundRes = ctx.notFound('Item not found');
+    expect(notFoundRes.status).toBe(404);
+    expect(await notFoundRes.json()).toEqual({
+      statusCode: 404,
+      error: 'Not Found',
+      message: 'Item not found',
+    });
+  });
+
+  it('supports custom HttpError throwing and serialization', () => {
+    const err = new HttpError(400, 'Invalid payload', { field: 'email' });
+    expect(err.statusCode).toBe(400);
+    expect(err.message).toBe('Invalid payload');
+    expect(err.details).toEqual({ field: 'email' });
+
+    const response = err.toResponse();
+    expect(response.status).toBe(400);
+  });
+});

package/test/db.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'bun:test';
+import { MemoryDatabase } from '../src/db/memory-adapter';
+import { createDatabaseHub } from '../src/db/hub';
+
+describe('FireAPI FireDB Universal Hub & Memory Adapter', () => {
+  it('supports insert, find, findById, and where filtering', async () => {
+    const db = new MemoryDatabase();
+
+    const inserted = await db.table('users').insert({
+      name: 'Yoga',
+      email: 'yoga@fire.dev',
+      role: 'admin',
+    });
+
+    expect(inserted.id).toBeDefined();
+    expect(inserted.name).toBe('Yoga');
+
+    const users = await db.table('users').where('role', 'admin').find();
+    expect(users.length).toBe(1);
+    expect(users[0].email).toBe('yoga@fire.dev');
+
+    const userById = await db.table('users').findById(inserted.id);
+    expect(userById?.name).toBe('Yoga');
+  });
+
+  it('supports update and delete operations', async () => {
+    const db = new MemoryDatabase();
+
+    const item = await db.table('products').insert({ title: 'MacBook', price: 2000 });
+    
+    // Update
+    const updated = await db.table('products').where('id', item.id).update({ price: 1800 });
+    expect(updated.price).toBe(1800);
+
+    // Delete
+    const deleted = await db.table('products').where('id', item.id).delete();
+    expect(deleted.count).toBe(1);
+
+    const remaining = await db.table('products').find();
+    expect(remaining.length).toBe(0);
+  });
+
+  it('supports transactions in memory adapter', async () => {
+    const db = new MemoryDatabase();
+
+    await db.transaction(async (trx) => {
+      await trx.table('logs').insert({ action: 'audit_start' });
+      await trx.table('logs').insert({ action: 'audit_end' });
+    });
+
+    const logs = await db.table('logs').find();
+    expect(logs.length).toBe(2);
+  });
+
+  it('initializes seamlessly via createDatabaseHub', async () => {
+    const hub = createDatabaseHub({ driver: 'memory', autoMock: true });
+    expect(hub).toBeDefined();
+
+    const res = await hub.table('test').insert({ status: 'ready' });
+    expect(res.status).toBe('ready');
+  });
+});

package/test/docker.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'bun:test';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { generateDockerFiles } from '../src/cli/docker';
+
+describe('FireAPI One-Command Distroless Docker Synthesizer', () => {
+  it('generates production-hardened multi-stage Dockerfile and .dockerignore', () => {
+    const testDir = path.join(process.cwd(), 'temp_test_docker');
+    if (!fs.existsSync(testDir)) fs.mkdirSync(testDir, { recursive: true });
+
+    const result = generateDockerFiles(testDir);
+
+    expect(fs.existsSync(result.dockerfilePath)).toBe(true);
+    expect(fs.existsSync(result.dockerignorePath)).toBe(true);
+
+    const dockerfileContent = fs.readFileSync(result.dockerfilePath, 'utf-8');
+    expect(dockerfileContent).toContain('FROM oven/bun:alpine AS base');
+    expect(dockerfileContent).toContain('USER appuser');
+    expect(dockerfileContent).toContain('EXPOSE 3000');
+
+    const ignoreContent = fs.readFileSync(result.dockerignorePath, 'utf-8');
+    expect(ignoreContent).toContain('node_modules');
+    expect(ignoreContent).toContain('.git');
+
+    // Clean up
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+});

package/test/events.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'bun:test';
+import { createApp, createRouter } from '../src/index';
+
+describe('FireAPI Typed In-Process Event Bus (app.on, ctx.emit)', () => {
+  it('subscribes to and receives typed events triggered via ctx.emit()', async () => {
+    const app = createApp();
+    const router = createRouter();
+
+    let eventReceived: any = null;
+
+    app.on('order.paid', async (payload) => {
+      eventReceived = payload;
+    });
+
+    router.post('/checkout', async (ctx) => {
+      await ctx.emit('order.paid', { orderId: 'ORD_999', total: 450 });
+      return ctx.ok({ status: 'dispatched' });
+    });
+
+    app.use(router);
+
+    const res = await app.handle(
+      new Request('http://localhost:3000/checkout', { method: 'POST' })
+    );
+
+    expect(res.status).toBe(200);
+    expect(eventReceived).not.toBeNull();
+    expect(eventReceived.orderId).toBe('ORD_999');
+    expect(eventReceived.total).toBe(450);
+  });
+
+  it('supports wildcard listeners (e.g. user.*)', async () => {
+    const app = createApp();
+    const capturedEvents: string[] = [];
+
+    app.on('user.*', async (payload) => {
+      capturedEvents.push(payload.action);
+    });
+
+    await app.emit('user.registered', { action: 'REGISTER' });
+    await app.emit('user.login', { action: 'LOGIN' });
+    await app.emit('order.created', { action: 'ORDER' }); // Should NOT match
+
+    expect(capturedEvents).toEqual(['REGISTER', 'LOGIN']);
+  });
+
+  it('allows unsubscribing from events cleanly', async () => {
+    const app = createApp();
+    let callCount = 0;
+
+    const unsubscribe = app.on('ping', () => {
+      callCount++;
+    });
+
+    await app.emit('ping', {});
+    expect(callCount).toBe(1);
+
+    unsubscribe();
+    await app.emit('ping', {});
+    expect(callCount).toBe(1); // Not called after unsubscribe
+  });
+});