@tamayrp14/fire-api 0.0.0-stage → 1.0.1

package/test/static-serve.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it, afterAll } from 'bun:test';
+import { createApp } from '../src/index';
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('FireAPI Static Assets & SPA Serving (app.serveStatic, app.serveSPA)', () => {
+  const tempDir = path.resolve('./temp_static_test');
+
+  if (!fs.existsSync(tempDir)) {
+    fs.mkdirSync(tempDir, { recursive: true });
+    fs.writeFileSync(path.join(tempDir, 'style.css'), 'body { background: #000; }');
+    fs.writeFileSync(path.join(tempDir, 'app.js'), 'console.log("hello");');
+    fs.writeFileSync(path.join(tempDir, 'index.html'), '<html><body>SPA Root</body></html>');
+  }
+
+  afterAll(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it('serves static files with correct MIME types and headers', async () => {
+    const app = createApp();
+    app.serveStatic('/assets', tempDir);
+
+    // 1. Fetch style.css
+    const resCss = await app.handle(new Request('http://localhost:3000/assets/style.css'));
+    expect(resCss.status).toBe(200);
+    expect(resCss.headers.get('Content-Type')).toContain('text/css');
+    const textCss = await resCss.text();
+    expect(textCss).toBe('body { background: #000; }');
+
+    // 2. Fetch app.js
+    const resJs = await app.handle(new Request('http://localhost:3000/assets/app.js'));
+    expect(resJs.status).toBe(200);
+    expect(resJs.headers.get('Content-Type')).toContain('application/javascript');
+
+    // 3. 404 for non-existent file
+    const res404 = await app.handle(new Request('http://localhost:3000/assets/missing.png'));
+    expect(res404.status).toBe(404);
+  });
+
+  it('serves SPA fallback HTML for client-side routing', async () => {
+    const app = createApp();
+    app.serveSPA('/app', path.join(tempDir, 'index.html'));
+
+    const res = await app.handle(new Request('http://localhost:3000/app'));
+    expect(res.status).toBe(200);
+    expect(res.headers.get('Content-Type')).toContain('text/html');
+    const textHtml = await res.text();
+    expect(textHtml).toContain('SPA Root');
+  });
+});

package/test/storage.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'bun:test';
+import { MemoryStorageAdapter } from '../src/storage/storage';
+
+describe('FireAPI Universal Object Storage Hub (fire-api/storage)', () => {
+  it('stores, retrieves, and checks existence of files in storage', async () => {
+    const storage = new MemoryStorageAdapter({ baseUrl: 'http://localhost:3000/uploads' });
+
+    const content = 'User avatar raw binary or string data';
+    const result = await storage.put('avatars/usr_1.png', content, { contentType: 'image/png' });
+
+    expect(result.path).toBe('avatars/usr_1.png');
+    expect(result.url).toBe('http://localhost:3000/uploads/avatars/usr_1.png');
+    expect(result.size).toBe(content.length);
+
+    expect(await storage.exists('avatars/usr_1.png')).toBe(true);
+    expect(await storage.exists('avatars/non_existent.png')).toBe(false);
+
+    const retrievedText = await storage.getText('avatars/usr_1.png');
+    expect(retrievedText).toBe(content);
+  });
+
+  it('deletes files from storage cleanly', async () => {
+    const storage = new MemoryStorageAdapter();
+    await storage.put('temp.txt', 'Delete me');
+
+    expect(await storage.exists('temp.txt')).toBe(true);
+    const deleted = await storage.delete('temp.txt');
+    expect(deleted).toBe(true);
+    expect(await storage.exists('temp.txt')).toBe(false);
+  });
+});

package/test/studio.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'bun:test';
+import { createApp, createRouter } from '../src/index';
+import { enableStudio } from '../src/studio/studio';
+
+describe('FireAPI FireStudio Embedded Dev Dashboard (fire-api/studio)', () => {
+  it('serves the Studio dashboard HTML and overview data', async () => {
+    const app = createApp({ database: { driver: 'memory' } });
+    
+    // Seed some data
+    await app.db.table('users').insert({ name: 'Alice', role: 'admin' });
+    await app.db.table('posts').insert({ title: 'Welcome to FireAPI' });
+
+    const router = createRouter('/api');
+    router.get('/health', { handler: (ctx) => ctx.ok({ status: 'ok' }) });
+    app.use(router);
+
+    // Enable studio
+    enableStudio(app, { path: '/studio' });
+
+    // 1. Test HTML Dashboard
+    const htmlRes = await app.handle(new Request('http://localhost:3000/studio'));
+    expect(htmlRes.status).toBe(200);
+    expect(htmlRes.headers.get('content-type')).toContain('text/html');
+    const html = await htmlRes.text();
+    expect(html).toContain('FireStudio');
+    expect(html).toContain('Database Explorer');
+
+    // 2. Test Overview API
+    const overviewRes = await app.handle(new Request('http://localhost:3000/studio/api/overview'));
+    expect(overviewRes.status).toBe(200);
+    const overview = await overviewRes.json();
+    expect(overview.tables).toContain('users');
+    expect(overview.tables).toContain('posts');
+    expect(overview.routesCount).toBeGreaterThan(0);
+
+    // 3. Test Table Data API
+    const tableRes = await app.handle(new Request('http://localhost:3000/studio/api/tables/users'));
+    expect(tableRes.status).toBe(200);
+    const users = await tableRes.json();
+    expect(users.length).toBe(1);
+    expect(users[0].name).toBe('Alice');
+  });
+});

package/test/tx.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'bun:test';
+import { createApp, createRouter } from '../src/index';
+
+describe('FireAPI Atomic Transaction Scope (ctx.db.tx)', () => {
+  it('commits multi-table operations atomically when transaction succeeds', async () => {
+    const app = createApp({ database: { driver: 'memory' } });
+    const router = createRouter();
+
+    router.post('/checkout', async (ctx) => {
+      const result = await ctx.db.tx(async (trx) => {
+        const user = await trx.users.insert({ name: 'Alice', balance: 500 });
+        const order = await trx.orders.insert({ userId: user.id, total: 150 });
+        const log = await trx.audit_logs.insert({ action: 'CHECKOUT_SUCCESS', orderId: order.id });
+        return { user, order, log };
+      });
+
+      return ctx.created(result);
+    });
+
+    app.use(router);
+
+    const res = await app.handle(
+      new Request('http://localhost:3000/checkout', { method: 'POST' })
+    );
+
+    expect(res.status).toBe(201);
+
+    // Verify all records were committed
+    const users = await app.db.users.find();
+    const orders = await app.db.orders.find();
+    const logs = await app.db.audit_logs.find();
+
+    expect(users.length).toBe(1);
+    expect(orders.length).toBe(1);
+    expect(logs.length).toBe(1);
+    expect(users[0].name).toBe('Alice');
+    expect(orders[0].total).toBe(150);
+  });
+
+  it('automatically rolls back all multi-table changes when transaction callback throws', async () => {
+    const app = createApp({ database: { driver: 'memory' } });
+    const router = createRouter();
+
+    // Pre-populate with initial user
+    await app.db.users.insert({ id: 'existing_user', name: 'Bob', balance: 1000 });
+
+    router.post('/transfer-fail', async (ctx) => {
+      try {
+        await ctx.db.tx(async (trx) => {
+          // 1. Deduct balance from existing user
+          await trx.users.update('existing_user', { balance: 800 });
+
+          // 2. Insert new recipient user
+          await trx.users.insert({ id: 'new_recipient', name: 'Charlie', balance: 200 });
+
+          // 3. Insert transaction record
+          await trx.transfers.insert({ from: 'existing_user', to: 'new_recipient', amount: 200 });
+
+          // 4. Simulate a failure (e.g. external network error or validation failure)
+          throw new Error('Anti-fraud check triggered: transfer rejected');
+        });
+      } catch (err: any) {
+        return ctx.badRequest({ message: err.message });
+      }
+
+      return ctx.ok({ success: true });
+    });
+
+    app.use(router);
+
+    const res = await app.handle(
+      new Request('http://localhost:3000/transfer-fail', { method: 'POST' })
+    );
+
+    expect(res.status).toBe(400);
+    const body = await res.json();
+    expect(body.message).toContain('Anti-fraud check triggered');
+
+    // VERIFY AUTO-ROLLBACK:
+    // 1. Existing user balance must still be 1000 (NOT 800)
+    const existingUser = await app.db.users.findById('existing_user');
+    expect(existingUser.balance).toBe(1000);
+
+    // 2. New recipient must NOT exist
+    const recipient = await app.db.users.findById('new_recipient');
+    expect(recipient).toBeNull();
+
+    // 3. Transfers table must have 0 rows
+    const transfers = await app.db.transfers.find();
+    expect(transfers.length).toBe(0);
+  });
+});

package/test/webhook.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it } from 'bun:test';
+import { createApp, createRouter } from '../src/index';
+import { computeHMAC } from '../src/shield/webhook';
+
+describe('FireAPI Turnkey Webhook HMAC Verifier (ctx.webhook.verifyHMAC)', () => {
+  it('verifies standard SHA-256 HMAC signature using raw request body', async () => {
+    const app = createApp();
+    const router = createRouter();
+    const secret = 'super-secret-signing-key-999';
+
+    router.post('/webhooks/payment', async (ctx) => {
+      const isValid = await ctx.webhook.verifyHMAC({
+        secret,
+        header: 'x-signature-256',
+      });
+
+      if (!isValid) {
+        return ctx.unauthorized('Invalid webhook signature');
+      }
+
+      return ctx.ok({ verified: true, event: ctx.body.event });
+    });
+
+    app.use(router);
+
+    const payload = JSON.stringify({ event: 'charge.succeeded', amount: 5000 });
+    const validSignature = await computeHMAC(payload, secret, 'SHA-256');
+
+    // 1. Valid Signature -> 200 OK
+    const resValid = await app.handle(
+      new Request('http://localhost:3000/webhooks/payment', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-signature-256': validSignature,
+        },
+        body: payload,
+      })
+    );
+
+    expect(resValid.status).toBe(200);
+    const bodyValid = await resValid.json();
+    expect(bodyValid.verified).toBe(true);
+    expect(bodyValid.event).toBe('charge.succeeded');
+
+    // 2. Tampered Payload with same signature -> 401 Unauthorized
+    const tamperedPayload = JSON.stringify({ event: 'charge.succeeded', amount: 999999 });
+    const resTampered = await app.handle(
+      new Request('http://localhost:3000/webhooks/payment', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-signature-256': validSignature,
+        },
+        body: tamperedPayload,
+      })
+    );
+
+    expect(resTampered.status).toBe(401);
+
+    // 3. Forged Signature -> 401 Unauthorized
+    const resForged = await app.handle(
+      new Request('http://localhost:3000/webhooks/payment', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-signature-256': 'badf00d1234567890abcdef',
+        },
+        body: payload,
+      })
+    );
+
+    expect(resForged.status).toBe(401);
+  });
+
+  it('supports GitHub (sha256=...) and auto-detected header prefixes', async () => {
+    const app = createApp();
+    const router = createRouter();
+    const secret = 'github-webhook-secret';
+
+    router.post('/webhooks/github', async (ctx) => {
+      // Header omitted: auto-detects 'x-hub-signature-256'
+      const isValid = await ctx.webhook.verifyHMAC({ secret });
+
+      if (!isValid) {
+        return ctx.forbidden('Webhook signature mismatch');
+      }
+
+      return ctx.ok({ processed: true });
+    });
+
+    app.use(router);
+
+    const payload = JSON.stringify({ action: 'opened', repository: { name: 'API-FIRE' } });
+    const hexDigest = await computeHMAC(payload, secret, 'SHA-256');
+
+    // GitHub sends header with prefix 'sha256='
+    const res = await app.handle(
+      new Request('http://localhost:3000/webhooks/github', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Hub-Signature-256': `sha256=${hexDigest}`,
+        },
+        body: payload,
+      })
+    );
+
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.processed).toBe(true);
+  });
+});

package/test/ws.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'bun:test';
+import { WebSocketHub, MockWebSocket } from '../src/ws/ws';
+
+describe('FireAPI Native WebSockets with Rooms & Pub/Sub', () => {
+  it('manages rooms, joining, leaving, and publishing messages', () => {
+    const hub = new WebSocketHub();
+
+    const client1 = new MockWebSocket('ws_1');
+    const client2 = new MockWebSocket('ws_2');
+    const client3 = new MockWebSocket('ws_3');
+
+    const fireWs1 = hub.register(client1);
+    const fireWs2 = hub.register(client2);
+    const fireWs3 = hub.register(client3);
+
+    // Client 1 and 2 join room "chat:tech"
+    fireWs1.join('chat:tech');
+    fireWs2.join('chat:tech');
+
+    // Client 3 joins room "chat:random"
+    fireWs3.join('chat:random');
+
+    // Client 1 publishes message to "chat:tech"
+    fireWs1.publish('chat:tech', { user: 'Alice', text: 'Hello tech!' });
+
+    // Client 2 should receive the message
+    expect(client2.receivedMessages.length).toBe(1);
+    expect(JSON.parse(client2.receivedMessages[0])).toEqual({ user: 'Alice', text: 'Hello tech!' });
+
+    // Client 3 in another room should NOT receive it
+    expect(client3.receivedMessages.length).toBe(0);
+
+    // Client 2 leaves the room
+    fireWs2.leave('chat:tech');
+
+    // Client 1 publishes again
+    fireWs1.publish('chat:tech', { user: 'Alice', text: 'Anyone here?' });
+    expect(client2.receivedMessages.length).toBe(1); // Still 1, didn't receive second
+  });
+
+  it('broadcasts messages to all connected clients globally', () => {
+    const hub = new WebSocketHub();
+    const c1 = new MockWebSocket('c1');
+    const c2 = new MockWebSocket('c2');
+
+    const ws1 = hub.register(c1);
+    hub.register(c2);
+
+    ws1.broadcast({ announcement: 'System update in 5 mins' });
+
+    expect(c1.receivedMessages.length).toBe(1);
+    expect(c2.receivedMessages.length).toBe(1);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "rootDir": "./src",
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test"]
+}