@syncular/server-hono 0.0.6-95 → 0.2.0

package/src/__tests__/blob-routes.test.ts

@@ -1,424 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
-import type { BlobStorageAdapter } from '@syncular/core';
-import { createDatabase } from '@syncular/core';
-import {
-  type BlobTokenSigner,
-  createBlobManager,
-  createDatabaseBlobStorageAdapter,
-  createHmacTokenSigner,
-  ensureBlobStorageSchemaSqlite,
-  type SyncBlobDb,
-} from '@syncular/server';
-import { Hono } from 'hono';
-import type { Kysely } from 'kysely';
-import { createBunSqliteDialect } from '../../../dialect-bun-sqlite/src';
-import { createBlobRoutes } from '../blobs';
-
-interface UploadInitResponse {
-  exists: boolean;
-  uploadUrl?: string;
-  uploadMethod?: 'PUT' | 'POST';
-}
-
-interface UrlResponse {
-  url: string;
-}
-
-interface CompleteResponse {
-  ok: boolean;
-  error?: string;
-}
-
-const ACTOR_HEADER = 'x-user-id';
-const ACTOR_ID = 'user-1';
-const INVALID_HASH = 'invalid-hash';
-
-function toHex(bytes: Uint8Array): string {
-  return Array.from(bytes)
-    .map((value) => value.toString(16).padStart(2, '0'))
-    .join('');
-}
-
-async function createHash(bytes: Uint8Array): Promise<string> {
-  const digest = await crypto.subtle.digest('SHA-256', bytes);
-  return `sha256:${toHex(new Uint8Array(digest))}`;
-}
-
-async function signBlobToken(args: {
-  signer: BlobTokenSigner;
-  hash: string;
-  action: 'upload' | 'download';
-}): Promise<string> {
-  return args.signer.sign(
-    {
-      hash: args.hash,
-      action: args.action,
-      expiresAt: Date.now() + 60_000,
-    },
-    60
-  );
-}
-
-function createDefaultAdapter(
-  db: Kysely<SyncBlobDb>,
-  tokenSigner: BlobTokenSigner
-): BlobStorageAdapter {
-  return createDatabaseBlobStorageAdapter({
-    db,
-    baseUrl: 'http://localhost/sync',
-    tokenSigner,
-  });
-}
-
-function createFallbackAdapter(
-  db: Kysely<SyncBlobDb>,
-  tokenSigner: BlobTokenSigner
-): BlobStorageAdapter {
-  const adapter = createDefaultAdapter(db, tokenSigner);
-  return {
-    name: 'database-fallback',
-    signUpload: adapter.signUpload,
-    signDownload: adapter.signDownload,
-    exists: adapter.exists,
-    delete: adapter.delete,
-    getMetadata: adapter.getMetadata,
-  };
-}
-
-function buildApp(args: {
-  db: Kysely<SyncBlobDb>;
-  tokenSigner: BlobTokenSigner;
-  adapter: BlobStorageAdapter;
-  authenticate?: (
-    c: Parameters<typeof createBlobRoutes>[0]['authenticate']
-  ) => ReturnType<Parameters<typeof createBlobRoutes>[0]['authenticate']>;
-  canAccessBlob?: Parameters<typeof createBlobRoutes>[0]['canAccessBlob'];
-}): Hono {
-  const blobManager = createBlobManager({
-    db: args.db,
-    adapter: args.adapter,
-  });
-
-  const app = new Hono();
-  app.route(
-    '/sync',
-    createBlobRoutes({
-      blobManager,
-      authenticate: async (c) => {
-        if (args.authenticate) {
-          return args.authenticate(c);
-        }
-        const actorId = c.req.header(ACTOR_HEADER);
-        return actorId ? { actorId } : null;
-      },
-      tokenSigner: args.tokenSigner,
-      db: args.db,
-      canAccessBlob: args.canAccessBlob,
-    })
-  );
-  return app;
-}
-
-async function initiateUpload(args: {
-  app: Hono;
-  hash: string;
-  size: number;
-  mimeType?: string;
-}): Promise<UploadInitResponse> {
-  const response = await args.app.request(
-    'http://localhost/sync/blobs/upload',
-    {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        [ACTOR_HEADER]: ACTOR_ID,
-      },
-      body: JSON.stringify({
-        hash: args.hash,
-        size: args.size,
-        mimeType: args.mimeType ?? 'application/octet-stream',
-      }),
-    }
-  );
-
-  expect(response.status).toBe(200);
-  return (await response.json()) as UploadInitResponse;
-}
-
-describe('createBlobRoutes', () => {
-  let db: Kysely<SyncBlobDb>;
-  let tokenSigner: BlobTokenSigner;
-
-  beforeEach(async () => {
-    db = createDatabase<SyncBlobDb>({
-      dialect: createBunSqliteDialect({ path: ':memory:' }),
-      family: 'sqlite',
-    });
-    await ensureBlobStorageSchemaSqlite(db);
-    tokenSigner = createHmacTokenSigner('blob-route-test-secret');
-  });
-
-  afterEach(async () => {
-    await db.destroy();
-  });
-
-  it('rejects unauthenticated upload initiation', async () => {
-    const app = buildApp({
-      db,
-      tokenSigner,
-      adapter: createDefaultAdapter(db, tokenSigner),
-      authenticate: async () => null,
-    });
-
-    const hash = await createHash(new Uint8Array([1, 2, 3]));
-    const response = await app.request('http://localhost/sync/blobs/upload', {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({
-        hash,
-        size: 3,
-        mimeType: 'application/octet-stream',
-      }),
-    });
-
-    expect(response.status).toBe(401);
-    expect(await response.json()).toEqual({ error: 'UNAUTHENTICATED' });
-  });
-
-  it('rejects invalid direct-upload tokens', async () => {
-    const app = buildApp({
-      db,
-      tokenSigner,
-      adapter: createDefaultAdapter(db, tokenSigner),
-    });
-
-    const response = await app.request(
-      `http://localhost/sync/blobs/${encodeURIComponent(`sha256:${'a'.repeat(64)}`)}/upload?token=invalid-token`,
-      {
-        method: 'PUT',
-        body: new Uint8Array([1, 2, 3]),
-      }
-    );
-
-    expect(response.status).toBe(401);
-    expect(await response.json()).toEqual({ error: 'INVALID_TOKEN' });
-  });
-
-  it('rejects direct upload when body size does not match metadata', async () => {
-    const app = buildApp({
-      db,
-      tokenSigner,
-      adapter: createDefaultAdapter(db, tokenSigner),
-    });
-
-    const content = new Uint8Array([1, 2, 3, 4]);
-    const hash = await createHash(content);
-    const init = await initiateUpload({
-      app,
-      hash,
-      size: content.length,
-    });
-
-    const firstUpload = await app.request(init.uploadUrl!, {
-      method: init.uploadMethod ?? 'PUT',
-      body: content,
-    });
-    expect(firstUpload.status).toBe(200);
-
-    const complete = await app.request(
-      `http://localhost/sync/blobs/${encodeURIComponent(hash)}/complete`,
-      {
-        method: 'POST',
-        headers: { [ACTOR_HEADER]: ACTOR_ID },
-      }
-    );
-    expect(complete.status).toBe(200);
-
-    const token = await signBlobToken({
-      signer: tokenSigner,
-      hash,
-      action: 'upload',
-    });
-
-    const response = await app.request(
-      `http://localhost/sync/blobs/${encodeURIComponent(hash)}/upload?token=${encodeURIComponent(token)}`,
-      {
-        method: 'PUT',
-        body: new Uint8Array([1, 2, 3]),
-      }
-    );
-
-    expect(response.status).toBe(400);
-    const payload = (await response.json()) as { error: string };
-    expect(payload.error).toBe('SIZE_MISMATCH');
-  });
-
-  it('rejects direct upload when body hash does not match route hash', async () => {
-    const app = buildApp({
-      db,
-      tokenSigner,
-      adapter: createDefaultAdapter(db, tokenSigner),
-    });
-
-    const expected = new Uint8Array([1, 2, 3, 4]);
-    const hash = await createHash(expected);
-    await initiateUpload({
-      app,
-      hash,
-      size: expected.length,
-    });
-
-    const token = await signBlobToken({
-      signer: tokenSigner,
-      hash,
-      action: 'upload',
-    });
-
-    const response = await app.request(
-      `http://localhost/sync/blobs/${encodeURIComponent(hash)}/upload?token=${encodeURIComponent(token)}`,
-      {
-        method: 'PUT',
-        body: new Uint8Array([9, 9, 9, 9]),
-      }
-    );
-
-    expect(response.status).toBe(400);
-    const payload = (await response.json()) as { error: string };
-    expect(payload.error).toBe('HASH_MISMATCH');
-  });
-
-  it('returns 404 for invalid hash format and 403 for forbidden actor access', async () => {
-    const app = buildApp({
-      db,
-      tokenSigner,
-      adapter: createDefaultAdapter(db, tokenSigner),
-      canAccessBlob: async () => false,
-    });
-
-    const invalidHashResponse = await app.request(
-      `http://localhost/sync/blobs/${INVALID_HASH}/url`,
-      {
-        headers: { [ACTOR_HEADER]: ACTOR_ID },
-      }
-    );
-    expect(invalidHashResponse.status).toBe(404);
-    expect(await invalidHashResponse.json()).toEqual({ error: 'NOT_FOUND' });
-
-    const validHash = `sha256:${'b'.repeat(64)}`;
-    const forbiddenResponse = await app.request(
-      `http://localhost/sync/blobs/${encodeURIComponent(validHash)}/url`,
-      {
-        headers: { [ACTOR_HEADER]: ACTOR_ID },
-      }
-    );
-    expect(forbiddenResponse.status).toBe(403);
-    expect(await forbiddenResponse.json()).toEqual({ error: 'FORBIDDEN' });
-  });
-
-  it('uploads and downloads blobs through adapter put/get branches', async () => {
-    const app = buildApp({
-      db,
-      tokenSigner,
-      adapter: createDefaultAdapter(db, tokenSigner),
-    });
-
-    const content = new TextEncoder().encode('adapter-route-content');
-    const hash = await createHash(content);
-    const init = await initiateUpload({
-      app,
-      hash,
-      size: content.length,
-      mimeType: 'text/plain',
-    });
-
-    expect(init.exists).toBe(false);
-    expect(typeof init.uploadUrl).toBe('string');
-
-    const uploadResponse = await app.request(init.uploadUrl!, {
-      method: init.uploadMethod ?? 'PUT',
-      headers: { 'content-type': 'text/plain' },
-      body: content,
-    });
-    expect(uploadResponse.status).toBe(200);
-
-    const completeResponse = await app.request(
-      `http://localhost/sync/blobs/${encodeURIComponent(hash)}/complete`,
-      {
-        method: 'POST',
-        headers: { [ACTOR_HEADER]: ACTOR_ID },
-      }
-    );
-    expect(completeResponse.status).toBe(200);
-    expect((await completeResponse.json()) as CompleteResponse).toEqual({
-      ok: true,
-      metadata: expect.anything(),
-    });
-
-    const downloadUrlResponse = await app.request(
-      `http://localhost/sync/blobs/${encodeURIComponent(hash)}/url`,
-      {
-        headers: { [ACTOR_HEADER]: ACTOR_ID },
-      }
-    );
-    expect(downloadUrlResponse.status).toBe(200);
-    const { url } = (await downloadUrlResponse.json()) as UrlResponse;
-
-    const downloadResponse = await app.request(url);
-    expect(downloadResponse.status).toBe(200);
-    expect(new Uint8Array(await downloadResponse.arrayBuffer())).toEqual(
-      content
-    );
-  });
-
-  it('uploads and downloads blobs through DB fallback branches when adapter lacks put/get', async () => {
-    const app = buildApp({
-      db,
-      tokenSigner,
-      adapter: createFallbackAdapter(db, tokenSigner),
-    });
-
-    const content = new TextEncoder().encode('database-fallback-content');
-    const hash = await createHash(content);
-    const init = await initiateUpload({
-      app,
-      hash,
-      size: content.length,
-      mimeType: 'text/plain',
-    });
-
-    const uploadResponse = await app.request(init.uploadUrl!, {
-      method: init.uploadMethod ?? 'PUT',
-      headers: { 'content-type': 'text/plain' },
-      body: content,
-    });
-    expect(uploadResponse.status).toBe(200);
-
-    const completeResponse = await app.request(
-      `http://localhost/sync/blobs/${encodeURIComponent(hash)}/complete`,
-      {
-        method: 'POST',
-        headers: { [ACTOR_HEADER]: ACTOR_ID },
-      }
-    );
-    expect(completeResponse.status).toBe(200);
-    expect((await completeResponse.json()) as CompleteResponse).toEqual({
-      ok: true,
-      metadata: expect.anything(),
-    });
-
-    const urlResponse = await app.request(
-      `http://localhost/sync/blobs/${encodeURIComponent(hash)}/url`,
-      {
-        headers: { [ACTOR_HEADER]: ACTOR_ID },
-      }
-    );
-    expect(urlResponse.status).toBe(200);
-    const payload = (await urlResponse.json()) as UrlResponse;
-
-    const downloadResponse = await app.request(payload.url);
-    expect(downloadResponse.status).toBe(200);
-    expect(new Uint8Array(await downloadResponse.arrayBuffer())).toEqual(
-      content
-    );
-  });
-});

package/src/__tests__/console-gateway-live-routes.test.ts

@@ -1,297 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { Hono } from 'hono';
-import { defineWebSocketHelper, WSContext, type WSEvents } from 'hono/ws';
-import { createConsoleGatewayRoutes } from '../console';
-
-const CONSOLE_TOKEN = 'gateway-token';
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-class MockDownstreamSocket {
-  url: string;
-  onopen: ((event: Event) => void) | null = null;
-  onmessage: ((event: MessageEvent) => void) | null = null;
-  onerror: ((event: Event) => void) | null = null;
-  closeCalls = 0;
-  sent: string[] = [];
-
-  constructor(url: string) {
-    this.url = url;
-  }
-
-  emitOpen() {
-    this.onopen?.(new Event('open'));
-  }
-
-  emitJson(payload: Record<string, unknown>) {
-    this.onmessage?.(
-      new MessageEvent('message', { data: JSON.stringify(payload) })
-    );
-  }
-
-  emitError() {
-    this.onerror?.(new Event('error'));
-  }
-
-  close() {
-    this.closeCalls += 1;
-  }
-
-  send(data: string) {
-    this.sent.push(data);
-  }
-}
-
-function createGatewayLiveHarness() {
-  const downstreamSockets: MockDownstreamSocket[] = [];
-  let capturedEvents: WSEvents | null = null;
-
-  const app = new Hono();
-  const upgradeWebSocket = defineWebSocketHelper(async (_c, events) => {
-    capturedEvents = events;
-    return new Response(null, { status: 200 });
-  });
-
-  app.route(
-    '/console',
-    createConsoleGatewayRoutes({
-      instances: [
-        {
-          instanceId: 'alpha',
-          label: 'Alpha',
-          baseUrl: 'https://alpha.example.test/api/alpha',
-        },
-        {
-          instanceId: 'beta',
-          label: 'Beta',
-          baseUrl: 'https://beta.example.test/api/beta',
-        },
-      ],
-      authenticate: async (c) => {
-        const authHeader = c.req.header('Authorization');
-        if (authHeader === `Bearer ${CONSOLE_TOKEN}`) {
-          return { consoleUserId: 'gateway-user' };
-        }
-        return null;
-      },
-      websocket: {
-        enabled: true,
-        upgradeWebSocket,
-        heartbeatIntervalMs: 60000,
-        createWebSocket: (url) => {
-          const socket = new MockDownstreamSocket(url);
-          downstreamSockets.push(socket);
-          return socket;
-        },
-      },
-    })
-  );
-
-  return {
-    app,
-    downstreamSockets,
-    getEvents: () => capturedEvents,
-  };
-}
-
-function createUpstreamSocketHarness() {
-  const messages: Array<Record<string, unknown>> = [];
-  const closes: Array<{ code?: number; reason?: string }> = [];
-
-  const ws = new WSContext({
-    readyState: 1,
-    send(data) {
-      if (typeof data !== 'string') {
-        return;
-      }
-
-      const parsed = JSON.parse(data);
-      if (isRecord(parsed)) {
-        messages.push(parsed);
-      }
-    },
-    close(code, reason) {
-      closes.push({ code, reason });
-    },
-  });
-
-  return {
-    ws,
-    messages,
-    closes,
-  };
-}
-
-describe('createConsoleGatewayRoutes live fan-in', () => {
-  it('fans in downstream websocket events and emits instance degradation markers', async () => {
-    const { app, downstreamSockets, getEvents } = createGatewayLiveHarness();
-
-    const response = await app.request(
-      'http://localhost/console/events/live?instanceIds=alpha,beta&partitionId=tenant-a&replayLimit=42',
-      {
-        headers: { Authorization: `Bearer ${CONSOLE_TOKEN}` },
-      }
-    );
-    expect(response.status).toBe(200);
-
-    const events = getEvents();
-    if (!events?.onOpen || !events.onError) {
-      throw new Error('Expected websocket lifecycle handlers to be captured.');
-    }
-
-    const upstream = createUpstreamSocketHarness();
-    events.onOpen(new Event('open'), upstream.ws);
-
-    expect(downstreamSockets).toHaveLength(2);
-
-    const alphaSocket = downstreamSockets.find((socket) =>
-      socket.url.includes('alpha.example.test')
-    );
-    const betaSocket = downstreamSockets.find((socket) =>
-      socket.url.includes('beta.example.test')
-    );
-
-    if (!alphaSocket || !betaSocket) {
-      throw new Error(
-        'Expected both alpha and beta downstream websocket links.'
-      );
-    }
-
-    const alphaUrl = new URL(alphaSocket.url);
-    expect(alphaUrl.pathname).toBe('/api/alpha/console/events/live');
-    expect(alphaUrl.searchParams.get('token')).toBeNull();
-    expect(alphaUrl.searchParams.get('partitionId')).toBe('tenant-a');
-    expect(alphaUrl.searchParams.get('replayLimit')).toBe('42');
-
-    alphaSocket.emitOpen();
-    betaSocket.emitOpen();
-    expect(alphaSocket.sent[0]).toBe(
-      JSON.stringify({ type: 'auth', token: CONSOLE_TOKEN })
-    );
-    expect(betaSocket.sent[0]).toBe(
-      JSON.stringify({ type: 'auth', token: CONSOLE_TOKEN })
-    );
-
-    const connectedEvent = upstream.messages.find(
-      (message) => message.type === 'connected'
-    );
-    expect(connectedEvent?.instanceCount).toBe(2);
-
-    alphaSocket.emitJson({
-      type: 'push',
-      timestamp: '2026-02-17T11:00:00.000Z',
-      data: {
-        partitionId: 'tenant-a',
-        requestId: 'alpha-req-1',
-      },
-    });
-
-    const pushEvent = upstream.messages.find(
-      (message) => message.type === 'push'
-    );
-    expect(pushEvent?.instanceId).toBe('alpha');
-    if (!isRecord(pushEvent?.data)) {
-      throw new Error('Expected push event to include object data payload.');
-    }
-    expect(pushEvent.data.instanceId).toBe('alpha');
-    expect(pushEvent.data.partitionId).toBe('tenant-a');
-
-    betaSocket.emitError();
-    const degradedEvent = upstream.messages.find(
-      (message) => message.type === 'instance_error'
-    );
-    expect(degradedEvent?.instanceId).toBe('beta');
-
-    events.onError(new Event('error'), upstream.ws);
-    expect(downstreamSockets.every((socket) => socket.closeCalls === 1)).toBe(
-      true
-    );
-  });
-
-  it('accepts auth over first websocket message when headers are missing', async () => {
-    const { app, downstreamSockets, getEvents } = createGatewayLiveHarness();
-
-    const response = await app.request('http://localhost/console/events/live');
-    expect(response.status).toBe(200);
-
-    const events = getEvents();
-    if (!events?.onOpen || !events.onMessage) {
-      throw new Error('Expected websocket onOpen handler to be captured.');
-    }
-
-    const upstream = createUpstreamSocketHarness();
-    events.onOpen(new Event('open'), upstream.ws);
-    expect(downstreamSockets).toHaveLength(0);
-
-    await events.onMessage(
-      new MessageEvent('message', {
-        data: JSON.stringify({ type: 'auth', token: CONSOLE_TOKEN }),
-      }),
-      upstream.ws
-    );
-
-    expect(upstream.messages[0]?.type).toBe('connected');
-    expect(downstreamSockets).toHaveLength(2);
-  });
-
-  it('closes the upstream socket when websocket auth token is invalid', async () => {
-    const { app, downstreamSockets, getEvents } = createGatewayLiveHarness();
-
-    const response = await app.request('http://localhost/console/events/live');
-    expect(response.status).toBe(200);
-
-    const events = getEvents();
-    if (!events?.onOpen || !events.onMessage) {
-      throw new Error('Expected websocket handlers to be captured.');
-    }
-
-    const upstream = createUpstreamSocketHarness();
-    events.onOpen(new Event('open'), upstream.ws);
-    await events.onMessage(
-      new MessageEvent('message', {
-        data: JSON.stringify({ type: 'auth', token: 'bad-token' }),
-      }),
-      upstream.ws
-    );
-
-    const errorEvent = upstream.messages[0];
-    expect(errorEvent?.type).toBe('error');
-    expect(errorEvent?.message).toBe('UNAUTHENTICATED');
-    expect(upstream.closes).toEqual([
-      { code: 4001, reason: 'Unauthenticated' },
-    ]);
-    expect(downstreamSockets).toHaveLength(0);
-  });
-
-  it('closes the upstream socket when no instances match the filter', async () => {
-    const { app, downstreamSockets, getEvents } = createGatewayLiveHarness();
-
-    const response = await app.request(
-      'http://localhost/console/events/live?instanceId=missing',
-      {
-        headers: { Authorization: `Bearer ${CONSOLE_TOKEN}` },
-      }
-    );
-    expect(response.status).toBe(200);
-
-    const events = getEvents();
-    if (!events?.onOpen) {
-      throw new Error('Expected websocket onOpen handler to be captured.');
-    }
-
-    const upstream = createUpstreamSocketHarness();
-    events.onOpen(new Event('open'), upstream.ws);
-
-    const errorEvent = upstream.messages[0];
-    expect(errorEvent?.type).toBe('error');
-    expect(errorEvent?.message).toBe(
-      'No enabled instances matched the provided instance filter.'
-    );
-    expect(upstream.closes).toEqual([
-      { code: 4004, reason: 'No instances selected' },
-    ]);
-    expect(downstreamSockets).toHaveLength(0);
-  });
-});