@nmtjs/protocol 0.12.6 → 0.12.8

package/src/client/stream.ts

@@ -1,116 +0,0 @@
-import { defer } from '@nmtjs/common'
-import { concat, encodeText } from '../common/binary.ts'
-import type { ProtocolBlobMetadata } from '../common/blob.ts'
-
-export class ProtocolClientBlobStream extends TransformStream<
-  any,
-  ArrayBuffer
-> {
-  #queue: ArrayBuffer
-  #reader: ReadableStreamDefaultReader
-
-  constructor(
-    readonly source: ReadableStream,
-    readonly id: number,
-    readonly metadata: ProtocolBlobMetadata,
-  ) {
-    super({
-      start: () => {
-        defer(() => source.pipeThrough(this))
-      },
-      transform: (chunk, controller) => {
-        if (chunk instanceof ArrayBuffer) {
-          controller.enqueue(chunk)
-        } else if (chunk instanceof Uint8Array) {
-          controller.enqueue(chunk.buffer as unknown as ArrayBuffer)
-        } else if (typeof chunk === 'string') {
-          controller.enqueue(encodeText(chunk))
-        } else {
-          throw new Error(
-            'Invalid chunk data type. Expected ArrayBuffer, Uint8Array, or string.',
-          )
-        }
-      },
-    })
-
-    this.#queue = new ArrayBuffer(0)
-    this.#reader = this.readable.getReader()
-  }
-
-  async read(size: number) {
-    while (this.#queue.byteLength < size) {
-      const { done, value } = await this.#reader.read()
-      if (done) {
-        if (this.#queue.byteLength > 0) {
-          const chunk = this.#queue
-          this.#queue = new ArrayBuffer(0)
-          return chunk
-        }
-        return null
-      }
-      const buffer = value as ArrayBuffer
-      this.#queue = concat(this.#queue, buffer)
-    }
-    const chunk = this.#queue.slice(0, size)
-    this.#queue = this.#queue.slice(size)
-    return chunk
-  }
-
-  abort(error = new Error('Stream aborted')) {
-    this.#reader.cancel(error)
-    this.source.cancel(error)
-  }
-
-  end() {
-    return this.source.cancel('Stream ended')
-  }
-}
-
-export interface ProtocolServerStreamInterface<T = any> {
-  [Symbol.asyncIterator](): AsyncGenerator<T>
-  abort(error?: Error): void
-}
-
-export class ProtocolServerStream<T = any>
-  extends TransformStream<any, T>
-  implements ProtocolServerStreamInterface<T>
-{
-  #writer: WritableStreamDefaultWriter
-
-  constructor(options?: Transformer<any, T>) {
-    super(options)
-
-    this.#writer = this.writable.getWriter()
-  }
-
-  async *[Symbol.asyncIterator]() {
-    const reader = this.readable.getReader()
-    while (true) {
-      const { done, value } = await reader.read()
-      if (!done) yield value
-      else break
-    }
-  }
-
-  async push(chunk: T) {
-    await this.#writer.write(chunk)
-  }
-
-  async end() {
-    await this.#writer.close()
-  }
-
-  async abort(error = new Error('Stream aborted')) {
-    await this.#writer.abort(error)
-  }
-}
-
-export class ProtocolServerBlobStream extends ProtocolServerStream<ArrayBuffer> {
-  constructor(
-    readonly id: number,
-    readonly metadata: ProtocolBlobMetadata,
-    options?: Transformer<any, ArrayBuffer>,
-  ) {
-    super(options)
-  }
-}

package/src/client/types.ts

@@ -1,14 +0,0 @@
-import type { ProtocolBlob, ProtocolBlobInterface } from '../common/blob.ts'
-import type { ProtocolServerBlobStream } from './stream.ts'
-
-export type InputType<T> = T extends ProtocolBlobInterface
-  ? ProtocolBlob
-  : T extends object
-    ? { [K in keyof T]: InputType<T[K]> }
-    : T
-
-export type OutputType<T> = T extends ProtocolBlobInterface
-  ? ProtocolServerBlobStream
-  : T extends object
-    ? { [K in keyof T]: OutputType<T[K]> }
-    : T

package/src/common/binary.ts

@@ -1,60 +0,0 @@
-// TODO: get rid of lib DOM somehow...
-/// <reference lib="dom" />
-
-const utf8decoder = new TextDecoder()
-const utf8encoder = new TextEncoder()
-
-export type BinaryTypes = {
-  Int8: number
-  Int16: number
-  Int32: number
-  Uint8: number
-  Uint16: number
-  Uint32: number
-  Float32: number
-  Float64: number
-  BigInt64: bigint
-  BigUint64: bigint
-}
-
-export const encodeNumber = <T extends keyof BinaryTypes>(
-  value: BinaryTypes[T],
-  type: T,
-  littleEndian = false,
-) => {
-  const bytesNeeded = globalThis[`${type}Array`].BYTES_PER_ELEMENT
-  const ab = new ArrayBuffer(bytesNeeded)
-  const dv = new DataView(ab)
-  dv[`set${type}`](0, value as never, littleEndian)
-  return ab
-}
-
-export const decodeNumber = <T extends keyof BinaryTypes>(
-  buffer: ArrayBuffer,
-  type: T,
-  offset = 0,
-  littleEndian = false,
-): BinaryTypes[T] => {
-  const view = new DataView(buffer)
-  return view[`get${type}`](offset, littleEndian) as BinaryTypes[T]
-}
-
-export const encodeText = (text: string) =>
-  new Uint8Array(utf8encoder.encode(text)).buffer as ArrayBuffer
-
-export const decodeText = (buffer: Parameters<typeof utf8decoder.decode>[0]) =>
-  utf8decoder.decode(buffer)
-
-export const concat = (...buffers: ArrayBuffer[]) => {
-  const totalLength = buffers.reduce(
-    (acc, buffer) => acc + buffer.byteLength,
-    0,
-  )
-  const view = new Uint8Array(totalLength)
-  let offset = 0
-  for (const buffer of buffers) {
-    view.set(new Uint8Array(buffer), offset)
-    offset += buffer.byteLength
-  }
-  return view.buffer
-}

package/src/common/blob.ts

@@ -1,77 +0,0 @@
-export const BlobKey: unique symbol = Symbol.for('neemata:BlobKey')
-export type BlobKey = typeof BlobKey
-
-export type ProtocolBlobMetadata = {
-  type: string
-  size?: number
-  filename?: string
-}
-
-export interface ProtocolBlobInterface {
-  readonly metadata: ProtocolBlobMetadata
-  readonly [BlobKey]: true
-}
-
-export class ProtocolBlob implements ProtocolBlobInterface {
-  readonly [BlobKey] = true
-
-  public readonly metadata: ProtocolBlobMetadata
-  public readonly source: any
-
-  constructor(
-    source: any,
-    size?: number,
-    type = 'application/octet-stream',
-    filename?: string,
-  ) {
-    if (typeof size !== 'undefined' && size <= 0)
-      throw new Error('Blob size is invalid')
-
-    this.source = source
-    this.metadata = {
-      size,
-      type,
-      filename,
-    }
-  }
-
-  static from(
-    source: any,
-    metadata: {
-      size?: number
-      type?: string
-      filename?: string
-    } = {},
-  ) {
-    let _source: any
-
-    if (source instanceof globalThis.ReadableStream) {
-      _source = source
-    } else if ('File' in globalThis && source instanceof globalThis.File) {
-      _source = source.stream()
-      metadata.size = source.size
-      metadata.filename = source.name
-    } else if (source instanceof globalThis.Blob) {
-      _source = source.stream()
-      metadata.size = source.size
-    } else if (typeof source === 'string') {
-      const blob = new Blob([source])
-      _source = blob.stream()
-      metadata.size = blob.size
-      metadata.type = metadata.type || 'text/plain'
-    } else if (source instanceof globalThis.ArrayBuffer) {
-      const blob = new Blob([source])
-      _source = blob.stream()
-      metadata.size = blob.size
-    } else {
-      _source = source
-    }
-
-    return new ProtocolBlob(
-      _source,
-      metadata.size,
-      metadata.type,
-      metadata.filename,
-    )
-  }
-}

package/src/common/enums.ts

@@ -1,48 +0,0 @@
-export enum ClientMessageType {
-  Rpc = 10,
-  RpcAbort = 11,
-  RpcStreamAbort = 12,
-
-  ClientStreamPush = 20,
-  ClientStreamEnd = 21,
-  ClientStreamAbort = 22,
-  ServerStreamAbort = 23,
-  ServerStreamPull = 24,
-}
-
-export enum ServerMessageType {
-  Event = 1,
-
-  RpcResponse = 10,
-  RpcStreamResponse = 11,
-  RpcStreamChunk = 12,
-  RpcStreamEnd = 13,
-  RpcStreamAbort = 14,
-
-  ServerStreamPush = 20,
-  ServerStreamEnd = 21,
-  ServerStreamAbort = 22,
-
-  ClientStreamAbort = 23,
-  ClientStreamPull = 24,
-}
-
-export enum TransportType {
-  Bidirectional = 'Bidirectional',
-  Unidirectional = 'Unidirectional',
-}
-
-export enum ErrorCode {
-  ValidationError = 'ValidationError',
-  BadRequest = 'BadRequest',
-  NotFound = 'NotFound',
-  Forbidden = 'Forbidden',
-  Unauthorized = 'Unauthorized',
-  InternalServerError = 'InternalServerError',
-  NotAcceptable = 'NotAcceptable',
-  RequestTimeout = 'RequestTimeout',
-  GatewayTimeout = 'GatewayTimeout',
-  ServiceUnavailable = 'ServiceUnavailable',
-  ClientRequestError = 'ClientRequestError',
-  ConnectionError = 'ConnectionError',
-}

package/src/common/index.ts

@@ -1,4 +0,0 @@
-export * from './binary.ts'
-export * from './blob.ts'
-export * from './enums.ts'
-export * from './types.ts'

package/src/common/types.ts

@@ -1,41 +0,0 @@
-import type { OneOf } from '@nmtjs/common'
-import type { ProtocolBlob, ProtocolBlobMetadata } from './blob.ts'
-
-type Stream = any
-
-export interface BaseProtocolError {
-  code: string
-  message: string
-  data?: any
-}
-
-export type ProtocolRPC = {
-  callId: number
-  namespace: string
-  procedure: string
-  payload: any
-}
-
-export type ProtocolRPCResponse<T = Stream> = OneOf<
-  [
-    {
-      callId: number
-      error: BaseProtocolError
-    },
-    {
-      callId: number
-      result: any
-      streams: Record<number, T>
-    },
-  ]
->
-
-export interface EncodeRPCContext<T = Stream> {
-  getStream: (id: number) => T
-  addStream: (blob: ProtocolBlob) => T
-}
-
-export interface DecodeRPCContext<T = Stream> {
-  getStream: (id: number, callId: number) => T
-  addStream: (id: number, callId: number, metadata: ProtocolBlobMetadata) => T
-}

package/src/server/api.ts

@@ -1,63 +0,0 @@
-import type { Async } from '@nmtjs/common'
-import type { Container, Hook, MetadataStore } from '@nmtjs/core'
-import type { Connection } from './connection.ts'
-import { kIterableResponse } from './constants.ts'
-
-export type ProtocolApiCallOptions = {
-  connection: Connection
-  namespace: string
-  procedure: string
-  container: Container
-  payload: any
-  signal: AbortSignal
-  metadata?: (metadata: MetadataStore) => void
-}
-
-export type ProtocolAnyIterable<T> =
-  | ((signal: AbortSignal) => Async<AsyncIterable<T>>)
-  | AsyncIterable<T>
-
-export interface ProtocolApiCallBaseResult<T = unknown> {
-  output: T
-}
-
-export interface ProtocolApiCallIterableResult<Y = unknown, O = unknown>
-  extends ProtocolApiCallBaseResult<O> {
-  [kIterableResponse]: true
-  iterable: ProtocolAnyIterable<Y>
-  onFinish?: () => void
-}
-
-export type ProtocolApiCallResult =
-  | ProtocolApiCallBaseResult
-  | ProtocolApiCallIterableResult
-
-export interface ProtocolApi {
-  call(options: ProtocolApiCallOptions): Promise<ProtocolApiCallResult>
-}
-
-export function isIterableResult(
-  value: ProtocolApiCallResult,
-): value is ProtocolApiCallIterableResult {
-  return value && value[kIterableResponse] === true
-}
-
-export function createStreamResponse<Y, O>(
-  iterable: ProtocolAnyIterable<Y>,
-  output = undefined as O,
-  onFinish?: () => void,
-): ProtocolApiCallIterableResult<Y, O> {
-  return {
-    [kIterableResponse]: true as const,
-    iterable,
-    output,
-    onFinish,
-  }
-}
-
-declare module '@nmtjs/core' {
-  export interface HookType {
-    [Hook.OnConnect]: (connection: Connection) => any
-    [Hook.OnDisconnect]: (connection: Connection) => any
-  }
-}

package/src/server/connection.ts

@@ -1,40 +0,0 @@
-import { randomUUID } from 'node:crypto'
-import type { Container } from '@nmtjs/core'
-import type { BaseServerDecoder, BaseServerEncoder } from './format.ts'
-import type { ProtocolClientStream, ProtocolServerStream } from './stream.ts'
-
-export type ConnectionOptions<Data = unknown> = {
-  id?: string
-  data: Data
-}
-
-export class Connection<Data = unknown> {
-  readonly id: string
-  readonly data: Data
-
-  constructor(options: ConnectionOptions<Data>) {
-    this.id = options.id ?? randomUUID()
-    this.data = options.data
-  }
-}
-
-export class ConnectionContext {
-  streamId = 1
-  rpcs = new Map<number, AbortController>()
-  clientStreams = new Map<number, ProtocolClientStream>()
-  serverStreams = new Map<number, ProtocolServerStream>()
-  rpcStreams = new Map<number, AbortController>()
-  container: Container
-  format: {
-    encoder: BaseServerEncoder
-    decoder: BaseServerDecoder
-  }
-
-  constructor(
-    container: ConnectionContext['container'],
-    format: ConnectionContext['format'],
-  ) {
-    this.container = container
-    this.format = format
-  }
-}

package/src/server/constants.ts

@@ -1,9 +0,0 @@
-export const kTransportPlugin: unique symbol = Symbol.for(
-  'neemata:TransportPluginKey',
-)
-export type kTransportPlugin = typeof kTransportPlugin
-
-export const kIterableResponse: unique symbol = Symbol.for(
-  'neemata:IterableResponseKey',
-)
-export type kIterableResponse = typeof kIterableResponse

package/src/server/format.ts

@@ -1,117 +0,0 @@
-import type { OneOf } from '@nmtjs/common'
-import { match, type Pattern } from '@nmtjs/core'
-import type {
-  DecodeRPCContext,
-  EncodeRPCContext,
-  ProtocolRPC,
-  ProtocolRPCResponse,
-} from '../common/types.ts'
-import type { ProtocolClientStream, ProtocolServerStream } from './stream.ts'
-
-export interface BaseServerDecoder {
-  accept: Pattern[]
-  decode(buffer: ArrayBuffer): any
-  decodeRPC(
-    buffer: ArrayBuffer,
-    context: DecodeRPCContext<ProtocolClientStream>,
-  ): ProtocolRPC
-}
-
-export interface BaseServerEncoder {
-  contentType: string
-  encode(data: any): ArrayBuffer
-  encodeRPC(
-    rpc: OneOf<
-      [{ callId: number; error: any }, { callId: number; result: any }]
-    >,
-    context: EncodeRPCContext<ProtocolServerStream>,
-  ): ArrayBuffer
-}
-
-export abstract class BaseServerFormat
-  implements BaseServerDecoder, BaseServerEncoder
-{
-  abstract accept: Pattern[]
-  abstract contentType: string
-
-  abstract encode(data: any): ArrayBuffer
-  abstract encodeRPC(
-    rpc: ProtocolRPCResponse,
-    context: EncodeRPCContext<ProtocolServerStream>,
-  ): ArrayBuffer
-  abstract decode(buffer: ArrayBuffer): any
-  abstract decodeRPC(
-    buffer: ArrayBuffer,
-    context: DecodeRPCContext<ProtocolClientStream>,
-  ): ProtocolRPC
-}
-
-export const parseContentTypes = (types: string) => {
-  if (types === '*/*') return ['*/*']
-  return types
-    .split(',')
-    .map((t) => {
-      const [type, ...rest] = t.split(';')
-      const params = new Map(
-        rest.map((p) =>
-          p
-            .trim()
-            .split('=')
-            .slice(0, 2)
-            .map((p) => p.trim()),
-        ) as [string, string][],
-      )
-      return {
-        type,
-        q: params.has('q') ? Number.parseFloat(params.get('q')!) : 1,
-      }
-    })
-    .sort((a, b) => {
-      if (a.type === '*/*') return 1
-      if (b.type === '*/*') return -1
-      return b.q - a.q ? -1 : 1
-    })
-    .map((t) => t.type)
-}
-
-export class Format {
-  decoders = new Map<Pattern, BaseServerDecoder>()
-  encoders = new Map<Pattern, BaseServerEncoder>()
-
-  constructor(formats: BaseServerFormat[]) {
-    for (const format of formats) {
-      this.encoders.set(format.contentType, format)
-      for (const acceptType of format.accept) {
-        this.decoders.set(acceptType, format)
-      }
-    }
-  }
-
-  supportsDecoder(contentType: string, throwIfUnsupported = false) {
-    return this.supports(this.decoders, contentType, throwIfUnsupported)
-  }
-
-  supportsEncoder(contentType: string, throwIfUnsupported = false) {
-    return this.supports(this.encoders, contentType, throwIfUnsupported)
-  }
-
-  private supports<T extends BaseServerEncoder | BaseServerDecoder>(
-    formats: Map<Pattern, T>,
-    contentType: string,
-    throwIfUnsupported = false,
-  ): T | null {
-    // TODO: Use node:utils.MIMEType (not implemented yet in Deno and Bun yet)
-    const types = parseContentTypes(contentType)
-
-    for (const type of types) {
-      for (const [pattern, format] of formats) {
-        if (type === '*/*' || match(type, pattern)) return format
-      }
-    }
-
-    if (throwIfUnsupported)
-      throw new Error(`No supported format found: ${contentType}`)
-
-    return null
-  }
-}

package/src/server/index.ts

@@ -1,11 +0,0 @@
-export * from './api.ts'
-export * from './connection.ts'
-export * from './constants.ts'
-export * from './format.ts'
-export * from './injectables.ts'
-export * from './protocol.ts'
-export * from './registry.ts'
-export * from './stream.ts'
-export * from './transport.ts'
-export * from './types.ts'
-export * from './utils.ts'

package/src/server/injectables.ts

@@ -1,52 +0,0 @@
-import {
-  createFactoryInjectable,
-  createLazyInjectable,
-  Scope,
-} from '@nmtjs/core'
-import type { Connection } from './connection.ts'
-
-const connection = createLazyInjectable<Connection, Scope.Connection>(
-  Scope.Connection,
-  'RPC connection',
-)
-
-const connectionData = createLazyInjectable<any, Scope.Connection>(
-  Scope.Connection,
-  "RPC connection's data",
-)
-
-const connectionAbortSignal = createLazyInjectable<
-  AbortSignal,
-  Scope.Connection
->(Scope.Connection, 'Connection abort signal')
-
-const rpcClientAbortSignal = createLazyInjectable<AbortSignal, Scope.Call>(
-  Scope.Call,
-  'RPC client abort signal',
-)
-
-const rpcTimeoutSignal = createLazyInjectable<AbortSignal, Scope.Call>(
-  Scope.Call,
-  'RPC timeout signal',
-)
-
-const rpcAbortSignal = createFactoryInjectable(
-  {
-    dependencies: {
-      rpcTimeoutSignal,
-      rpcClientAbortSignal,
-      connectionAbortSignal,
-    },
-    factory: (ctx) => AbortSignal.any(Object.values(ctx)),
-  },
-  'Any RPC abort signal',
-)
-
-export const ProtocolInjectables = {
-  connection,
-  connectionData,
-  connectionAbortSignal,
-  rpcClientAbortSignal,
-  rpcTimeoutSignal,
-  rpcAbortSignal,
-} as const