@proulr/bff-core 0.1.0

package/README.md

@@ -0,0 +1,15 @@
+# proulr-bff-core
+
+Utilitários Hono compartilhados por todos os BFFs.
+
+## Endpoints
+
+- `GET /health`
+- `GET /v1/screens/:screenId`
+- `POST /v1/actions/:actionId` (stub)
+
+## Setup
+
+```bash
+npm install
+```

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@proulr/bff-core",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/saviorbp/proulr-bff-core.git"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.19.6",
+    "@proulr/sdui-contract": "^0.1.0",
+    "@supabase/supabase-js": "^2.107.0",
+    "dotenv": "^16.6.1",
+    "hono": "^4.10.6",
+    "prom-client": "^15.1.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "~6.0.3"
+  }
+}

package/src/bff-env-loader.ts

@@ -0,0 +1,22 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { config } from 'dotenv';
+
+let loaded = false;
+
+/** Loads `.env` from the BFF cwd, or falls back to `proulr-app/.env` in local dev. */
+export function loadBffEnv(): void {
+  if (loaded) return;
+  loaded = true;
+
+  const cwdEnv = resolve(process.cwd(), '.env');
+  if (existsSync(cwdEnv)) {
+    config({ path: cwdEnv });
+    return;
+  }
+
+  const appEnv = resolve(process.cwd(), '../proulr-app/.env');
+  if (existsSync(appEnv)) {
+    config({ path: appEnv });
+  }
+}

package/src/bff-metrics.ts

@@ -0,0 +1,35 @@
+import { Counter, Histogram, Registry, collectDefaultMetrics } from 'prom-client';
+
+export type BffMetrics = {
+  registry: Registry;
+  requestDuration: Histogram<'bff_id' | 'screen_id' | 'status' | 'method'>;
+  requestsTotal: Counter<'bff_id' | 'screen_id' | 'status' | 'method'>;
+};
+
+export function createBffMetrics(bffId: string): BffMetrics {
+  const registry = new Registry();
+  registry.setDefaultLabels({ bff_id: bffId });
+
+  collectDefaultMetrics({ register: registry, prefix: 'bff_' });
+
+  const requestDuration = new Histogram({
+    name: 'bff_http_request_duration_seconds',
+    help: 'BFF HTTP request duration in seconds',
+    labelNames: ['bff_id', 'screen_id', 'status', 'method'] as const,
+    buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10],
+    registers: [registry],
+  });
+
+  const requestsTotal = new Counter({
+    name: 'bff_http_requests_total',
+    help: 'Total BFF HTTP requests',
+    labelNames: ['bff_id', 'screen_id', 'status', 'method'] as const,
+    registers: [registry],
+  });
+
+  return { registry, requestDuration, requestsTotal };
+}
+
+export function isBffMetricsEnabled(): boolean {
+  return process.env.BFF_METRICS !== '0';
+}

package/src/bff-supabase-client.ts

@@ -0,0 +1,33 @@
+import { createClient, type SupabaseClient } from '@supabase/supabase-js';
+import { loadBffEnv } from './bff-env-loader';
+
+loadBffEnv();
+
+const supabaseUrl = process.env.SUPABASE_URL ?? process.env.EXPO_PUBLIC_SUPABASE_URL ?? '';
+const supabaseAnonKey =
+  process.env.SUPABASE_ANON_KEY ?? process.env.EXPO_PUBLIC_SUPABASE_ANON_KEY ?? '';
+
+export function isBffSupabaseConfigured(): boolean {
+  return Boolean(supabaseUrl && supabaseAnonKey);
+}
+
+export function createBffSupabaseClient(authToken?: string): SupabaseClient {
+  if (!isBffSupabaseConfigured()) {
+    throw new Error('bff_supabase_not_configured');
+  }
+
+  return createClient(supabaseUrl, supabaseAnonKey, {
+    auth: {
+      persistSession: false,
+      autoRefreshToken: false,
+      detectSessionInUrl: false,
+    },
+    global: authToken
+      ? {
+          headers: {
+            Authorization: `Bearer ${authToken}`,
+          },
+        }
+      : undefined,
+  });
+}

package/src/index.ts

@@ -0,0 +1,130 @@
+import { randomUUID } from 'node:crypto';
+import { serve } from '@hono/node-server';
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import type { SduiScreenBuilder, SduiScreenBuilderContext } from '@proulr/sdui-contract';
+import { createBffMetrics, isBffMetricsEnabled } from './bff-metrics';
+
+export type CreateSduiBffOptions = {
+  name: string;
+  port: number;
+  bffId: string;
+  screens: Record<string, SduiScreenBuilder>;
+};
+
+function buildContext(
+  routeParams: Record<string, string>,
+  query: Record<string, string>,
+  authToken?: string,
+): SduiScreenBuilderContext {
+  return { routeParams, query, authToken };
+}
+
+function readAuthToken(headerValue: string | undefined): string | undefined {
+  if (!headerValue) return undefined;
+  const match = headerValue.match(/^Bearer\s+(.+)$/i);
+  return match?.[1]?.trim() || undefined;
+}
+
+function resolveScreenId(path: string): string {
+  if (path.startsWith('/v1/screens/')) return path.slice('/v1/screens/'.length);
+  if (path.startsWith('/v1/actions/')) return `action:${path.slice('/v1/actions/'.length)}`;
+  if (path === '/health') return 'health';
+  if (path === '/metrics') return 'metrics';
+  return 'other';
+}
+
+export function createSduiBff(options: CreateSduiBffOptions) {
+  const app = new Hono();
+  const metricsEnabled = isBffMetricsEnabled();
+  const metrics = metricsEnabled ? createBffMetrics(options.bffId) : null;
+
+  app.use('*', cors());
+
+  app.use('*', async (c, next) => {
+    const requestId = randomUUID();
+    const startedAt = performance.now();
+    c.header('X-Request-Id', requestId);
+
+    await next();
+
+    const durationMs = Math.round(performance.now() - startedAt);
+    const path = new URL(c.req.url).pathname;
+    const screenId = resolveScreenId(path);
+    const status = String(c.res.status);
+    const method = c.req.method;
+
+    if (metrics) {
+      const labels = { bff_id: options.bffId, screen_id: screenId, status, method };
+      metrics.requestDuration.observe(labels, durationMs / 1000);
+      metrics.requestsTotal.inc(labels);
+    }
+
+    console.log(
+      JSON.stringify({
+        type: 'bff_request',
+        request_id: requestId,
+        bff_id: options.bffId,
+        screen_id: screenId,
+        method: c.req.method,
+        path,
+        status: c.res.status,
+        duration_ms: durationMs,
+      }),
+    );
+  });
+
+  if (metrics) {
+    app.get('/metrics', async (c) => {
+      c.header('Content-Type', metrics.registry.contentType);
+      return c.body(await metrics.registry.metrics());
+    });
+  }
+
+  app.get('/health', (c) =>
+    c.json({
+      ok: true,
+      bff: options.bffId,
+      name: options.name,
+      screens: Object.keys(options.screens),
+      metrics_enabled: metricsEnabled,
+    }),
+  );
+
+  app.get('/v1/screens/:screenId', async (c) => {
+    const screenId = c.req.param('screenId');
+    const builder = options.screens[screenId];
+
+    if (!builder) {
+      return c.json({ error: 'screen_not_found', screen_id: screenId }, 404);
+    }
+
+    const query = Object.fromEntries(new URL(c.req.url).searchParams.entries());
+    const authToken = readAuthToken(c.req.header('Authorization'));
+    const screen = await builder(buildContext({}, query, authToken));
+    return c.json(screen);
+  });
+
+  app.post('/v1/actions/:actionId', async (c) => {
+    const actionId = c.req.param('actionId');
+    const body = await c.req.json().catch(() => ({}));
+    return c.json({
+      ok: true,
+      action_id: actionId,
+      received: body,
+      message: 'Action endpoint stub — implement per domain in each BFF.',
+    });
+  });
+
+  return {
+    app,
+    start() {
+      serve({ fetch: app.fetch, port: options.port, hostname: '0.0.0.0' }, () => {
+        console.log(`[${options.bffId}] listening on http://0.0.0.0:${options.port}`);
+      });
+    },
+  };
+}
+
+export * from '@proulr/sdui-contract';
+export { createBffSupabaseClient, isBffSupabaseConfigured } from './bff-supabase-client';