@enbox/dwn-server 0.0.2 → 0.0.3

package/src/json-rpc-handlers/dwn/process-message.ts

@@ -1,7 +1,6 @@
 import type { GenericMessage } from '@enbox/dwn-sdk-js';
 import { DwnInterfaceName, DwnMethodName } from '@enbox/dwn-sdk-js';
 
-import type { Readable as IsomorphicReadable } from 'readable-stream';
 import log from 'loglevel';
 import { v4 as uuidv4 } from 'uuid';
 
@@ -28,7 +27,7 @@ export const handleDwnProcessMessage: JsonRpcHandler = async (
 
   try {
     // RecordsWrite is only supported on 'http' to support data stream for large data
-    // TODO: https://github.com/TBD54566975/dwn-server/issues/108
+    // TODO: https://github.com/enboxorg/enbox/issues/108
     if (
       transport !== 'http' &&
       message.descriptor.interface === DwnInterfaceName.Records &&
@@ -38,11 +37,11 @@ export const handleDwnProcessMessage: JsonRpcHandler = async (
         requestId,
         JsonRpcErrorCodes.InvalidParams,
         `RecordsWrite is not supported via ${context.transport}`
-      )
+      );
       return { jsonRpcResponse };
     }
 
-    // subscribe methods must come with a subscriptionRequest context 
+    // subscribe methods must come with a subscriptionRequest context
     if (message.descriptor.method === DwnMethodName.Subscribe && subscriptionRequest === undefined) {
       const jsonRpcResponse = createJsonRpcErrorResponse(
         requestId,
@@ -58,7 +57,7 @@ export const handleDwnProcessMessage: JsonRpcHandler = async (
         requestId,
         JsonRpcErrorCodes.InvalidParams,
         `subscriptions are not supported via ${context.transport}`
-      )
+      );
       return { jsonRpcResponse };
     }
 
@@ -70,12 +69,12 @@ export const handleDwnProcessMessage: JsonRpcHandler = async (
         requestId,
         JsonRpcErrorCodes.InvalidParams,
         `the subscribe id: ${subscriptionRequest.id} is in use by an active subscription`
-      )
+      );
       return { jsonRpcResponse };
     }
 
     const reply = await dwn.processMessage(target, message, {
-      dataStream: dataStream as IsomorphicReadable,
+      dataStream,
       subscriptionHandler: subscriptionRequest?.subscriptionHandler,
     });
 
@@ -83,7 +82,7 @@ export const handleDwnProcessMessage: JsonRpcHandler = async (
     const { entry } = reply;
     // RecordsRead or MessagesRead messages optionally return data as a stream to accommodate large amounts of data
     // we remove the data stream from the reply that will be serialized and return it as a separate property in the response payload.
-    let recordDataStream: IsomorphicReadable;
+    let recordDataStream: ReadableStream<Uint8Array>;
     if (entry !== undefined && entry.data !== undefined) {
       recordDataStream = entry.data;
       delete reply.entry.data; // not serializable via JSON
@@ -97,9 +96,9 @@ export const handleDwnProcessMessage: JsonRpcHandler = async (
       const subscriptionReply: JsonRpcSubscription = {
         id: subscriptionRequest.id,
         close,
-      }
+      };
       await socketConnection.addSubscription(subscriptionReply);
-      delete reply.subscription.close // delete the close method from the reply as it's not JSON serializable and has a held reference.
+      delete reply.subscription.close; // delete the close method from the reply as it's not JSON serializable and has a held reference.
     }
 
     const jsonRpcResponse = createJsonRpcSuccessResponse(requestId, { reply });

package/src/json-rpc-handlers/subscription/close.ts

@@ -1,12 +1,12 @@
 import { v4 as uuidv4 } from 'uuid';
 
-import { DwnServerErrorCode } from '../../dwn-error.js';
 import type {
   HandlerResponse,
   JsonRpcHandler,
 } from '../../lib/json-rpc-router.js';
-
 import type { JsonRpcId, JsonRpcResponse } from '../../lib/json-rpc.js';
+
+import { DwnServerErrorCode } from '../../dwn-error.js';
 import {
   createJsonRpcErrorResponse,
   createJsonRpcSuccessResponse,
@@ -43,7 +43,7 @@ export const handleSubscriptionsClose: JsonRpcHandler = async (
     // closing the subscription and cleaning up the reference within the given connection.
     await socketConnection.closeSubscription(id);
     jsonRpcResponse = createJsonRpcSuccessResponse(requestId, { reply: { status: 200, detail: 'Accepted' } });
-  } catch(error) {
+  } catch (error) {
     if (error.code === DwnServerErrorCode.ConnectionSubscriptionJsonRpcIdNotFound) {
       jsonRpcResponse = createJsonRpcErrorResponse(requestId, JsonRpcErrorCodes.InvalidParams, `subscription ${id} does not exist.`);
     } else {
@@ -56,4 +56,4 @@ export const handleSubscriptionsClose: JsonRpcHandler = async (
   }
 
   return { jsonRpcResponse } as HandlerResponse;
-}
+};

package/src/json-rpc-socket.ts

@@ -2,8 +2,9 @@ import log from 'loglevel';
 import { v4 as uuidv4 } from 'uuid';
 import WebSocket from 'ws';
 
-import type { JsonRpcId, JsonRpcRequest, JsonRpcResponse } from "./lib/json-rpc.js";
-import { createJsonRpcSubscriptionRequest } from "./lib/json-rpc.js";
+import type { JsonRpcId, JsonRpcRequest, JsonRpcResponse } from './lib/json-rpc.js';
+
+import { createJsonRpcSubscriptionRequest } from './lib/json-rpc.js';
 
 // These were arbitrarily chosen, but can be modified via connect options
 const CONNECT_TIMEOUT = 3_000;

package/src/lib/json-rpc-router.ts

@@ -1,8 +1,7 @@
 import type { Dwn, MessageSubscriptionHandler } from '@enbox/dwn-sdk-js';
 
-import type { Readable } from 'node:stream';
-
 import type { JsonRpcId, JsonRpcRequest, JsonRpcResponse } from './json-rpc.js';
+
 import type { SocketConnection } from '../connection/socket-connection.js';
 
 export type RequestContext = {
@@ -12,17 +11,17 @@ export type RequestContext = {
   socketConnection?: SocketConnection;
   subscriptionRequest?: {
     /** The JsonRpcId of the subscription handler */
-    id: JsonRpcId; 
+    id: JsonRpcId;
     /** The `MessageEvent` handler associated with a subscription request, only used in `ws` requests */
     subscriptionHandler: MessageSubscriptionHandler;
   }
-  /** The `Readable` stream associated with a `RecordsWrite` request only used in `http` requests */
-  dataStream?: Readable;
+  /** The `ReadableStream` associated with a `RecordsWrite` request only used in `http` requests */
+  dataStream?: ReadableStream<Uint8Array>;
 };
 
 export type HandlerResponse = {
   jsonRpcResponse: JsonRpcResponse;
-  dataStream?: Readable;
+  dataStream?: ReadableStream<Uint8Array>;
 };
 
 export type JsonRpcHandler = (

package/src/lib/json-rpc.ts

@@ -91,15 +91,15 @@ export const createJsonRpcSubscriptionRequest = (
   subscriptionId?: JsonRpcId
 ): JsonRpcRequest => {
   return {
-    jsonrpc: '2.0',
+    jsonrpc      : '2.0',
     id,
     method,
     params,
-    subscription: {
+    subscription : {
       id: subscriptionId,
     }
-  }
-}
+  };
+};
 
 export const createJsonRpcRequest = (
   id: JsonRpcId,
@@ -119,8 +119,8 @@ export const createJsonRpcSuccessResponse = (
   result?: any,
 ): JsonRpcSuccessResponse => {
   return {
-    jsonrpc: '2.0',
+    jsonrpc : '2.0',
     id,
-    result: result ?? null,
+    result  : result ?? null,
   };
 };

package/src/metrics.ts

@@ -1,14 +1,14 @@
 import { Counter, Histogram } from 'prom-client';
 
 export const requestCounter = new Counter({
-  name: 'dwn_requests_total',
-  help: 'all dwn requests processed',
-  labelNames: ['method', 'status', 'error'],
+  name       : 'dwn_requests_total',
+  help       : 'all dwn requests processed',
+  labelNames : ['method', 'status', 'error'],
 });
 
 export const responseHistogram = new Histogram({
-  name: 'http_response',
-  help: 'response histogram',
-  buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10],
-  labelNames: ['route', 'code'],
+  name       : 'http_response',
+  help       : 'response histogram',
+  buckets    : [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10],
+  labelNames : ['route', 'code'],
 });

package/src/process-handlers.ts

@@ -51,11 +51,11 @@ export const setProcessHandlers = (dwnServer: DwnServer): ProcessHandlers => {
 };
 
 export const removeProcessHandlers = (handlers: ProcessHandlers): void => {
-  const { 
-    unhandledRejectionHandler, 
-    uncaughtExceptionHandler, 
-    sigintHandler, 
-    sigtermHandler 
+  const {
+    unhandledRejectionHandler,
+    uncaughtExceptionHandler,
+    sigintHandler,
+    sigtermHandler
   } = handlers;
 
   process.removeListener('unhandledRejection', unhandledRejectionHandler);

package/src/registration/proof-of-work-manager.ts

@@ -1,6 +1,7 @@
-import { DwnServerError, DwnServerErrorCode } from "../dwn-error.js";
-import type { ProofOfWorkChallengeModel } from "./proof-of-work-types.js";
-import { ProofOfWork } from "./proof-of-work.js";
+import type { ProofOfWorkChallengeModel } from './proof-of-work-types.js';
+
+import { ProofOfWork } from './proof-of-work.js';
+import { DwnServerError, DwnServerErrorCode } from '../dwn-error.js';
 
 /**
  * Manages proof-of-work challenge difficulty and lifecycle based on solve rate.
@@ -18,7 +19,7 @@ export class ProofOfWorkManager {
   };
 
   // There is opportunity to improve implementation here.
-  // TODO: https://github.com/TBD54566975/dwn-server/issues/101
+  // TODO: https://github.com/enboxorg/enbox/issues/101
   private proofOfWorkOfLastMinute: Map<string, number> = new Map(); // proofOfWorkId -> timestamp of proof-of-work
 
   // Seed to generate the challenge nonce from, this allows all DWN instances in a cluster to generate the same challenge.
@@ -122,8 +123,8 @@ export class ProofOfWorkManager {
 
   public getProofOfWorkChallenge(): ProofOfWorkChallengeModel {
     return {
-      challengeNonce: this.challengeNonces.currentChallengeNonce,
-      maximumAllowedHashValue: ProofOfWorkManager.bigIntToHexString(this.currentMaximumAllowedHashValue),
+      challengeNonce          : this.challengeNonces.currentChallengeNonce,
+      maximumAllowedHashValue : ProofOfWorkManager.bigIntToHexString(this.currentMaximumAllowedHashValue),
     };
   }
 
@@ -228,7 +229,7 @@ export class ProofOfWorkManager {
   /**
    * Refreshes the difficulty by changing the max hash value.
    * The higher the number, the easier. Scale 1 (hardest) to 2^256 (easiest), represented in HEX.
-   * 
+   *
    * If solve rate rate is higher than expected, the difficulty will increase rapidly.
    * If solve rate is lower than expected, the difficulty will decrease gradually.
    * The difficulty will never be lower than the initial difficulty.
@@ -247,16 +248,16 @@ export class ProofOfWorkManager {
     //       and harder difficulty is represented by a smaller max allowed hash value.
     if (latestSolveCountPerMinute > this.desiredSolveCountPerMinute) {
       // if solve rate is higher than desired, make difficulty harder by making the max allowed hash value smaller
-      
+
       const currentSolveRateInFractionOfDesiredSolveRate = latestSolveCountPerMinute / this.desiredSolveCountPerMinute;
       const newMaximumAllowedHashValueAsBigIntPriorToMultiplierAdjustment
-        = (this.currentMaximumAllowedHashValueAsBigInt * BigInt(scaleFactor)) / 
+        = (this.currentMaximumAllowedHashValueAsBigInt * BigInt(scaleFactor)) /
           (BigInt(Math.floor(currentSolveRateInFractionOfDesiredSolveRate * this.difficultyIncreaseMultiplier * scaleFactor)));
 
       const hashValueDecreaseAmountPriorToEvaluationFrequencyAdjustment
         = (this.currentMaximumAllowedHashValueAsBigInt - newMaximumAllowedHashValueAsBigIntPriorToMultiplierAdjustment) *
           (BigInt(Math.floor(this.difficultyIncreaseMultiplier * scaleFactor)) / BigInt(scaleFactor));
-          
+
       // Adjustment based on the reevaluation frequency to provide more-or-less consistent behavior regardless of the reevaluation frequency.
       const hashValueDecreaseAmount = hashValueDecreaseAmountPriorToEvaluationFrequencyAdjustment / BigInt(difficultyEvaluationsPerMinute);
 

package/src/registration/registration-manager.ts

@@ -1,12 +1,14 @@
-import { ProofOfWorkManager } from "./proof-of-work-manager.js";
-import { ProofOfWork } from "./proof-of-work.js";
-import { RegistrationStore } from "./registration-store.js";
-import type { RegistrationData, RegistrationRequest } from "./registration-types.js";
-import type { ProofOfWorkChallengeModel } from "./proof-of-work-types.js";
-import { DwnServerError, DwnServerErrorCode } from "../dwn-error.js";
-import type { ActiveTenantCheckResult, TenantGate } from "@enbox/dwn-sdk-js";
-import { getDialectFromUrl } from "../storage.js";
-import { readFileSync } from "fs";
+import type { ProofOfWorkChallengeModel } from './proof-of-work-types.js';
+import type { ActiveTenantCheckResult, TenantGate } from '@enbox/dwn-sdk-js';
+import type { RegistrationData, RegistrationRequest } from './registration-types.js';
+
+import { readFileSync } from 'fs';
+
+import { getDialectFromUrl } from '../storage.js';
+import { ProofOfWork } from './proof-of-work.js';
+import { ProofOfWorkManager } from './proof-of-work-manager.js';
+import { RegistrationStore } from './registration-store.js';
+import { DwnServerError, DwnServerErrorCode } from '../dwn-error.js';
 
 /**
  * The RegistrationManager is responsible for managing the registration of tenants.
@@ -27,7 +29,7 @@ export class RegistrationManager implements TenantGate {
   }
 
   /**
-   * The terms-of-service hash. 
+   * The terms-of-service hash.
    */
   public getTermsOfServiceHash(): string | undefined {
     return this.termsOfServiceHash;
@@ -45,7 +47,7 @@ export class RegistrationManager implements TenantGate {
    * Creates a new RegistrationManager instance.
    * @param input.registrationStoreUrl - The URL of the registration store.
    * Set to `undefined` or empty string if tenant registration is not required (ie. DWN is open for all).
-   * 
+   *
    */
   public static async create(input: {
     registrationStoreUrl?: string,
@@ -70,17 +72,17 @@ export class RegistrationManager implements TenantGate {
 
     // Initialize and start ProofOfWorkManager.
     registrationManager.proofOfWorkManager = await ProofOfWorkManager.create({
-      autoStart: true,
-      desiredSolveCountPerMinute: 10,
-      initialMaximumAllowedHashValue: input.proofOfWorkInitialMaximumAllowedHash,
-      challengeSeed: input.proofOfWorkChallengeNonceSeed,
+      autoStart                      : true,
+      desiredSolveCountPerMinute     : 10,
+      initialMaximumAllowedHashValue : input.proofOfWorkInitialMaximumAllowedHash,
+      challengeSeed                  : input.proofOfWorkChallengeNonceSeed,
     });
 
     // Initialize RegistrationStore.
     const sqlDialect = getDialectFromUrl(new URL(registrationStoreUrl));
     const registrationStore = await RegistrationStore.create(sqlDialect);
     registrationManager.registrationStore = registrationStore;
-    
+
     return registrationManager;
   }
 
@@ -136,18 +138,18 @@ export class RegistrationManager implements TenantGate {
 
     if (tenantRegistration === undefined) {
       return {
-        isActiveTenant: false,
-        detail: 'Not a registered tenant.'
+        isActiveTenant : false,
+        detail         : 'Not a registered tenant.'
       };
     }
 
     if (tenantRegistration.termsOfServiceHash !== this.termsOfServiceHash) {
       return {
-        isActiveTenant: false,
-        detail: 'Agreed terms-of-service is outdated.'
+        isActiveTenant : false,
+        detail         : 'Agreed terms-of-service is outdated.'
       };
     }
 
-    return { isActiveTenant: true }
+    return { isActiveTenant: true };
   }
 }

package/src/registration/registration-store.ts

@@ -1,6 +1,7 @@
-import { Kysely } from 'kysely';
-import type { RegistrationData } from './registration-types.js';
 import type { Dialect } from '@enbox/dwn-sql-store';
+import type { RegistrationData } from './registration-types.js';
+
+import { Kysely } from 'kysely';
 
 /**
  * The RegistrationStore is responsible for storing and retrieving tenant registration information.
@@ -27,11 +28,11 @@ export class RegistrationStore {
 
   private async initialize(): Promise<void> {
     await this.db.schema
-    .createTable(RegistrationStore.registeredTenantTableName)
-    .ifNotExists()
-    .addColumn('did', 'text', (column) => column.primaryKey())
-    .addColumn('termsOfServiceHash', 'text')
-    .execute();
+      .createTable(RegistrationStore.registeredTenantTableName)
+      .ifNotExists()
+      .addColumn('did', 'text', (column) => column.primaryKey())
+      .addColumn('termsOfServiceHash', 'text')
+      .execute();
   }
 
   /**

package/src/storage.ts

@@ -1,4 +1,6 @@
+import type { Dialect } from '@enbox/dwn-sql-store';
 import type { DidResolver } from '@enbox/dids';
+import type { DwnServerConfig } from './config.js';
 import type {
   DataStore,
   DwnConfig,
@@ -8,14 +10,13 @@ import type {
   ResumableTaskStore,
   TenantGate,
 } from '@enbox/dwn-sdk-js';
-import type { Dialect } from '@enbox/dwn-sql-store';
-import type { DwnServerConfig } from './config.js';
 
 import * as fs from 'fs';
 import Cursor from 'pg-cursor';
-import Database from 'better-sqlite3';
-import pg from 'pg';
 import { createPool as MySQLCreatePool } from 'mysql2';
+import pg from 'pg';
+
+import { createBunSqliteDatabase } from '@enbox/dwn-sql-store';
 import { PluginLoader } from './plugin-loader.js';
 
 import {
@@ -51,10 +52,10 @@ export enum BackendTypes {
 export type DwnStore = DataStore | EventLog | MessageStore | ResumableTaskStore;
 
 export async function getDwnConfig(
-  config  : DwnServerConfig,
+  config : DwnServerConfig,
   options : {
     didResolver? : DidResolver,
-    tenantGate?  : TenantGate,
+    tenantGate? : TenantGate,
     eventStream? : EventStream,
   }
 ): Promise<DwnConfig> {
@@ -78,8 +79,8 @@ function getLevelStore(
       });
     case StoreType.MessageStore:
       return new MessageStoreLevel({
-        blockstoreLocation: storeURI.host + storeURI.pathname + '/MESSAGESTORE',
-        indexLocation: storeURI.host + storeURI.pathname + '/INDEX',
+        blockstoreLocation : storeURI.host + storeURI.pathname + '/MESSAGESTORE',
+        indexLocation      : storeURI.host + storeURI.pathname + '/INDEX',
       });
     case StoreType.EventLog:
       return new EventLogLevel({
@@ -131,7 +132,7 @@ async function getStore(storeConfigString: string, storeType: StoreType): Promis
     return await loadStoreFromFilePath(storeConfigString, storeType);
   }
   // else treat the `storeConfigString` as a connection string
-  
+
   const storeURI = new URL(storeConfigString);
 
   switch (storeURI.protocol.slice(0, -1)) {
@@ -171,7 +172,7 @@ async function loadStoreFromFilePath(
 
 export function getDialectFromUrl(connectionUrl: URL): Dialect {
   switch (connectionUrl.protocol.slice(0, -1)) {
-    case BackendTypes.SQLITE:
+    case BackendTypes.SQLITE: {
       const path = connectionUrl.host + connectionUrl.pathname;
       console.log('SQL-lite relative path:', path ? path : undefined); // NOTE, using ? for lose equality comparison
 
@@ -184,16 +185,17 @@ export function getDialectFromUrl(connectionUrl: URL): Dialect {
       const dbPath = path || ':memory:';
 
       return new SqliteDialect({
-        database: async () => new Database(dbPath),
+        database: async () => createBunSqliteDatabase(dbPath),
       });
+    }
     case BackendTypes.MYSQL:
       return new MysqlDialect({
         pool: async () => MySQLCreatePool(connectionUrl.toString()),
       });
     case BackendTypes.POSTGRES:
       return new PostgresDialect({
-        pool: async () => new pg.Pool({ connectionString: connectionUrl.toString() }),
-        cursor: Cursor,
+        pool   : async () => new pg.Pool({ connectionString: connectionUrl.toString() }),
+        cursor : Cursor,
       });
   }
 }

package/src/web5-connect/sql-ttl-cache.ts

@@ -39,9 +39,9 @@ export class SqlTtlCache {
         // 512 chars to accommodate potentially large `state` in Web5 Connect flow
         .addColumn('key', 'varchar(512)', (column) => column.primaryKey())
         .addColumn('value', 'text', (column) => column.notNull())
-        .addColumn('expiry', 'integer', (column) => column.notNull())
+        .addColumn('expiry', 'bigint', (column) => column.notNull())
         .execute();
-  
+
       await this.db.schema
         .createIndex('index_expiry')
         // .ifNotExists() // intentionally kept commented out code to show that it is not supported by all dialects (ie. MySQL)
@@ -97,7 +97,8 @@ export class SqlTtlCache {
     const entry = result[0];
 
     // if the entry is expired, don't return it and delete it
-    if (Date.now() >= entry.expiry) {
+    const expiry = typeof entry.expiry === 'string' ? parseInt(entry.expiry, 10) : entry.expiry;
+    if (Date.now() >= expiry) {
       this.delete(key); // no need to await
       return undefined;
     }
@@ -129,7 +130,7 @@ export class SqlTtlCache {
 interface CacheEntry {
   key: string;
   value: string;
-  expiry: number;
+  expiry: number | string; // bigint is returned as string by PostgreSQL driver
 }
 
 interface CacheDatabase {

package/src/web5-connect/web5-connect-server.ts

@@ -1,16 +1,17 @@
-import { getDialectFromUrl } from "../storage.js";
 import { CryptoUtils } from '@enbox/crypto';
-import { SqlTtlCache } from "./sql-ttl-cache.js";
+
+import { getDialectFromUrl } from '../storage.js';
+import { SqlTtlCache } from './sql-ttl-cache.js';
 
 /**
  * The Web5 Connect Request object.
  */
-export type Web5ConnectRequest = any; // TODO: define type in common repo for reuse (https://github.com/TBD54566975/dwn-server/issues/138)
+export type Web5ConnectRequest = any; // TODO: define type in common repo for reuse (https://github.com/enboxorg/enbox/issues/138)
 
 /**
  * The Web5 Connect Response object, which is also an OIDC ID token
  */
-export type Web5ConnectResponse = any; // TODO: define type in common repo for reuse (https://github.com/TBD54566975/dwn-server/issues/138)
+export type Web5ConnectResponse = any; // TODO: define type in common repo for reuse (https://github.com/enboxorg/enbox/issues/138)
 
 /**
  * The result of the setWeb5ConnectRequest() method.
@@ -25,7 +26,7 @@ export type SetWeb5ConnectRequestResult = {
    * The time in seconds that the Request URI is valid for.
    */
   expires_in: number;
-}
+};
 
 /**
  * The Web5 Connect Server is responsible for handling the Web5 Connect flow.
@@ -69,13 +70,13 @@ export class Web5ConnectServer {
     // Generate a request URI
     const requestId = CryptoUtils.randomUuid();
     const request_uri = `${this.baseUrl}/connect/authorize/${requestId}.jwt`;
-  
+
     // Store the Request Object.
     this.cache.insert(`request:${requestId}`, request, Web5ConnectServer.ttlInSeconds);
-  
+
     return {
       request_uri,
-      expires_in  : Web5ConnectServer.ttlInSeconds,
+      expires_in: Web5ConnectServer.ttlInSeconds,
     };
   }
 

package/src/ws-api.ts

@@ -1,45 +1,30 @@
-
-import type {
-  Dwn,
-} from '@enbox/dwn-sdk-js';
-
-import type { Server } from 'http';
-
-import { WebSocketServer } from 'ws';
+import type { Dwn } from '@enbox/dwn-sdk-js';
+import type { ServerWebSocket } from 'bun';
 
 import type { ConnectionManager } from './connection/connection-manager.js';
+import type { HttpApi, WsData } from './http-api.js';
+
 import { InMemoryConnectionManager } from './connection/connection-manager.js';
 
 export class WsApi {
-  #wsServer: WebSocketServer;
   dwn: Dwn;
-  #connectionManager: ConnectionManager
+  #connectionManager: ConnectionManager;
 
-  constructor(server: Server, dwn: Dwn, connectionManager?: ConnectionManager) {
+  constructor(httpApi: HttpApi, dwn: Dwn, connectionManager?: ConnectionManager) {
     this.dwn = dwn;
     this.#connectionManager = connectionManager || new InMemoryConnectionManager(dwn);
-    this.#wsServer = new WebSocketServer({ server });
-  }
-
-  get server(): WebSocketServer {
-    return this.#wsServer;
-  }
 
-  /**
-   * Handler for starting a WebSocket.
-   * Sets listeners for `connection`, `close` events.
-   */
-  #setupWebSocket(): void {
-    this.#wsServer.on('connection', (socket, request) => this.#connectionManager.connect(socket, request));
-    this.#wsServer.on('close', () => this.#connectionManager.closeAll());
+    // Wire up the WebSocket open event from Bun.serve() to the connection manager.
+    httpApi.onWebSocketConnection = (ws: ServerWebSocket<WsData>): void => {
+      this.#connectionManager.connect(ws);
+    };
   }
 
   start(): void {
-    this.#setupWebSocket();
+    // No additional setup needed — Bun.serve() handles WebSocket lifecycle.
   }
 
   async close(): Promise<void> {
-    this.#wsServer.close();
     await this.#connectionManager.closeAll();
   }
 }