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

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
+  )
+}

package/src/server/format.ts

@@ -0,0 +1,113 @@
+import type { Pattern } from '@nmtjs/common'
+import { match } from '@nmtjs/common'
+
+import type {
+  DecodeRPCContext,
+  EncodeRPCStreams,
+  ProtocolRPCPayload,
+} from '../common/types.ts'
+import type { ProtocolClientStream } from './stream.ts'
+
+export interface BaseServerDecoder {
+  accept: Pattern[]
+  decode(buffer: ArrayBufferView): unknown
+  decodeRPC(
+    buffer: ArrayBufferView,
+    context: DecodeRPCContext<() => ProtocolClientStream>,
+  ): ProtocolRPCPayload
+}
+
+export interface BaseServerEncoder {
+  contentType: string
+  encode(data: unknown): ArrayBufferView
+  encodeRPC(data: unknown, streams: EncodeRPCStreams): ArrayBufferView
+  encodeBlob(streamId: number): unknown
+}
+
+export abstract class BaseServerFormat
+  implements BaseServerDecoder, BaseServerEncoder
+{
+  abstract accept: Pattern[]
+  abstract contentType: string
+
+  abstract encode(data: unknown): ArrayBufferView
+  abstract encodeRPC(data: unknown, streams: EncodeRPCStreams): ArrayBufferView
+  abstract encodeBlob(streamId: number): unknown
+  abstract decode(buffer: ArrayBufferView): any
+  abstract decodeRPC(
+    buffer: ArrayBufferView,
+    context: DecodeRPCContext<() => ProtocolClientStream>,
+  ): ProtocolRPCPayload
+}
+
+export const parseContentTypes = (types: string) => {
+  const normalized = types.trim()
+  if (normalized === '*/*') return ['*/*']
+  return normalized
+    .split(',')
+    .map((t) => t.trim())
+    .map((t) => {
+      const [rawType, ...rest] = t.split(';')
+      const params = new Map(
+        rest.map((p) =>
+          p
+            .trim()
+            .split('=')
+            .slice(0, 2)
+            .map((part) => part.trim()),
+        ) as [string, string][],
+      )
+      return {
+        type: rawType.trim(),
+        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
+    })
+    .map((t) => t.type)
+}
+
+export class ProtocolFormats {
+  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

@@ -0,0 +1,10 @@
+export * from './format.ts'
+export * from './protocol.ts'
+export * from './stream.ts'
+export * from './types.ts'
+export * from './utils.ts'
+
+import { ProtocolVersion } from '../common/enums.ts'
+import { ProtocolVersion1 } from './versions/v1.ts'
+
+export const versions = { [ProtocolVersion.v1]: new ProtocolVersion1() }

package/src/server/protocol.ts

@@ -0,0 +1,97 @@
+import type {
+  ClientMessageType,
+  ProtocolVersion,
+  ServerMessageType,
+} from '../common/enums.ts'
+import type { BaseProtocolError, EncodeRPCStreams } from '../common/types.ts'
+import type { MessageContext } from './types.ts'
+import { concat } from '../common/binary.ts'
+
+export class ProtocolError extends Error implements BaseProtocolError {
+  code: string
+  data?: any
+
+  constructor(code: string, message?: string, data?: any) {
+    super(message)
+    this.code = code
+    this.data = data
+  }
+
+  get message() {
+    return `${this.code} ${super.message}`
+  }
+
+  toString() {
+    return `${this.code} ${this.message}`
+  }
+
+  toJSON() {
+    return { code: this.code, message: this.message, data: this.data }
+  }
+}
+
+export abstract class ProtocolVersionInterface {
+  abstract version: ProtocolVersion
+  abstract decodeMessage(
+    context: MessageContext,
+    buffer: ArrayBufferView,
+  ): {
+    [K in keyof ClientMessageTypePayload]: {
+      type: K
+    } & ClientMessageTypePayload[K]
+  }[keyof ClientMessageTypePayload]
+  abstract encodeMessage<T extends ServerMessageType = ServerMessageType>(
+    context: MessageContext,
+    messageType: T,
+    payload: ServerMessageTypePayload[T],
+  ): ArrayBufferView
+
+  protected encode(
+    ...chunks: (ArrayBuffer | ArrayBufferView)[]
+  ): ArrayBufferView {
+    return concat(...chunks)
+  }
+}
+
+export type ServerMessageTypePayload = {
+  // [ServerMessageType.Event]: { event: string; data: any }
+  [ServerMessageType.RpcResponse]: {
+    callId: number
+    result: any
+    streams: EncodeRPCStreams
+    error: any | null
+  }
+  [ServerMessageType.RpcStreamAbort]: { callId: number; reason?: string }
+  [ServerMessageType.RpcStreamEnd]: { callId: number }
+  [ServerMessageType.RpcStreamChunk]: { callId: number; chunk: ArrayBufferView }
+  [ServerMessageType.RpcStreamResponse]: { callId: number }
+  [ServerMessageType.ClientStreamAbort]: { streamId: number; reason?: string }
+  [ServerMessageType.ClientStreamPull]: { streamId: number; size: number }
+  [ServerMessageType.ServerStreamAbort]: { streamId: number; reason?: string }
+  [ServerMessageType.ServerStreamEnd]: { streamId: number }
+  [ServerMessageType.ServerStreamPush]: {
+    streamId: number
+    chunk: ArrayBufferView
+  }
+}
+
+export type ClientMessageTypePayload = {
+  [ClientMessageType.Rpc]: {
+    rpc: {
+      callId: number
+      procedure: string
+      payload: unknown
+      streams?: EncodeRPCStreams
+    }
+  }
+  [ClientMessageType.RpcPull]: { callId: number }
+  [ClientMessageType.RpcAbort]: { callId: number; reason?: string }
+  [ClientMessageType.ClientStreamPush]: {
+    streamId: number
+    chunk: ArrayBufferView
+  }
+  [ClientMessageType.ClientStreamEnd]: { streamId: number }
+  [ClientMessageType.ClientStreamAbort]: { streamId: number; reason?: string }
+  [ClientMessageType.ServerStreamPull]: { streamId: number; size: number }
+  [ClientMessageType.ServerStreamAbort]: { streamId: number; reason?: string }
+}

package/src/server/stream.ts

@@ -0,0 +1,51 @@
+import type { ReadableOptions } from 'node:stream'
+import { PassThrough, Readable } from 'node:stream'
+import { ReadableStream } from 'node:stream/web'
+
+import type { ProtocolBlob, ProtocolBlobMetadata } from '../common/blob.ts'
+
+export class ProtocolClientStream extends PassThrough {
+  readonly #read?: ReadableOptions['read']
+
+  constructor(
+    public readonly id: number,
+    public readonly metadata: ProtocolBlobMetadata,
+    options?: ReadableOptions,
+  ) {
+    const { read, ...rest } = options ?? {}
+    super(rest)
+    this.#read = read
+  }
+
+  override _read(size: number): void {
+    if (this.#read) {
+      this.#read.call(this, size)
+    }
+    super._read(size)
+  }
+}
+
+export class ProtocolServerStream extends PassThrough {
+  public readonly id: number
+  public readonly metadata: ProtocolBlobMetadata
+
+  constructor(id: number, blob: ProtocolBlob) {
+    let readable: Readable
+
+    if (blob.source instanceof Readable) {
+      readable = blob.source
+    } else if (blob.source instanceof ReadableStream) {
+      readable = Readable.fromWeb(blob.source as ReadableStream)
+    } else {
+      throw new Error('Invalid source type')
+    }
+
+    super()
+
+    this.pause()
+    readable.pipe(this)
+
+    this.id = id
+    this.metadata = blob.metadata
+  }
+}

package/src/server/types.ts

@@ -0,0 +1,42 @@
+import type { PlainType } from '@nmtjs/type'
+
+import type {
+  ProtocolBlobInterface,
+  ProtocolBlobMetadata,
+} from '../common/blob.ts'
+import type { kBlobKey } from '../common/constants.ts'
+import type { BaseServerDecoder, BaseServerEncoder } from './format.ts'
+import type { ProtocolVersionInterface } from './protocol.ts'
+import type { ProtocolClientStream } from './stream.ts'
+
+export type ClientStreamConsumer = (() => ProtocolClientStream) & {
+  readonly [kBlobKey]: any
+  readonly metadata: ProtocolBlobMetadata
+}
+
+export type MessageContext = {
+  protocol: ProtocolVersionInterface
+  connectionId: string
+  streamId: () => number
+  decoder: BaseServerDecoder
+  encoder: BaseServerEncoder
+  addClientStream: (options: {
+    streamId: number
+    metadata: ProtocolBlobMetadata
+    callId: number
+  }) => ClientStreamConsumer
+  transport: {
+    send?: (connectionId: string, buffer: ArrayBufferView) => boolean | null
+  }
+}
+
+export type ResolveFormatParams = {
+  contentType?: string | null
+  accept?: string | null
+}
+
+export type InputType<T> = T extends ProtocolBlobInterface
+  ? ClientStreamConsumer
+  : T extends { [PlainType]?: true }
+    ? { [K in keyof Omit<T, PlainType>]: InputType<T[K]> }
+    : T

package/src/server/utils.ts

@@ -0,0 +1,22 @@
+import type { ProtocolFormats } from './format.ts'
+import type { ResolveFormatParams } from './types.ts'
+
+export class UnsupportedFormatError extends Error {}
+
+export class UnsupportedContentTypeError extends UnsupportedFormatError {}
+
+export class UnsupportedAcceptTypeError extends UnsupportedFormatError {}
+
+export const getFormat = (
+  format: ProtocolFormats,
+  { accept, contentType }: ResolveFormatParams,
+) => {
+  const encoder = contentType ? format.supportsEncoder(contentType) : undefined
+  if (!encoder)
+    throw new UnsupportedContentTypeError('Unsupported Content type')
+
+  const decoder = accept ? format.supportsDecoder(accept) : undefined
+  if (!decoder) throw new UnsupportedAcceptTypeError('Unsupported Accept type')
+
+  return { encoder, decoder }
+}