@syncular/console 0.0.6-159 → 0.0.6-165

package/src/hooks/useLiveEvents.ts

@@ -3,7 +3,7 @@
  */
 
 import { useCallback, useEffect, useRef, useState } from 'react';
-import type { ConsoleRequestEvent, LiveEvent } from '../lib/types';
+import type { LiveEvent } from '../lib/types';
 import { useConnection } from './ConnectionContext';
 import { useInstanceContext } from './useInstanceContext';
 
@@ -35,11 +35,6 @@ interface UseLiveEventsResult {
   clearEvents: () => void;
 }
 
-function isServiceWorkerServerMode(): boolean {
-  if (typeof window === 'undefined') return false;
-  return new URLSearchParams(window.location.search).get('swServer') === '1';
-}
-
 export function useLiveEvents(
   options: UseLiveEventsOptions = {}
 ): UseLiveEventsResult {
@@ -70,12 +65,10 @@ export function useLiveEvents(
   const reconnectAttemptsRef = useRef(0);
   const lastActivityAtRef = useRef(0);
   const lastEventTimestampRef = useRef<string | null>(null);
-  const lastEventIdRef = useRef<number | null>(null);
 
   const clearEvents = useCallback(() => {
     setEvents([]);
     lastEventTimestampRef.current = null;
-    lastEventIdRef.current = null;
   }, []);
 
   useEffect(() => {
@@ -87,113 +80,7 @@ export function useLiveEvents(
     const normalizedReplayLimit = Number.isFinite(replayLimit)
       ? Math.max(1, Math.min(500, Math.floor(replayLimit)))
       : 100;
-    const usePollingFallback =
-      isServiceWorkerServerMode() || typeof WebSocket === 'undefined';
-
-    if (usePollingFallback) {
-      setConnectionState('connecting');
-      setIsConnected(false);
-
-      let pollTimer: ReturnType<typeof setInterval> | null = null;
-      let isPolling = false;
-
-      const poll = async () => {
-        if (isCleanedUp || isPolling) return;
-        isPolling = true;
-
-        try {
-          const baseUrl = new URL(config.serverUrl, window.location.origin);
-          const normalizedPath = baseUrl.pathname.endsWith('/')
-            ? baseUrl.pathname.slice(0, -1)
-            : baseUrl.pathname;
-          baseUrl.pathname = `${normalizedPath}/console/events`;
-          baseUrl.search = '';
-          baseUrl.searchParams.set('limit', String(normalizedReplayLimit));
-          baseUrl.searchParams.set('offset', '0');
-          if (partitionId) {
-            baseUrl.searchParams.set('partitionId', partitionId);
-          }
-
-          const response = await fetch(baseUrl.toString(), {
-            headers: {
-              Authorization: `Bearer ${config.token}`,
-            },
-          });
-
-          if (!response.ok) {
-            throw new Error(`Live event polling failed (${response.status})`);
-          }
-
-          const payload = (await response.json()) as {
-            items?: ConsoleRequestEvent[];
-          };
-          const rows = Array.isArray(payload.items) ? payload.items : [];
-          const filtered = rows
-            .filter((row) =>
-              effectiveInstanceId
-                ? row.instanceId === effectiveInstanceId
-                : true
-            )
-            .sort((a, b) => a.eventId - b.eventId);
-
-          const previousLastId = lastEventIdRef.current ?? -1;
-          const newRows = filtered.filter(
-            (row) => row.eventId > previousLastId
-          );
-          if (newRows.length > 0) {
-            const mapped: LiveEvent[] = newRows
-              .map((row) => ({
-                type: row.eventType,
-                timestamp: row.createdAt,
-                data: row as unknown as Record<string, unknown>,
-              }))
-              .reverse();
-
-            setEvents((prev) => [...mapped, ...prev].slice(0, maxEvents));
-            const newest = newRows[newRows.length - 1]!;
-            lastEventIdRef.current = newest.eventId;
-            lastEventTimestampRef.current = newest.createdAt;
-          } else if (filtered.length > 0) {
-            const newest = filtered[filtered.length - 1]!;
-            lastEventIdRef.current = Math.max(
-              lastEventIdRef.current ?? -1,
-              newest.eventId
-            );
-            lastEventTimestampRef.current = newest.createdAt;
-          }
-
-          setError(null);
-          setIsConnected(true);
-          setConnectionState('connected');
-        } catch (err) {
-          if (!isCleanedUp) {
-            setIsConnected(false);
-            setConnectionState('disconnected');
-            setError(
-              err instanceof Error
-                ? err
-                : new Error('Live event polling failed')
-            );
-          }
-        } finally {
-          isPolling = false;
-        }
-      };
-
-      void poll();
-      pollTimer = setInterval(() => {
-        void poll();
-      }, 2_000);
-
-      return () => {
-        isCleanedUp = true;
-        if (pollTimer) {
-          clearInterval(pollTimer);
-        }
-        setIsConnected(false);
-        setConnectionState('disconnected');
-      };
-    }
+    if (typeof WebSocket === 'undefined') return;
 
     const clearReconnectTimeout = () => {
       if (!reconnectTimeoutRef.current) return;

package/src/lib/topology.ts

@@ -1,4 +1,4 @@
-import type { SyncClient } from '@syncular/ui';
+import type { SyncClientNode } from '@syncular/ui';
 import type { ConsoleClient, SyncStats } from './types';
 
 interface TopologyAdapterOptions {
@@ -55,7 +55,7 @@ function inferLagCommitCount(
 function inferStatus(
   client: ConsoleClient,
   lagCommitCount: number
-): SyncClient['status'] {
+): SyncClientNode['status'] {
   if (client.activityState === 'stale') {
     return 'offline';
   }
@@ -80,7 +80,7 @@ export function adaptConsoleClientsToTopology(
   clients: ConsoleClient[],
   stats?: SyncStats,
   options: TopologyAdapterOptions = {}
-): SyncClient[] {
+): SyncClientNode[] {
   const maxNodes = options.maxNodes ?? 10;
 
   return clients.slice(0, maxNodes).map((client, index) => {

package/src/lib/types.ts

@@ -1,180 +1,132 @@
 /**
- * Console API types - derived from OpenAPI spec
+ * Console API types derived from generated OpenAPI operations.
  */
 
-export type ApiKeyType = 'relay' | 'proxy' | 'admin';
-
-export interface ConsoleApiKey {
-  keyId: string;
-  keyPrefix: string;
-  name: string;
-  keyType: ApiKeyType;
-  scopeKeys: string[];
-  actorId: string | null;
-  createdAt: string;
-  expiresAt: string | null;
-  lastUsedAt: string | null;
-  revokedAt: string | null;
-}
+import type { operations } from '@syncular/transport-http';
 
-export interface ConsoleApiKeyBulkRevokeResponse {
-  requestedCount: number;
-  revokedCount: number;
-  alreadyRevokedCount: number;
-  notFoundCount: number;
-  revokedKeyIds: string[];
-  alreadyRevokedKeyIds: string[];
-  notFoundKeyIds: string[];
-}
+type OperationName = keyof operations;
 
-export interface ConsoleCommitListItem {
-  commitSeq: number;
-  actorId: string;
-  clientId: string;
-  clientCommitId: string;
-  createdAt: string;
-  changeCount: number;
-  affectedTables: string[];
-  instanceId?: string;
-  federatedCommitId?: string;
-  localCommitSeq?: number;
+type JsonResponse<
+  TOperation extends OperationName,
+  TStatus extends keyof operations[TOperation]['responses'],
+> = operations[TOperation]['responses'][TStatus] extends {
+  content: { 'application/json': infer TJson };
 }
+  ? TJson
+  : never;
 
-export interface ConsoleChange {
-  changeId: number;
-  table: string;
-  rowId: string;
-  op: 'upsert' | 'delete';
-  rowJson: unknown | null;
-  rowVersion: number | null;
-  scopes: Record<string, unknown>;
-}
+type OperationWithResponse<TStatus extends PropertyKey> = {
+  [TName in OperationName]: TStatus extends keyof operations[TName]['responses']
+    ? TName
+    : never;
+}[OperationName];
 
-export interface ConsoleCommitDetail extends ConsoleCommitListItem {
-  changes: ConsoleChange[];
+type JsonSuccessResponse<TOperation extends OperationWithResponse<200>> =
+  JsonResponse<TOperation, 200>;
+
+type JsonRequestBody<TOperation extends OperationName> =
+  NonNullable<operations[TOperation]['requestBody']> extends {
+    content: { 'application/json': infer TJson };
+  }
+    ? TJson
+    : never;
+
+type PaginatedItem<TOperation extends OperationWithResponse<200>> =
+  JsonSuccessResponse<TOperation> extends { items: Array<infer TItem> }
+    ? TItem
+    : never;
+
+interface GatewayFailure {
+  instanceId: string;
+  reason: string;
+  status?: number;
 }
 
-export interface ConsoleClient {
-  clientId: string;
-  actorId: string;
-  cursor: number;
-  lagCommitCount: number;
-  connectionPath: 'direct' | 'relay';
-  connectionMode: 'polling' | 'realtime';
-  realtimeConnectionCount: number;
-  isRealtimeConnected: boolean;
-  activityState: 'active' | 'idle' | 'stale';
-  lastRequestAt: string | null;
-  lastRequestType: 'push' | 'pull' | null;
-  lastRequestOutcome: string | null;
-  effectiveScopes: Record<string, unknown>;
-  updatedAt: string;
-  instanceId?: string;
-  federatedClientId?: string;
+interface GatewayAggregateMetadata {
+  partial?: boolean;
+  failedInstances?: GatewayFailure[];
 }
 
-export interface ConsoleHandler {
-  table: string;
-  dependsOn?: string[];
-  snapshotChunkTtlMs?: number;
+interface GatewayCommitFields {
+  instanceId?: string;
+  federatedCommitId?: string;
+  localCommitSeq?: number;
 }
 
-export interface ConsoleRequestEvent {
-  eventId: number;
-  partitionId: string;
-  requestId: string;
-  traceId: string | null;
-  spanId: string | null;
-  eventType: 'push' | 'pull';
-  syncPath: 'http-combined' | 'ws-push';
-  transportPath: 'direct' | 'relay';
-  actorId: string;
-  clientId: string;
-  statusCode: number;
-  outcome: string;
-  responseStatus: string;
-  errorCode: string | null;
-  durationMs: number;
-  commitSeq: number | null;
-  operationCount: number | null;
-  rowCount: number | null;
-  subscriptionCount: number | null;
-  scopesSummary: Record<string, string | string[]> | null;
-  tables: string[];
-  errorMessage: string | null;
-  payloadRef: string | null;
-  createdAt: string;
+interface GatewayClientFields {
   instanceId?: string;
-  federatedEventId?: string;
-  localEventId?: number;
+  federatedClientId?: string;
 }
 
-export interface ConsoleRequestPayload {
-  payloadRef: string;
-  partitionId: string;
-  requestPayload: unknown;
-  responsePayload: unknown | null;
-  createdAt: string;
+interface GatewayEventFields {
   instanceId?: string;
   federatedEventId?: string;
   localEventId?: number;
 }
 
-export interface ConsoleTimelineItem {
-  type: 'commit' | 'event';
-  timestamp: string;
-  commit: ConsoleCommitListItem | null;
-  event: ConsoleRequestEvent | null;
+interface GatewayTimelineFields {
   instanceId?: string;
   federatedTimelineId?: string;
   localCommitSeq?: number | null;
   localEventId?: number | null;
 }
 
-export type ConsoleOperationType =
-  | 'prune'
-  | 'compact'
-  | 'notify_data_change'
-  | 'evict_client';
-
-export interface ConsoleOperationEvent {
-  operationId: number;
-  operationType: ConsoleOperationType;
-  consoleUserId: string | null;
-  partitionId: string | null;
-  targetClientId: string | null;
-  requestPayload: unknown | null;
-  resultPayload: unknown | null;
-  createdAt: string;
+interface GatewayOperationFields {
   instanceId?: string;
   federatedOperationId?: string;
   localOperationId?: number;
 }
 
-export interface ConsoleNotifyDataChangeResponse {
-  commitSeq: number;
-  tables: string[];
-  deletedChunks: number;
-}
+export type ApiKeyType = JsonRequestBody<'postConsoleApiKeys'>['keyType'];
 
-export interface SyncStats {
-  commitCount: number;
-  changeCount: number;
-  minCommitSeq: number;
-  maxCommitSeq: number;
-  clientCount: number;
-  activeClientCount: number;
-  minActiveClientCursor: number | null;
-  maxActiveClientCursor: number | null;
-  partial?: boolean;
-  failedInstances?: Array<{
-    instanceId: string;
-    reason: string;
-    status?: number;
-  }>;
-  minCommitSeqByInstance?: Record<string, number>;
-  maxCommitSeqByInstance?: Record<string, number>;
-}
+export type ConsoleApiKey = JsonSuccessResponse<'getConsoleApiKeysById'>;
+
+export type ConsoleApiKeyBulkRevokeResponse =
+  JsonSuccessResponse<'postConsoleApiKeysBulkRevoke'>;
+
+export type ConsoleCommitListItem = PaginatedItem<'getConsoleCommits'> &
+  GatewayCommitFields;
+
+export type ConsoleCommitDetail =
+  JsonSuccessResponse<'getConsoleCommitsBySeq'> & GatewayCommitFields;
+
+export type ConsoleClient = PaginatedItem<'getConsoleClients'> &
+  GatewayClientFields;
+
+export type ConsoleHandler =
+  JsonSuccessResponse<'getConsoleHandlers'>['items'][number];
+
+export type ConsoleRequestEvent = PaginatedItem<'getConsoleEvents'> &
+  GatewayEventFields;
+
+export type ConsoleRequestPayload =
+  JsonSuccessResponse<'getConsoleEventsByIdPayload'> & GatewayEventFields;
+
+type BaseConsoleTimelineItem = PaginatedItem<'getConsoleTimeline'>;
+
+export type ConsoleTimelineItem = Omit<
+  BaseConsoleTimelineItem,
+  'commit' | 'event'
+> &
+  GatewayTimelineFields & {
+    commit: ConsoleCommitListItem | null;
+    event: ConsoleRequestEvent | null;
+  };
+
+export type ConsoleOperationType =
+  PaginatedItem<'getConsoleOperations'>['operationType'];
+
+export type ConsoleOperationEvent = PaginatedItem<'getConsoleOperations'> &
+  GatewayOperationFields;
+
+export type ConsoleNotifyDataChangeResponse =
+  JsonSuccessResponse<'postConsoleNotifyDataChange'>;
+
+export type SyncStats = JsonSuccessResponse<'getConsoleStats'> &
+  GatewayAggregateMetadata & {
+    minCommitSeqByInstance?: Record<string, number>;
+    maxCommitSeqByInstance?: Record<string, number>;
+  };
 
 export interface PaginatedResponse<T> {
   items: T[];
@@ -183,38 +135,18 @@ export interface PaginatedResponse<T> {
   limit: number;
 }
 
-// Time-series types
-export type TimeseriesInterval = 'minute' | 'hour' | 'day';
-export type TimeseriesRange = '1h' | '6h' | '24h' | '7d' | '30d';
+export type TimeseriesInterval =
+  JsonSuccessResponse<'getConsoleStatsTimeseries'>['interval'];
 
-export interface TimeseriesBucket {
-  timestamp: string;
-  pushCount: number;
-  pullCount: number;
-  errorCount: number;
-  avgLatencyMs: number;
-}
+export type TimeseriesRange =
+  JsonSuccessResponse<'getConsoleStatsTimeseries'>['range'];
 
-export interface TimeseriesStatsResponse {
-  buckets: TimeseriesBucket[];
-  interval: TimeseriesInterval;
-  range: TimeseriesRange;
-}
+export type TimeseriesStatsResponse =
+  JsonSuccessResponse<'getConsoleStatsTimeseries'> & GatewayAggregateMetadata;
 
-// Latency percentiles types
-export interface LatencyPercentiles {
-  p50: number;
-  p90: number;
-  p99: number;
-}
+export type LatencyStatsResponse =
+  JsonSuccessResponse<'getConsoleStatsLatency'> & GatewayAggregateMetadata;
 
-export interface LatencyStatsResponse {
-  push: LatencyPercentiles;
-  pull: LatencyPercentiles;
-  range: TimeseriesRange;
-}
-
-// Live events types
 export interface LiveEvent {
   type:
     | 'push'
@@ -227,19 +159,4 @@ export interface LiveEvent {
   data: Record<string, unknown>;
 }
 
-// ---------------------------------------------------------------------------
-// Blob storage
-// ---------------------------------------------------------------------------
-
-export interface ConsoleBlob {
-  key: string;
-  size: number;
-  uploaded: string;
-  httpMetadata?: { contentType?: string };
-}
-
-export interface ConsoleBlobListResponse {
-  items: ConsoleBlob[];
-  truncated: boolean;
-  cursor: string | null;
-}
+export type ConsoleBlobListResponse = JsonSuccessResponse<'getConsoleStorage'>;

package/src/pages/Config.tsx

@@ -26,8 +26,8 @@ import {
   TableHead,
   TableHeader,
   TableRow,
+  Toggle,
   ToggleGroup,
-  ToggleGroupItem,
 } from '@syncular/ui';
 import { useEffect, useMemo, useState } from 'react';
 import {
@@ -48,6 +48,8 @@ import type {
   ConsoleApiKeyBulkRevokeResponse,
 } from '../lib/types';
 
+const ToggleGroupItem = Toggle;
+
 export function Config({ children }: { children?: import('react').ReactNode }) {
   return (
     <div className="space-y-4 px-5 py-5">