@nmtjs/ws-transport 0.1.7 → 0.2.0

package/dist/lib/utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../lib/utils.ts"],"sourcesContent":["import { ApiError, type Format } from '@nmtjs/application'\nimport {\n  ErrorCode,\n  type RpcResponse,\n  concat,\n  encodeNumber,\n} from '@nmtjs/common'\nimport type { HttpRequest } from 'uWebSockets.js'\nimport type { WsTransportSocket } from './types.ts'\n\nexport const sendMessage = (\n  ws: WsTransportSocket,\n  type: number,\n  payload: any,\n) => {\n  return send(ws, type, ws.getUserData().format.encoder.encode(payload))\n}\n\nexport const sendRpcMessage = (\n  ws: WsTransportSocket,\n  type: number,\n  rpc: RpcResponse,\n) => {\n  const data = ws.getUserData()\n  return send(ws, type, data.format.encoder.encodeRpc(rpc, data.context.encode))\n}\n\nexport const send = (\n  ws: WsTransportSocket,\n  type: number,\n  ...buffers: ArrayBuffer[]\n): boolean | null => {\n  const data = ws.getUserData()\n  try {\n    const result = ws.send(\n      concat(encodeNumber(type, 'Uint8'), ...buffers),\n      true,\n    )\n    if (result === 0) {\n      data.backpressure = Promise.withResolvers()\n      return false\n    }\n    if (result === 2) {\n      return null\n    }\n    return true\n  } catch (error) {\n    return null\n  }\n}\n\nexport const getFormat = ({ headers, query }: RequestData, format: Format) => {\n  const contentType = headers.get('content-type') || query.get('content-type')\n  const acceptType = headers.get('accept') || query.get('accept')\n\n  const encoder = contentType ? format.supportsEncoder(contentType) : undefined\n  if (!encoder) throw new Error('Unsupported content-type')\n\n  const decoder = acceptType ? format.supportsDecoder(acceptType) : undefined\n  if (!decoder) throw new Error('Unsupported accept')\n\n  return {\n    encoder,\n    decoder,\n  }\n}\n\nexport const toRecord = (input: {\n  forEach: (cb: (value, key) => void) => void\n}) => {\n  const obj: Record<string, string> = {}\n  input.forEach((value, key) => {\n    obj[key] = value\n  })\n  return obj\n}\n\ntype RequestData = {\n  url: string\n  origin: URL | null\n  method: string\n  headers: Map<string, string>\n  query: URLSearchParams\n}\n\nexport const getRequestData = (req: HttpRequest): RequestData => {\n  const url = req.getUrl()\n  const method = req.getMethod()\n  const headers = new Map()\n  req.forEach((key, value) => headers.set(key, value))\n  const query = new URLSearchParams(req.getQuery())\n  const origin = headers.has('origin')\n    ? new URL(url, headers.get('origin'))\n    : null\n\n  return {\n    url,\n    origin,\n    method,\n    headers,\n    query,\n  }\n}\n\nexport const InternalError = (message = 'Internal Server Error') =>\n  new ApiError(ErrorCode.InternalServerError, message)\n\nexport const NotFoundError = (message = 'Not Found') =>\n  new ApiError(ErrorCode.NotFound, message)\n\nexport const ForbiddenError = (message = 'Forbidden') =>\n  new ApiError(ErrorCode.Forbidden, message)\n\nexport const RequestTimeoutError = (message = 'Request Timeout') =>\n  new ApiError(ErrorCode.RequestTimeout, message)\n"],"names":["ApiError","ErrorCode","concat","encodeNumber","sendMessage","ws","type","payload","send","getUserData","format","encoder","encode","sendRpcMessage","rpc","data","encodeRpc","context","buffers","result","backpressure","Promise","withResolvers","error","getFormat","headers","query","contentType","get","acceptType","supportsEncoder","undefined","Error","decoder","supportsDecoder","toRecord","input","obj","forEach","value","key","getRequestData","req","url","getUrl","method","getMethod","Map","set","URLSearchParams","getQuery","origin","has","URL","InternalError","message","InternalServerError","NotFoundError","NotFound","ForbiddenError","Forbidden","RequestTimeoutError","RequestTimeout"],"mappings":"AAAA,SAASA,QAAQ,QAAqB,qBAAoB;AAC1D,SACEC,SAAS,EAETC,MAAM,EACNC,YAAY,QACP,gBAAe;AAItB,OAAO,MAAMC,cAAc,CACzBC,IACAC,MACAC;IAEA,OAAOC,KAAKH,IAAIC,MAAMD,GAAGI,WAAW,GAAGC,MAAM,CAACC,OAAO,CAACC,MAAM,CAACL;AAC/D,EAAC;AAED,OAAO,MAAMM,iBAAiB,CAC5BR,IACAC,MACAQ;IAEA,MAAMC,OAAOV,GAAGI,WAAW;IAC3B,OAAOD,KAAKH,IAAIC,MAAMS,KAAKL,MAAM,CAACC,OAAO,CAACK,SAAS,CAACF,KAAKC,KAAKE,OAAO,CAACL,MAAM;AAC9E,EAAC;AAED,OAAO,MAAMJ,OAAO,CAClBH,IACAC,MACA,GAAGY;IAEH,MAAMH,OAAOV,GAAGI,WAAW;IAC3B,IAAI;QACF,MAAMU,SAASd,GAAGG,IAAI,CACpBN,OAAOC,aAAaG,MAAM,aAAaY,UACvC;QAEF,IAAIC,WAAW,GAAG;YAChBJ,KAAKK,YAAY,GAAGC,QAAQC,aAAa;YACzC,OAAO;QACT;QACA,IAAIH,WAAW,GAAG;YAChB,OAAO;QACT;QACA,OAAO;IACT,EAAE,OAAOI,OAAO;QACd,OAAO;IACT;AACF,EAAC;AAED,OAAO,MAAMC,YAAY,CAAC,EAAEC,OAAO,EAAEC,KAAK,EAAe,EAAEhB;IACzD,MAAMiB,cAAcF,QAAQG,GAAG,CAAC,mBAAmBF,MAAME,GAAG,CAAC;IAC7D,MAAMC,aAAaJ,QAAQG,GAAG,CAAC,aAAaF,MAAME,GAAG,CAAC;IAEtD,MAAMjB,UAAUgB,cAAcjB,OAAOoB,eAAe,CAACH,eAAeI;IACpE,IAAI,CAACpB,SAAS,MAAM,IAAIqB,MAAM;IAE9B,MAAMC,UAAUJ,aAAanB,OAAOwB,eAAe,CAACL,cAAcE;IAClE,IAAI,CAACE,SAAS,MAAM,IAAID,MAAM;IAE9B,OAAO;QACLrB;QACAsB;IACF;AACF,EAAC;AAED,OAAO,MAAME,WAAW,CAACC;IAGvB,MAAMC,MAA8B,CAAC;IACrCD,MAAME,OAAO,CAAC,CAACC,OAAOC;QACpBH,GAAG,CAACG,IAAI,GAAGD;IACb;IACA,OAAOF;AACT,EAAC;AAUD,OAAO,MAAMI,iBAAiB,CAACC;IAC7B,MAAMC,MAAMD,IAAIE,MAAM;IACtB,MAAMC,SAASH,IAAII,SAAS;IAC5B,MAAMrB,UAAU,IAAIsB;IACpBL,IAAIJ,OAAO,CAAC,CAACE,KAAKD,QAAUd,QAAQuB,GAAG,CAACR,KAAKD;IAC7C,MAAMb,QAAQ,IAAIuB,gBAAgBP,IAAIQ,QAAQ;IAC9C,MAAMC,SAAS1B,QAAQ2B,GAAG,CAAC,YACvB,IAAIC,IAAIV,KAAKlB,QAAQG,GAAG,CAAC,aACzB;IAEJ,OAAO;QACLe;QACAQ;QACAN;QACApB;QACAC;IACF;AACF,EAAC;AAED,OAAO,MAAM4B,gBAAgB,CAACC,UAAU,uBAAuB,GAC7D,IAAIvD,SAASC,UAAUuD,mBAAmB,EAAED,SAAQ;AAEtD,OAAO,MAAME,gBAAgB,CAACF,UAAU,WAAW,GACjD,IAAIvD,SAASC,UAAUyD,QAAQ,EAAEH,SAAQ;AAE3C,OAAO,MAAMI,iBAAiB,CAACJ,UAAU,WAAW,GAClD,IAAIvD,SAASC,UAAU2D,SAAS,EAAEL,SAAQ;AAE5C,OAAO,MAAMM,sBAAsB,CAACN,UAAU,iBAAiB,GAC7D,IAAIvD,SAASC,UAAU6D,cAAc,EAAEP,SAAQ"}
+{"version":3,"sources":["../../../lib/utils.ts"],"sourcesContent":["import { createPromise } from '@nmtjs/common'\nimport { ErrorCode, concat, encodeNumber } from '@nmtjs/protocol/common'\nimport { ProtocolError } from '@nmtjs/protocol/server'\nimport type { HttpRequest } from 'uWebSockets.js'\nimport type { WsTransportSocket } from './types.ts'\n\nexport const send = (\n  ws: WsTransportSocket,\n  type: number,\n  ...buffers: ArrayBuffer[]\n): boolean | null => {\n  const data = ws.getUserData()\n  try {\n    const buffer = concat(encodeNumber(type, 'Uint8'), ...buffers)\n    const result = ws.send(buffer, true)\n    if (result === 0) {\n      data.backpressure = createPromise()\n      return false\n    }\n    if (result === 2) {\n      return null\n    }\n    return true\n  } catch (error) {\n    return null\n  }\n}\n\nexport const toRecord = (input: {\n  forEach: (cb: (value, key) => void) => void\n}) => {\n  const obj: Record<string, string> = {}\n  input.forEach((value, key) => {\n    obj[key] = value\n  })\n  return obj\n}\n\ntype RequestData = {\n  url: string\n  origin: URL | null\n  method: string\n  headers: Map<string, string>\n  query: URLSearchParams\n}\n\nexport const getRequestData = (req: HttpRequest): RequestData => {\n  const url = req.getUrl()\n  const method = req.getMethod()\n  const headers = new Map()\n  req.forEach((key, value) => headers.set(key, value))\n  const query = new URLSearchParams(req.getQuery())\n  const origin = headers.has('origin')\n    ? new URL(url, headers.get('origin'))\n    : null\n\n  return {\n    url,\n    origin,\n    method,\n    headers,\n    query,\n  }\n}\n\nexport const InternalError = (message = 'Internal Server Error') =>\n  new ProtocolError(ErrorCode.InternalServerError, message)\n\nexport const NotFoundError = (message = 'Not Found') =>\n  new ProtocolError(ErrorCode.NotFound, message)\n\nexport const ForbiddenError = (message = 'Forbidden') =>\n  new ProtocolError(ErrorCode.Forbidden, message)\n\nexport const RequestTimeoutError = (message = 'Request Timeout') =>\n  new ProtocolError(ErrorCode.RequestTimeout, message)\n"],"names":["createPromise","ErrorCode","concat","encodeNumber","ProtocolError","send","ws","type","buffers","data","getUserData","buffer","result","backpressure","error","toRecord","input","obj","forEach","value","key","getRequestData","req","url","getUrl","method","getMethod","headers","Map","set","query","URLSearchParams","getQuery","origin","has","URL","get","InternalError","message","InternalServerError","NotFoundError","NotFound","ForbiddenError","Forbidden","RequestTimeoutError","RequestTimeout"],"mappings":"AAAA,SAASA,aAAa,QAAQ,gBAAe;AAC7C,SAASC,SAAS,EAAEC,MAAM,EAAEC,YAAY,QAAQ,yBAAwB;AACxE,SAASC,aAAa,QAAQ,yBAAwB;AAItD,OAAO,MAAMC,OAAO,CAClBC,IACAC,MACA,GAAGC;IAEH,MAAMC,OAAOH,GAAGI,WAAW;IAC3B,IAAI;QACF,MAAMC,SAAST,OAAOC,aAAaI,MAAM,aAAaC;QACtD,MAAMI,SAASN,GAAGD,IAAI,CAACM,QAAQ;QAC/B,IAAIC,WAAW,GAAG;YAChBH,KAAKI,YAAY,GAAGb;YACpB,OAAO;QACT;QACA,IAAIY,WAAW,GAAG;YAChB,OAAO;QACT;QACA,OAAO;IACT,EAAE,OAAOE,OAAO;QACd,OAAO;IACT;AACF,EAAC;AAED,OAAO,MAAMC,WAAW,CAACC;IAGvB,MAAMC,MAA8B,CAAC;IACrCD,MAAME,OAAO,CAAC,CAACC,OAAOC;QACpBH,GAAG,CAACG,IAAI,GAAGD;IACb;IACA,OAAOF;AACT,EAAC;AAUD,OAAO,MAAMI,iBAAiB,CAACC;IAC7B,MAAMC,MAAMD,IAAIE,MAAM;IACtB,MAAMC,SAASH,IAAII,SAAS;IAC5B,MAAMC,UAAU,IAAIC;IACpBN,IAAIJ,OAAO,CAAC,CAACE,KAAKD,QAAUQ,QAAQE,GAAG,CAACT,KAAKD;IAC7C,MAAMW,QAAQ,IAAIC,gBAAgBT,IAAIU,QAAQ;IAC9C,MAAMC,SAASN,QAAQO,GAAG,CAAC,YACvB,IAAIC,IAAIZ,KAAKI,QAAQS,GAAG,CAAC,aACzB;IAEJ,OAAO;QACLb;QACAU;QACAR;QACAE;QACAG;IACF;AACF,EAAC;AAED,OAAO,MAAMO,gBAAgB,CAACC,UAAU,uBAAuB,GAC7D,IAAIlC,cAAcH,UAAUsC,mBAAmB,EAAED,SAAQ;AAE3D,OAAO,MAAME,gBAAgB,CAACF,UAAU,WAAW,GACjD,IAAIlC,cAAcH,UAAUwC,QAAQ,EAAEH,SAAQ;AAEhD,OAAO,MAAMI,iBAAiB,CAACJ,UAAU,WAAW,GAClD,IAAIlC,cAAcH,UAAU0C,SAAS,EAAEL,SAAQ;AAEjD,OAAO,MAAMM,sBAAsB,CAACN,UAAU,iBAAiB,GAC7D,IAAIlC,cAAcH,UAAU4C,cAAc,EAAEP,SAAQ"}

package/lib/injectables.ts

@@ -1,11 +1,13 @@
-import {
-  type LazyInjectable,
-  type Scope,
-  injectables,
-} from '@nmtjs/application'
-import type { WsConnectionData } from './types.ts'
+import type { LazyInjectable, Scope } from '@nmtjs/core'
+import { ProtocolInjectables } from '@nmtjs/protocol/server'
+import type { WsUserData } from './types.ts'
 
-export const connectionData = injectables.connectionData as LazyInjectable<
-  WsConnectionData,
-  Scope.Connection
->
+const connectionData =
+  ProtocolInjectables.connectionData as unknown as LazyInjectable<
+    WsUserData['request'],
+    Scope.Connection
+  >
+
+export const WsTransportInjectables = {
+  connectionData,
+} as const

package/lib/server.ts

@@ -1,26 +1,4 @@
 import { randomUUID } from 'node:crypto'
-import {
-  type AnyBaseProcedure,
-  ApiError,
-  type ApplicationContext,
-  type Connection,
-  type Container,
-  Scope,
-  ServerDownStream,
-  ServerUpStream,
-  type Service,
-  SubscriptionResponse,
-  builtin,
-  onAbort,
-} from '@nmtjs/application'
-import {
-  type ApiBlobMetadata,
-  type EncodeRpcContext,
-  MessageType,
-  TransportType,
-  decodeNumber,
-  encodeNumber,
-} from '@nmtjs/common'
 import {
   App,
   type HttpRequest,
@@ -29,27 +7,36 @@ import {
   type TemplatedApp,
 } from 'uWebSockets.js'
 
-import { connectionData } from './injectables.ts'
+import { createPromise } from '@nmtjs/common'
+import {
+  ClientMessageType,
+  type ServerMessageType,
+  decodeNumber,
+  decodeText,
+} from '@nmtjs/protocol/common'
+import {
+  type Connection,
+  ProtocolInjectables,
+  type Transport,
+  type TransportPluginContext,
+} from '@nmtjs/protocol/server'
 import type {
   WsTransportOptions,
   WsTransportSocket,
   WsUserData,
 } from './types.ts'
-import {
-  InternalError,
-  getFormat,
-  getRequestData,
-  send,
-  sendMessage,
-  sendRpcMessage,
-} from './utils.ts'
+import { getRequestData, send } from './utils.ts'
 
-export class WsTransportServer {
+export type WsConnectionData = {
+  ws: WsTransportSocket
+}
+
+export class WsTransportServer implements Transport<WsConnectionData> {
   protected server!: TemplatedApp
-  protected readonly transportType = TransportType.WS
+  protected clients: Map<string, WsTransportSocket> = new Map()
 
   constructor(
-    protected readonly application: ApplicationContext,
+    protected readonly context: TransportPluginContext,
     protected readonly options: WsTransportOptions,
   ) {
     this.server = this.options.tls ? SSLApp(options.tls!) : App()
@@ -70,36 +57,17 @@ export class WsTransportServer {
         maxPayloadLength: this.options.maxPayloadLength,
         upgrade: (res, req, context) => {
           const requestData = getRequestData(req)
-          const container = this.application.container.createScope(
-            Scope.Connection,
-          )
-          const services = requestData.query.getAll('services')
 
-          for (const serviceName of services) {
-            const service = this.application.registry.services.get(serviceName)
-            if (!service)
-              return void res
-                .writeStatus('400 Bad Request')
-                .end(`Service ${service} not found`)
-            if (this.transportType in service.contract.transports === false)
-              return void res
-                .writeStatus('400 Bad Request')
-                .end(`Service ${service} not supported`)
-          }
+          const contentType =
+            requestData.headers.get('content-type') ||
+            requestData.query.get('content-type')
+
+          const acceptType =
+            requestData.headers.get('accept') || requestData.query.get('accept')
 
           const data: WsUserData = {
             id: randomUUID(),
-            format: getFormat(requestData, this.application.format),
-            container,
-            streams: {
-              up: new Map(),
-              down: new Map(),
-              streamId: 0,
-            },
-            abortControllers: new Map(),
-            subscriptions: new Map(),
-            services,
-            data: {
+            request: {
               query: requestData.query,
               headers: requestData.headers,
               proxiedRemoteAddress: Buffer.from(
@@ -108,7 +76,10 @@ export class WsTransportServer {
               remoteAddress: Buffer.from(
                 res.getRemoteAddressAsText(),
               ).toString(),
+              contentType,
+              acceptType,
             },
+            opening: createPromise(),
             backpressure: null,
             context: {} as any,
           }
@@ -121,31 +92,38 @@ export class WsTransportServer {
             context,
           )
         },
-        open: (ws: WsTransportSocket) => {
-          const data = ws.getUserData()
-          this.logger.debug('Connection %s opened', data.id)
-          data.context.decode = this.createDecodeRpcContext(ws)
-          data.context.encode = this.createEncodeRpcContext(ws)
-          data.container.provide(connectionData, data.data)
-
-          const connection = this.application.connections.add({
-            id: data.id,
-            services: data.services,
-            type: this.transportType,
-            subscriptions: data.subscriptions,
-            sendEvent: (service, event, payload) =>
-              sendMessage(ws, MessageType.Event, [service, event, payload]),
-          })
-
-          data.container.provide(builtin.connection, connection)
+        open: async (ws: WsTransportSocket) => {
+          const { id, context, request, opening } = ws.getUserData()
+          this.clients.set(id, ws)
+          this.logger.debug('Connection %s opened', id)
+          try {
+            const { context: _context, connection } =
+              await this.context.protocol.connections.add(
+                this,
+                { id, data: request },
+                {
+                  acceptType: request.acceptType,
+                  contentType: request.contentType,
+                },
+              )
+            Object.assign(context, _context)
+            context.container.provide(
+              ProtocolInjectables.connection,
+              connection,
+            )
+            opening.resolve()
+          } catch (error) {
+            opening.reject(error)
+          }
         },
-        message: async (ws: WsTransportSocket, event) => {
-          const buffer = event as unknown as ArrayBuffer
+        message: async (ws: WsTransportSocket, buffer) => {
+          const { opening } = ws.getUserData()
           const messageType = decodeNumber(buffer, 'Uint8')
           if (messageType in this === false) {
             ws.end(1011, 'Unknown message type')
           } else {
             try {
+              await opening.promise
               await this[messageType](
                 ws,
                 buffer.slice(Uint8Array.BYTES_PER_ELEMENT),
@@ -160,44 +138,29 @@ export class WsTransportServer {
           data.backpressure?.resolve()
           data.backpressure = null
         },
-        close: (ws: WsTransportSocket, code, message) => {
-          const data = ws.getUserData()
+        close: async (ws: WsTransportSocket, code, message) => {
+          const { id } = ws.getUserData()
 
           this.logger.debug(
             'Connection %s closed with code %s: %s',
-            data.id,
+            id,
             code,
             Buffer.from(message).toString(),
           )
-
-          this.application.connections.remove(data.id)
-          const error = new Error('Connection closed')
-
-          for (const ac of data.abortControllers.values()) {
-            ac.abort(error)
-          }
-          data.abortControllers.clear()
-
-          for (const stream of data.streams.down.values()) {
-            stream.destroy(error)
-          }
-          data.streams.down.clear()
-
-          for (const stream of data.streams.up.values()) {
-            stream.destroy(error)
-          }
-          data.streams.up.clear()
-
-          for (const subscription of data.subscriptions.values()) {
-            subscription.destroy()
-          }
-          data.subscriptions.clear()
-
-          this.handleContainerDisposal(data.container)
+          this.clients.delete(id)
+          await this.protocol.connections.remove(id)
         },
       })
   }
 
+  send(
+    connection: Connection<WsConnectionData>,
+    messageType: ServerMessageType,
+    buffer: ArrayBuffer,
+  ) {
+    send(connection.data.ws, messageType, buffer)
+  }
+
   async start() {
     return new Promise<void>((resolve, reject) => {
       const hostname = this.options.hostname ?? '127.0.0.1'
@@ -220,12 +183,12 @@ export class WsTransportServer {
     this.server.close()
   }
 
-  protected get api() {
-    return this.application.api
+  protected get protocol() {
+    return this.context.protocol
   }
 
   protected get logger() {
-    return this.application.logger
+    return this.context.logger
   }
 
   protected async logError(
@@ -245,256 +208,76 @@ export class WsTransportServer {
     res.writeHeader('Access-Control-Allow-Credentials', 'true')
   }
 
-  protected async handleContainerDisposal(container: Container) {
-    await container.dispose()
-  }
-
-  protected async handleRPC(options: {
-    connection: Connection
-    service: Service
-    procedure: AnyBaseProcedure
-    container: Container
-    signal: AbortSignal
-    payload: any
-  }) {
-    return await this.api.call({
-      ...options,
-      transport: this.transportType,
-    })
-  }
-
-  protected createEncodeRpcContext(ws: WsTransportSocket): EncodeRpcContext {
-    const data = ws.getUserData()
-    return {
-      addStream: (blob) => {
-        const id = ++data.streams.streamId
-        const downstream = new ServerDownStream(id, blob)
-        downstream.pause()
-        downstream.on('error', console.dir)
-        downstream.once('error', (err) => {
-          console.log({ err })
-          if (downstream.errored?.message !== 'Aborted by client')
-            send(ws, MessageType.DownStreamAbort, encodeNumber(id, 'Uint32'))
-        })
-        downstream.on('data', (chunk) => {
-          downstream.pause()
-          send(
-            ws,
-            MessageType.DownStreamPush,
-            encodeNumber(id, 'Uint32'),
-            Buffer.from(chunk).buffer as ArrayBuffer,
-          )
-        })
-        data.streams.down.set(id, downstream)
-        return { id, metadata: blob.metadata }
-      },
-      getStream: (id) => {
-        return data.streams.down.get(id)!
-      },
-    }
-  }
-
-  protected createDecodeRpcContext(ws: WsTransportSocket) {
-    const data = ws.getUserData()
-    return {
-      addStream(signal: AbortSignal, id: number, metadata: ApiBlobMetadata) {
-        const upstream = new ServerUpStream(metadata, {
-          read: (size) => {
-            send(
-              ws,
-              MessageType.UpStreamPull,
-              encodeNumber(id, 'Uint32'),
-              encodeNumber(size, 'Uint32'),
-            )
-          },
-        })
-
-        data.streams.up.set(id, upstream)
-        onAbort(signal, () => {
-          upstream.destroy(new Error('Call aborted by client'))
-        })
-        upstream.once('error', (error) => {
-          if (error.message !== 'Aborted by server')
-            send(ws, MessageType.UpStreamAbort, encodeNumber(id, 'Uint32'))
-        })
-        upstream.once('close', () => {
-          if (upstream.errored?.message !== 'Aborted by server')
-            send(ws, MessageType.UpStreamEnd, encodeNumber(id, 'Uint32'))
-        })
-
-        return upstream
-      },
-      getStream(id) {
-        return data.streams.down.get(id)
-      },
-    }
-  }
-
-  protected async [MessageType.Rpc](
+  protected [ClientMessageType.Rpc](
     ws: WsTransportSocket,
     buffer: ArrayBuffer,
   ) {
-    const data = ws.getUserData()
-
-    const connection = this.application.connections.get(data.id)
-    if (!connection) return void ws.end(1011, 'Unknown connection')
-
-    const ac = new AbortController()
-    const rpc = data.format.decoder.decodeRpc(buffer, {
-      ...data.context.decode,
-      addStream: data.context.decode.addStream.bind(null, ac.signal),
-    })
-
-    data.abortControllers.set(rpc.callId, ac)
-
-    const container = data.container.createScope(Scope.Call)
-
-    try {
-      const { service, procedure } = this.api.find(
-        rpc.service,
-        rpc.procedure,
-        this.transportType,
-      )
-
-      const response = await this.handleRPC({
-        connection,
-        service,
-        procedure,
-        container,
-        signal: ac.signal,
-        payload: rpc.payload,
-      })
-
-      if (response instanceof SubscriptionResponse) {
-        sendRpcMessage(ws, MessageType.RpcSubscription, {
-          callId: rpc.callId,
-          error: null,
-          payload: [response.subscription.key, response.payload],
-        })
-
-        response.subscription.on('event', (event, payload) => {
-          sendMessage(ws, MessageType.ServerSubscriptionEvent, [
-            response.subscription.key,
-            event,
-            payload,
-          ])
-        })
-        response.subscription.once('end', () => {
-          sendMessage(ws, MessageType.ServerUnsubscribe, [
-            response.subscription.key,
-          ])
-        })
-      } else {
-        sendRpcMessage(ws, MessageType.Rpc, {
-          callId: rpc.callId,
-          error: null,
-          payload: response,
-        })
-      }
-    } catch (error) {
-      if (error instanceof ApiError) {
-        this.logger.debug(new Error('Api error', { cause: error }))
-        sendRpcMessage(ws, MessageType.Rpc, {
-          callId: rpc.callId,
-          error,
-          payload: null,
-        })
-      } else {
-        this.logger.error(new Error('Unexpected error', { cause: error }))
-        sendRpcMessage(ws, MessageType.Rpc, {
-          callId: rpc.callId,
-          error: InternalError(),
-          payload: null,
-        })
-      }
-    } finally {
-      data.abortControllers.delete(rpc.callId)
-      this.handleContainerDisposal(container)
-    }
+    const { id } = ws.getUserData()
+    this.protocol.rpcRaw(id, buffer)
   }
 
-  async [MessageType.UpStreamPush](ws: WsTransportSocket, buffer: ArrayBuffer) {
-    const data = ws.getUserData()
-    const id = decodeNumber(buffer, 'Uint32')
-    const stream = data.streams.up.get(id)
-    if (!stream) return ws.end(1011, 'Unknown stream')
-    stream.push(Buffer.from(buffer.slice(Uint32Array.BYTES_PER_ELEMENT)))
-  }
-
-  async [MessageType.UpStreamEnd](ws: WsTransportSocket, buffer: ArrayBuffer) {
-    const data = ws.getUserData()
-    const id = decodeNumber(buffer, 'Uint32')
-    const stream = data.streams.up.get(id)
-    if (!stream) return ws.end(1011, 'Unknown stream')
-    stream.push(null)
-    data.streams.up.delete(id)
+  protected [ClientMessageType.RpcAbort](
+    ws: WsTransportSocket,
+    buffer: ArrayBuffer,
+  ) {
+    const { id } = ws.getUserData()
+    this.protocol.rpcAbortRaw(id, buffer)
   }
 
-  async [MessageType.UpStreamAbort](
+  protected [ClientMessageType.RpcStreamAbort](
     ws: WsTransportSocket,
     buffer: ArrayBuffer,
   ) {
-    const data = ws.getUserData()
-    const id = decodeNumber(buffer, 'Uint32')
-    const stream = data.streams.up.get(id)
-    if (!stream) return ws.end(1011, 'Unknown stream')
-    stream.destroy(new Error('Aborted by client'))
-    data.streams.up.delete(id)
+    const { id } = ws.getUserData()
+    this.protocol.rpcStreamAbortRaw(id, buffer)
   }
 
-  async [MessageType.DownStreamPull](
+  protected [ClientMessageType.ClientStreamPush](
     ws: WsTransportSocket,
     buffer: ArrayBuffer,
   ) {
-    const data = ws.getUserData()
-    const id = decodeNumber(buffer, 'Uint32')
-    const stream = data.streams.down.get(id)
-    if (!stream) return ws.end(1011, 'Unknown stream')
-    await data.backpressure?.promise
-    if (stream.readableEnded)
-      send(ws, MessageType.DownStreamEnd, encodeNumber(id, 'Uint32'))
-    else stream.resume()
+    const { id } = ws.getUserData()
+    const streamId = decodeNumber(buffer, 'Uint32')
+    this.protocol.clientStreams.push(
+      id,
+      streamId,
+      buffer.slice(Uint32Array.BYTES_PER_ELEMENT),
+    )
   }
 
-  async [MessageType.DownStreamEnd](
+  protected [ClientMessageType.ClientStreamEnd](
     ws: WsTransportSocket,
     buffer: ArrayBuffer,
   ) {
-    const data = ws.getUserData()
-    const id = decodeNumber(buffer, 'Uint32')
-    const stream = data.streams.down.get(id)
-    if (!stream) return ws.end(1011, 'Unknown stream')
-    data.streams.down.delete(id)
+    const { id } = ws.getUserData()
+    const streamId = decodeNumber(buffer, 'Uint32')
+    this.protocol.clientStreams.end(id, streamId)
   }
 
-  async [MessageType.DownStreamAbort](
+  protected [ClientMessageType.ClientStreamAbort](
     ws: WsTransportSocket,
     buffer: ArrayBuffer,
   ) {
-    const data = ws.getUserData()
-    const id = decodeNumber(buffer, 'Uint32')
-    const stream = data.streams.down.get(id)
-    if (!stream) return ws.end(1011, 'Unknown stream')
-    stream.destroy(new Error('Aborted by client'))
-    data.streams.down.delete(id)
+    const { id } = ws.getUserData()
+    const streamId = decodeNumber(buffer, 'Uint32')
+    this.protocol.clientStreams.abort(id, streamId)
   }
 
-  async [MessageType.ClientUnsubscribe](
+  protected [ClientMessageType.ServerStreamPull](
     ws: WsTransportSocket,
     buffer: ArrayBuffer,
   ) {
-    const data = ws.getUserData()
-    const [key] = data.format.decoder.decode(buffer)
-    const subscription = data.subscriptions.get(key)
-    if (!subscription) return void ws.end()
-    subscription.destroy()
-    data.subscriptions.delete(key)
+    const { id } = ws.getUserData()
+    const streamId = decodeNumber(buffer, 'Uint32')
+    this.protocol.serverStreams.pull(id, streamId)
   }
 
-  async [MessageType.RpcAbort](ws: WsTransportSocket, buffer: ArrayBuffer) {
-    const data = ws.getUserData()
-    const callId = decodeNumber(buffer, 'Uint32')
-    const ac = data.abortControllers.get(callId)
-    if (ac) ac.abort(new Error('Aborted by client'))
+  protected [ClientMessageType.ServerStreamAbort](
+    ws: WsTransportSocket,
+    buffer: ArrayBuffer,
+  ) {
+    const { id } = ws.getUserData()
+    const streamId = decodeNumber(buffer, 'Uint32')
+    this.protocol.serverStreams.abort(id, streamId)
   }
 }

package/lib/transport.ts

@@ -1,16 +1,10 @@
-import { Hook, createPlugin } from '@nmtjs/application'
-import { WsTransportServer } from './server.ts'
+import { createTransport } from '@nmtjs/protocol/server'
+import { type WsConnectionData, WsTransportServer } from './server.ts'
 import type { WsTransportOptions } from './types.ts'
 
-export const WsTransport = createPlugin<WsTransportOptions>(
-  'WsTransport',
-  (app, options) => {
-    const server = new WsTransportServer(app, options)
-    app.hooks.add(Hook.OnStartup, async () => {
-      await server.start()
-    })
-    app.hooks.add(Hook.OnShutdown, async () => {
-      await server.stop()
-    })
-  },
-)
+export const WsTransport = createTransport<
+  WsConnectionData,
+  WsTransportOptions
+>('WsTransport', (context, options) => {
+  return new WsTransportServer(context, options)
+})