@nmtjs/protocol 0.15.0-beta.2 → 0.15.0-beta.4

package/src/client/stream.ts

@@ -0,0 +1,222 @@
+import type { Callback, DuplexStreamOptions } from '@nmtjs/common'
+import { DuplexStream } from '@nmtjs/common'
+
+import type {
+  ProtocolBlobInterface,
+  ProtocolBlobMetadata,
+} from '../common/blob.ts'
+import { concat, decodeText, encodeText } from '../common/binary.ts'
+import { kBlobKey } from '../common/constants.ts'
+
+export class ProtocolClientBlobStream
+  extends DuplexStream<any, ArrayBufferView>
+  implements ProtocolBlobInterface
+{
+  readonly [kBlobKey] = true
+
+  #queue: Uint8Array
+  #reader: ReadableStreamDefaultReader
+  #sourceReader: ReadableStreamDefaultReader | null = null
+
+  constructor(
+    readonly source: ReadableStream,
+    readonly id: number,
+    readonly metadata: ProtocolBlobMetadata,
+  ) {
+    let sourceReader: ReadableStreamDefaultReader | null = null
+    super({
+      start: () => {
+        sourceReader = source.getReader()
+      },
+      pull: async (controller) => {
+        const { done, value } = await sourceReader!.read()
+        if (done) {
+          controller.close()
+          return
+        }
+        const chunk = value
+        controller.enqueue(
+          chunk instanceof Uint8Array
+            ? chunk
+            : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength),
+        )
+      },
+      transform: (chunk) => {
+        if (chunk instanceof ArrayBuffer) {
+          return new Uint8Array(chunk)
+        } else if (chunk instanceof Uint8Array) {
+          return chunk
+        } else if (typeof chunk === 'string') {
+          return encodeText(chunk)
+        } else {
+          throw new Error(
+            'Invalid chunk data type. Expected ArrayBuffer, Uint8Array, or string.',
+          )
+        }
+      },
+      cancel: (reason) => {
+        // Use reader.cancel() if reader exists (stream is locked), otherwise source.cancel()
+        if (sourceReader) {
+          sourceReader.cancel(reason)
+        } else {
+          source.cancel(reason)
+        }
+      },
+    })
+
+    this.#queue = new Uint8Array(0)
+    this.#reader = this.readable.getReader()
+    this.#sourceReader = sourceReader
+  }
+
+  async abort(reason = 'Stream aborted') {
+    await this.#reader.cancel(reason)
+    this.#reader.releaseLock()
+    this.#sourceReader?.releaseLock()
+  }
+
+  async end() {
+    // Release the reader lock when the stream is finished
+    this.#reader.releaseLock()
+    this.#sourceReader?.releaseLock()
+  }
+
+  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 Uint8Array(0)
+          return chunk
+        }
+        return null
+      }
+      const buffer = value
+      this.#queue = concat(this.#queue, buffer)
+    }
+    const chunk = this.#queue.subarray(0, size)
+    this.#queue = this.#queue.subarray(size)
+    return chunk
+  }
+}
+
+export abstract class ProtocolServerStreamInterface<
+  O = unknown,
+> extends DuplexStream<O, ArrayBufferView> {
+  async *[Symbol.asyncIterator]() {
+    const reader = this.readable.getReader()
+    try {
+      while (true) {
+        const { done, value } = await reader.read()
+        if (!done) yield value
+        else break
+      }
+    } finally {
+      reader.releaseLock()
+    }
+  }
+}
+
+export class ProtocolServerStream<T = unknown>
+  extends ProtocolServerStreamInterface<T>
+  implements ProtocolServerStreamInterface<T> {}
+
+export class ProtocolServerRPCStream<
+  T = unknown,
+> extends ProtocolServerStream<T> {
+  createAsyncIterable(onDone: Callback) {
+    return {
+      [Symbol.asyncIterator]: () => {
+        const iterator = this[Symbol.asyncIterator]()
+        return {
+          async next() {
+            const result = await iterator.next()
+            if (result.done) onDone()
+            return result
+          },
+          async return(value) {
+            onDone()
+            return iterator.return?.(value) ?? { done: true, value }
+          },
+          async throw(error) {
+            onDone()
+            return iterator.throw?.(error) ?? Promise.reject(error)
+          },
+        }
+      },
+    }
+  }
+}
+
+export class ProtocolServerBlobStream
+  extends ProtocolServerStreamInterface<ArrayBufferView>
+  implements ProtocolBlobInterface, Blob
+{
+  readonly [kBlobKey] = true
+
+  constructor(
+    readonly metadata: ProtocolBlobMetadata,
+    options?: DuplexStreamOptions<ArrayBufferView, ArrayBufferView>,
+  ) {
+    super(options)
+  }
+
+  get size() {
+    return this.metadata.size || Number.NaN
+  }
+
+  get type() {
+    return this.metadata.type || 'application/octet-stream'
+  }
+
+  async text() {
+    const chunks: ArrayBufferView[] = []
+    for await (const chunk of this) chunks.push(chunk)
+    return decodeText(concat(...chunks))
+  }
+
+  async bytes() {
+    const chunks: ArrayBufferView[] = []
+    for await (const chunk of this) chunks.push(chunk)
+    return concat(...chunks)
+  }
+
+  async arrayBuffer() {
+    const bytes = await this.bytes()
+    return bytes.buffer
+  }
+
+  async json<T = unknown>() {
+    const text = await this.text()
+    return JSON.parse(text) as T
+  }
+
+  stream() {
+    const transform = new TransformStream<ArrayBufferView, Uint8Array>({
+      transform: (chunk, controller) => {
+        controller.enqueue(
+          chunk instanceof Uint8Array
+            ? chunk
+            : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength),
+        )
+      },
+    })
+    this.readable.pipeThrough(transform)
+    return transform.readable as ReadableStream<Uint8Array<ArrayBuffer>>
+  }
+
+  /**
+   * Throws an error
+   */
+  async formData(): Promise<FormData> {
+    throw new Error('Method not implemented.')
+  }
+
+  /**
+   * Throws an error
+   */
+  slice(): Blob {
+    throw new Error('Unable to slice')
+  }
+}

package/src/client/versions/v1.ts

@@ -0,0 +1,205 @@
+import type { BaseProtocolError } from '../../common/types.ts'
+import type { ClientMessageTypePayload, MessageContext } from '../protocol.ts'
+import {
+  decodeNumber,
+  decodeText,
+  encodeNumber,
+  encodeText,
+} from '../../common/binary.ts'
+import {
+  ClientMessageType,
+  MessageByteLength,
+  ProtocolVersion,
+  ServerMessageType,
+} from '../../common/enums.ts'
+import { ProtocolVersionInterface } from '../protocol.ts'
+
+export class ProtocolVersion1 extends ProtocolVersionInterface {
+  version = ProtocolVersion.v1
+
+  decodeMessage(context: MessageContext, buffer: Uint8Array) {
+    const messageType = decodeNumber(buffer, 'Uint8')
+    const payload = buffer.subarray(MessageByteLength.MessageType)
+    switch (messageType) {
+      // case ServerMessageType.Event: {
+      //   const { event, data } = context.decoder.decode(payload)
+      //   return { type: messageType, event, data }
+      // }
+      case ServerMessageType.RpcResponse: {
+        const callId = decodeNumber(payload, 'Uint32')
+        const isError = decodeNumber(payload, 'Uint8', MessageByteLength.CallId)
+        const dataPayload = payload.subarray(
+          MessageByteLength.CallId + MessageByteLength.MessageError,
+        )
+
+        if (isError) {
+          const error = context.decoder.decode(dataPayload) as BaseProtocolError
+          return { type: messageType, callId, error }
+        } else {
+          const result = context.decoder.decodeRPC(dataPayload, {
+            addStream: (streamId, metadata) => {
+              return context.addServerStream(streamId, metadata)
+            },
+          })
+          return { type: messageType, callId, result }
+        }
+      }
+      case ServerMessageType.RpcStreamResponse: {
+        const callId = decodeNumber(payload, 'Uint32')
+        const errorPayload = payload.subarray(MessageByteLength.CallId)
+        const error =
+          errorPayload.byteLength > 0
+            ? (context.decoder.decode(errorPayload) as
+                | BaseProtocolError
+                | undefined)
+            : undefined
+        return { type: messageType, callId, error }
+      }
+      case ServerMessageType.RpcStreamChunk: {
+        const callId = decodeNumber(payload, 'Uint32')
+        const chunk = payload.subarray(MessageByteLength.CallId)
+        return { type: messageType, callId, chunk }
+      }
+      case ServerMessageType.RpcStreamEnd: {
+        const callId = decodeNumber(payload, 'Uint32')
+        return { type: messageType, callId }
+      }
+      case ServerMessageType.RpcStreamAbort: {
+        const callId = decodeNumber(payload, 'Uint32')
+        const reasonPayload = payload.subarray(MessageByteLength.CallId)
+        const reason =
+          reasonPayload.byteLength > 0 ? decodeText(reasonPayload) : undefined
+        return { type: messageType, callId, reason }
+      }
+      case ServerMessageType.ClientStreamPull: {
+        const streamId = decodeNumber(payload, 'Uint32')
+        const size = decodeNumber(payload, 'Uint32', MessageByteLength.StreamId)
+        return { type: messageType, streamId, size }
+      }
+      case ServerMessageType.ClientStreamAbort: {
+        const streamId = decodeNumber(payload, 'Uint32')
+        const reasonPayload = payload.subarray(MessageByteLength.StreamId)
+        const reason =
+          reasonPayload.byteLength > 0 ? decodeText(reasonPayload) : undefined
+
+        return { type: messageType, streamId, reason }
+      }
+      case ServerMessageType.ServerStreamPush: {
+        const streamId = decodeNumber(payload, 'Uint32')
+        const chunk = payload.subarray(MessageByteLength.StreamId)
+        return { type: messageType, streamId, chunk }
+      }
+      case ServerMessageType.ServerStreamEnd: {
+        const streamId = decodeNumber(payload, 'Uint32')
+        const reasonPayload = payload.subarray(MessageByteLength.StreamId)
+        const reason =
+          reasonPayload.byteLength > 0 ? decodeText(reasonPayload) : undefined
+
+        return { type: messageType, streamId, reason }
+      }
+      case ServerMessageType.ServerStreamAbort: {
+        const streamId = decodeNumber(payload, 'Uint32')
+        const reasonPayload = payload.subarray(MessageByteLength.StreamId)
+        const reason =
+          reasonPayload.byteLength > 0 ? decodeText(reasonPayload) : undefined
+
+        return { type: messageType, streamId, reason }
+      }
+
+      default:
+        throw new Error(`Unsupported message type: ${messageType}`)
+    }
+  }
+
+  encodeMessage<T extends ClientMessageType>(
+    context: MessageContext,
+    messageType: T,
+    payload: ClientMessageTypePayload[T],
+  ) {
+    switch (messageType) {
+      case ClientMessageType.Rpc: {
+        const {
+          callId,
+          procedure,
+          payload: rpcPayload,
+        } = payload as ClientMessageTypePayload[ClientMessageType.Rpc]
+        const procedureBuffer = encodeText(procedure)
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(callId, 'Uint32'),
+          encodeNumber(procedureBuffer.byteLength, 'Uint16'),
+          procedureBuffer,
+          context.encoder.encodeRPC(rpcPayload, {
+            addStream: (blob) => context.addClientStream(blob),
+          }),
+        )
+      }
+      case ClientMessageType.RpcAbort: {
+        const { callId, reason } =
+          payload as ClientMessageTypePayload[ClientMessageType.RpcAbort]
+
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(callId, 'Uint32'),
+          reason ? encodeText(reason) : new Uint8Array(0),
+        )
+      }
+      case ClientMessageType.RpcPull: {
+        const { callId } =
+          payload as ClientMessageTypePayload[ClientMessageType.RpcPull]
+
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(callId, 'Uint32'),
+        )
+      }
+      case ClientMessageType.ClientStreamPush: {
+        const { streamId, chunk } =
+          payload as ClientMessageTypePayload[ClientMessageType.ClientStreamPush]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(streamId, 'Uint32'),
+          chunk,
+        )
+      }
+      case ClientMessageType.ClientStreamEnd: {
+        const { streamId } =
+          payload as ClientMessageTypePayload[ClientMessageType.ClientStreamEnd]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(streamId, 'Uint32'),
+        )
+      }
+      case ClientMessageType.ClientStreamAbort: {
+        const { streamId, reason } =
+          payload as ClientMessageTypePayload[ClientMessageType.ClientStreamAbort]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(streamId, 'Uint32'),
+          reason ? encodeText(reason) : new Uint8Array(0),
+        )
+      }
+      case ClientMessageType.ServerStreamPull: {
+        const { streamId, size } =
+          payload as ClientMessageTypePayload[ClientMessageType.ServerStreamPull]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(streamId, 'Uint32'),
+          encodeNumber(size, 'Uint32'),
+        )
+      }
+      case ClientMessageType.ServerStreamAbort: {
+        const { streamId, reason } =
+          payload as ClientMessageTypePayload[ClientMessageType.ServerStreamAbort]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(streamId, 'Uint32'),
+          reason ? encodeText(reason) : new Uint8Array(0),
+        )
+      }
+
+      default:
+        throw new Error(`Unsupported message type: ${messageType}`)
+    }
+  }
+}

package/src/common/binary.ts

@@ -0,0 +1,70 @@
+// 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 = true,
+) => {
+  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 | ArrayBufferView,
+  type: T,
+  offset = 0,
+  littleEndian = true,
+): BinaryTypes[T] => {
+  const ab = buffer instanceof ArrayBuffer ? buffer : buffer.buffer
+  const baseOffset = buffer instanceof ArrayBuffer ? 0 : buffer.byteOffset
+  const view = new DataView(ab)
+  return view[`get${type}`](baseOffset + offset, littleEndian) as BinaryTypes[T]
+}
+
+export const encodeText = (text: string) => utf8encoder.encode(text)
+
+export const decodeText = (buffer: Parameters<typeof utf8decoder.decode>[0]) =>
+  utf8decoder.decode(buffer)
+
+export const concat = (...buffers: (ArrayBuffer | ArrayBufferView)[]) => {
+  let totalLength = 0
+  for (const buffer of buffers) totalLength += buffer.byteLength
+  const view = new Uint8Array(totalLength)
+  let offset = 0
+  for (const buffer of buffers) {
+    const chunk =
+      buffer instanceof ArrayBuffer
+        ? new Uint8Array(buffer)
+        : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+    view.set(chunk, offset)
+    offset += chunk.byteLength
+  }
+  return view
+}
+
+export const UTF8Transform = () =>
+  new TransformStream<string, Uint8Array>({
+    transform(chunk, controller) {
+      controller.enqueue(encodeText(chunk))
+    },
+  })

package/src/common/blob.ts

@@ -0,0 +1,99 @@
+import { kBlobKey } from './constants.ts'
+
+export type ProtocolBlobMetadata = {
+  type: string
+  size?: number | undefined
+  filename?: string | undefined
+}
+
+export interface ProtocolBlobInterface {
+  readonly metadata: ProtocolBlobMetadata
+  readonly [kBlobKey]: any
+}
+
+export class ProtocolBlob implements ProtocolBlobInterface {
+  [kBlobKey]: true = true
+
+  public readonly source: any
+  public readonly metadata: ProtocolBlobMetadata
+  public readonly encode?: () => unknown
+  public readonly toJSON?: () => unknown
+
+  constructor({
+    source,
+    encode,
+    size,
+    type = 'application/octet-stream',
+    filename,
+  }: {
+    source: any
+    encode?: () => unknown
+    size?: number
+    type?: string
+    filename?: string
+  }) {
+    if (typeof size !== 'undefined' && size <= 0)
+      throw new Error('Blob size is invalid')
+
+    this.encode = encode
+    this.source = source
+    this.metadata = { size, type, filename }
+    if (encode) {
+      Object.defineProperty(this, 'toJSON', {
+        configurable: false,
+        enumerable: false,
+        writable: false,
+        value: encode,
+      })
+    }
+  }
+
+  static from(
+    _source: any,
+    _metadata: { size?: number; type?: string; filename?: string } = {},
+    _encode?: () => unknown,
+  ) {
+    let source: any
+    const metadata = { ..._metadata }
+
+    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
+      metadata.type ??= _source.type
+    } else if (typeof _source === 'string') {
+      const blob = new Blob([_source])
+      source = blob.stream()
+      metadata.size ??= blob.size
+      metadata.type ??= 'text/plain'
+    } else if (globalThis.ArrayBuffer.isView(_source)) {
+      const blob = new Blob([_source as ArrayBufferView<ArrayBuffer>])
+      source = blob.stream()
+      metadata.size ??= blob.size
+    } 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,
+      encode: _encode,
+      size: metadata.size,
+      type: metadata.type,
+      filename: metadata.filename,
+    })
+  }
+
+  // toJSON() {
+  //   if (!this.encode) throw new Error('Blob format encoder is not defined')
+  //   return this.encode()
+  // }
+}

package/src/common/constants.ts

@@ -0,0 +1,2 @@
+export const kBlobKey: unique symbol = Symbol.for('neemata:blobKey')
+export type kBlobKey = typeof kBlobKey

package/src/common/enums.ts

@@ -0,0 +1,62 @@
+export enum ProtocolVersion {
+  v1 = 1,
+}
+
+export enum ClientMessageType {
+  Rpc = 10,
+  RpcAbort = 11,
+  RpcPull = 12,
+
+  ClientStreamPush = 20,
+  ClientStreamEnd = 21,
+  ClientStreamAbort = 22,
+
+  ServerStreamAbort = 33,
+  ServerStreamPull = 34,
+}
+
+export enum ServerMessageType {
+  // Event = 1,
+
+  RpcResponse = 10,
+  RpcStreamResponse = 11,
+  RpcStreamChunk = 12,
+  RpcStreamEnd = 13,
+  RpcStreamAbort = 14,
+
+  ServerStreamPush = 20,
+  ServerStreamEnd = 21,
+  ServerStreamAbort = 22,
+
+  ClientStreamAbort = 33,
+  ClientStreamPull = 34,
+}
+
+export enum ConnectionType {
+  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',
+}
+
+export enum MessageByteLength {
+  MessageType = 1,
+  MessageError = 1,
+  ProcedureLength = 2,
+  CallId = 4,
+  StreamId = 4,
+  ChunkSize = 4,
+}

package/src/common/index.ts

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

package/src/common/types.ts

@@ -0,0 +1,18 @@
+import type { ProtocolBlobMetadata } from './blob.ts'
+
+type Stream = any
+
+export interface BaseProtocolError {
+  code: string
+  message: string
+  data?: any
+}
+
+export type ProtocolRPCPayload = unknown
+export type ProtocolRPCResponse = unknown
+
+export type EncodeRPCStreams = Record<number, ProtocolBlobMetadata>
+
+export interface DecodeRPCContext<T = Stream> {
+  addStream: (id: number, metadata: ProtocolBlobMetadata) => T
+}

package/src/common/utils.ts

@@ -0,0 +1,12 @@
+import type { ProtocolBlobInterface } from './blob.ts'
+import { kBlobKey } from './constants.ts'
+
+export const isBlobInterface = <T extends ProtocolBlobInterface>(
+  value: any,
+): value is T => {
+  return (
+    value &&
+    (typeof value === 'object' || typeof value === 'function') &&
+    kBlobKey in value
+  )
+}