@proulr/bff-core 0.1.5 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proulr/bff-core",
-  "version": "0.1.5",
+  "version": "0.1.8",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -20,18 +20,21 @@
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "test:integration:coverage": "vitest run --config vitest.integration.config.ts --coverage",
     "prepublishOnly": "npm run typecheck",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "version:sync": "node ../scripts/proulr-bump-and-sync-deps.mjs"
+    "version:sync": "node ../scripts/proulr-bump-and-sync-deps.mjs",
+    "test:coverage": "vitest run --coverage"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
     "@hono/node-server": "^1.19.6",
-    "@proulr/rosetta": "^0.1.4",
-    "@proulr/sdui-contract": "^0.1.5",
+    "@proulr/rosetta": "^0.1.23",
+    "@proulr/sdui-contract": "^0.1.10",
     "@supabase/supabase-js": "^2.107.0",
     "dotenv": "^16.6.1",
     "hono": "^4.10.6",
@@ -40,6 +43,7 @@
   "devDependencies": {
     "@eslint/js": "^9.39.4",
     "@types/node": "^22.10.0",
+    "@vitest/coverage-v8": "^3.2.7",
     "eslint": "^9.0.0",
     "globals": "^16.0.0",
     "husky": "^9.1.7",

package/src/index.integration.test.ts

@@ -0,0 +1,212 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+type ServeCallback = (info: { address: string; family: string; port: number }) => void;
+
+const serveMock = vi.fn((opts: unknown, cb?: ServeCallback) => {
+  void opts;
+  cb?.({ address: '0.0.0.0', family: 'IPv4', port: 9999 });
+  return { close: vi.fn() };
+});
+
+vi.mock('@hono/node-server', () => ({
+  serve: (opts: unknown, cb?: ServeCallback) => serveMock(opts, cb),
+}));
+
+import { createSduiBff } from './index';
+
+function createTestApp(overrides?: {
+  metricsEnv?: string;
+  actions?: Parameters<typeof createSduiBff>[0]['actions'];
+}) {
+  if (overrides?.metricsEnv !== undefined) {
+    vi.stubEnv('BFF_METRICS', overrides.metricsEnv);
+  }
+  return createSduiBff({
+    name: 'Integration BFF',
+    port: 9999,
+    bffId: 'integration-bff',
+    screens: {
+      'demo.home': async (ctx) => ({
+        schema_version: 1,
+        screen_id: 'demo.home',
+        blocks: [],
+        data: {
+          auth_token: ctx.authToken ?? null,
+          locale: ctx.query?.locale ?? null,
+        },
+        meta: { bff: 'integration-bff' },
+      }),
+    },
+    actions: overrides?.actions ?? {
+      ping: async (_ctx, body) => ({ echo: body }),
+      boom: async () => {
+        throw new Error('boom_failed');
+      },
+      boom_string: async () => {
+        throw 'string_error';
+      },
+    },
+  });
+}
+
+describe('createSduiBff HTTP integration', () => {
+  beforeEach(() => {
+    serveMock.mockClear();
+    vi.unstubAllEnvs();
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it('serves /health with screens and metrics flag', async () => {
+    const { app } = createTestApp({ metricsEnv: '1' });
+    const response = await app.request('/health');
+    expect(response.status).toBe(200);
+    expect(response.headers.get('X-Request-Id')).toBeTruthy();
+    await expect(response.json()).resolves.toMatchObject({
+      ok: true,
+      bff: 'integration-bff',
+      name: 'Integration BFF',
+      screens: ['demo.home'],
+      metrics_enabled: true,
+    });
+  });
+
+  it('returns screen wire and parses Bearer auth + query', async () => {
+    const { app } = createTestApp();
+    const response = await app.request('/v1/screens/demo.home?locale=pt-BR', {
+      headers: { Authorization: 'Bearer  tok-abc  ' },
+    });
+    expect(response.status).toBe(200);
+    const body = await response.json();
+    expect(body.screen_id).toBe('demo.home');
+    expect(body.data).toMatchObject({ auth_token: 'tok-abc', locale: 'pt-BR' });
+  });
+
+  it('ignores non-Bearer Authorization header', async () => {
+    const { app } = createTestApp();
+    const response = await app.request('/v1/screens/demo.home', {
+      headers: { Authorization: 'Basic abc' },
+    });
+    expect(response.status).toBe(200);
+    const body = await response.json();
+    expect(body.data.auth_token).toBeNull();
+  });
+
+  it('returns 404 for unknown screen', async () => {
+    const { app } = createTestApp();
+    const response = await app.request('/v1/screens/missing.screen');
+    expect(response.status).toBe(404);
+    await expect(response.json()).resolves.toMatchObject({
+      error: 'screen_not_found',
+      screen_id: 'missing.screen',
+    });
+  });
+
+  it('invokes registered action with auth and body', async () => {
+    const { app } = createTestApp();
+    const response = await app.request('/v1/actions/ping', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: 'Bearer act-tok',
+      },
+      body: JSON.stringify({ n: 1 }),
+    });
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      ok: true,
+      action_id: 'ping',
+      echo: { n: 1 },
+    });
+  });
+
+  it('returns 404 stub for unknown action', async () => {
+    const { app } = createTestApp({ actions: {} });
+    const response = await app.request('/v1/actions/noop', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({}),
+    });
+    expect(response.status).toBe(404);
+    await expect(response.json()).resolves.toMatchObject({
+      ok: false,
+      error: 'action_not_found',
+      action_id: 'noop',
+    });
+  });
+
+  it('returns 500 when action throws Error', async () => {
+    const { app } = createTestApp();
+    const response = await app.request('/v1/actions/boom', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({}),
+    });
+    expect(response.status).toBe(500);
+    await expect(response.json()).resolves.toMatchObject({
+      ok: false,
+      error: 'action_failed',
+      message: 'boom_failed',
+      action_id: 'boom',
+    });
+  });
+
+  it('returns 500 with fallback message for non-Error throw', async () => {
+    const { app } = createTestApp();
+    const response = await app.request('/v1/actions/boom_string', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: '{}',
+    });
+    expect(response.status).toBe(500);
+    await expect(response.json()).resolves.toMatchObject({
+      ok: false,
+      error: 'action_failed',
+      message: 'action_failed',
+    });
+  });
+
+  it('accepts invalid JSON action body as empty object', async () => {
+    const { app } = createTestApp();
+    const response = await app.request('/v1/actions/ping', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: '{not-json',
+    });
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      ok: true,
+      echo: {},
+    });
+  });
+
+  it('serves /metrics when metrics enabled', async () => {
+    const { app } = createTestApp({ metricsEnv: '1' });
+    await app.request('/health');
+    const response = await app.request('/metrics');
+    expect(response.status).toBe(200);
+    expect(response.headers.get('Content-Type')).toContain('text/plain');
+    const text = await response.text();
+    expect(text).toContain('bff_http_requests_total');
+  });
+
+  it('does not register /metrics when BFF_METRICS=0', async () => {
+    const { app } = createTestApp({ metricsEnv: '0' });
+    const health = await app.request('/health');
+    await expect(health.json()).resolves.toMatchObject({ metrics_enabled: false });
+    const metrics = await app.request('/metrics');
+    expect(metrics.status).toBe(404);
+  });
+
+  it('start() binds via @hono/node-server serve', () => {
+    const { start } = createTestApp({ metricsEnv: '0' });
+    start();
+    expect(serveMock).toHaveBeenCalledOnce();
+    expect(serveMock.mock.calls[0]?.[0]).toMatchObject({
+      port: 9999,
+      hostname: '0.0.0.0',
+    });
+  });
+});

package/src/index.test.ts

@@ -1,93 +1,7 @@
 import { describe, expect, it } from 'vitest';
-import { createSduiBff } from './index';
 import { createScreenBuilderContext } from './testing/create-screen-builder-context';
 import { createMockSupabaseClient } from './testing/create-mock-supabase-client';
-
-describe('createSduiBff', () => {
-  it('serves /health with registered screens', async () => {
-    const { app } = createSduiBff({
-      name: 'Test BFF',
-      port: 9999,
-      bffId: 'test-bff',
-      screens: {
-        'demo.home': async () => ({
-          schema_version: 1,
-          screen_id: 'demo.home',
-          blocks: [],
-        }),
-      },
-    });
-
-    const response = await app.request('/health');
-    expect(response.status).toBe(200);
-    const body = await response.json();
-    expect(body).toMatchObject({
-      ok: true,
-      bff: 'test-bff',
-      name: 'Test BFF',
-      screens: ['demo.home'],
-    });
-  });
-
-  it('returns 404 for unknown screen', async () => {
-    const { app } = createSduiBff({
-      name: 'Test BFF',
-      port: 9999,
-      bffId: 'test-bff',
-      screens: {},
-    });
-
-    const response = await app.request('/v1/screens/missing');
-    expect(response.status).toBe(404);
-    const body = await response.json();
-    expect(body).toMatchObject({ error: 'screen_not_found', screen_id: 'missing' });
-  });
-
-  it('returns 404 stub for unknown action', async () => {
-    const { app } = createSduiBff({
-      name: 'Test BFF',
-      port: 9999,
-      bffId: 'test-bff',
-      screens: {},
-    });
-
-    const response = await app.request('/v1/actions/noop', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({}),
-    });
-    expect(response.status).toBe(404);
-    const body = await response.json();
-    expect(body).toMatchObject({ ok: false, error: 'action_not_found', action_id: 'noop' });
-  });
-
-  it('invokes registered screen builder with auth token', async () => {
-    let seenToken: string | undefined;
-    const { app } = createSduiBff({
-      name: 'Test BFF',
-      port: 9999,
-      bffId: 'test-bff',
-      screens: {
-        'demo.home': async (ctx) => {
-          seenToken = ctx.authToken;
-          return {
-            schema_version: 1,
-            screen_id: 'demo.home',
-            blocks: [{ id: 'root', type: 'stack', props: {} }],
-          };
-        },
-      },
-    });
-
-    const response = await app.request('/v1/screens/demo.home', {
-      headers: { Authorization: 'Bearer tok-123' },
-    });
-    expect(response.status).toBe(200);
-    expect(seenToken).toBe('tok-123');
-    const body = await response.json();
-    expect(body.screen_id).toBe('demo.home');
-  });
-});
+import { createTestSduiBff } from './testing/create-test-sdui-bff';
 
 describe('testing helpers', () => {
   it('createScreenBuilderContext defaults empty maps', () => {
@@ -114,4 +28,15 @@ describe('testing helpers', () => {
     const rpc = await client.rpc('ping');
     expect(rpc.data).toBe(true);
   });
+
+  it('createTestSduiBff exposes app.request without start', async () => {
+    const { app } = createTestSduiBff({
+      name: 'Unit',
+      port: 1,
+      bffId: 'unit',
+      screens: {},
+    });
+    const response = await app.request('/health');
+    expect(response.status).toBe(200);
+  });
 });