@nmtjs/protocol 0.8.1 → 0.9.0

package/src/client/stream.ts

@@ -1,4 +1,4 @@
-import { type Callback, defer } from '@nmtjs/common'
+import { type Callback, defer, noopFn } from '@nmtjs/common'
 import { concat, encodeText } from '../common/binary.ts'
 import type { ProtocolBlobMetadata } from '../common/blob.ts'
 
@@ -75,32 +75,25 @@ export class ProtocolServerStream<T = any>
   extends TransformStream<any, T>
   implements ProtocolServerStreamInterface<T>
 {
-  #writer: WritableStreamDefaultWriter
-
-  constructor(start?: Callback) {
-    super({ start })
-    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 return void 0
+      else break
     }
   }
 
   async push(chunk: T) {
-    await this.#writer.write(chunk)
+    await this.writable.getWriter().write(chunk)
   }
 
   async end() {
-    await this.#writer.close()
+    await this.writable.getWriter().close()
   }
 
   abort(error = new Error('Stream aborted')) {
-    this.#writer.abort(error)
+    this.writable.getWriter().abort(error)
   }
 }
 
@@ -108,8 +101,8 @@ export class ProtocolServerBlobStream extends ProtocolServerStream<ArrayBuffer>
   constructor(
     readonly id: number,
     readonly metadata: ProtocolBlobMetadata,
-    start: Callback,
+    options?: Transformer<any, ArrayBuffer>,
   ) {
-    super(start)
+    super(options)
   }
 }

package/src/client/types.ts

@@ -0,0 +1,14 @@
+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/blob.ts

@@ -1,24 +1,31 @@
+export const BlobKey: unique symbol = Symbol.for('neemata:BlobKey')
+export type BlobKey = typeof BlobKey
+
 export type ProtocolBlobMetadata = {
   type: string
-  size: number
+  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 = -1,
+    size?: number,
     type = 'application/octet-stream',
     filename?: string,
   ) {
-    if (size < -1 || size === 0) throw new Error('Blob size is invalid')
+    if (typeof size !== 'undefined' && size <= 0)
+      throw new Error('Blob size is invalid')
 
     this.source = source
     this.metadata = {

package/src/common/enums.ts

@@ -16,11 +16,13 @@ export enum ServerMessageType {
   RpcResponse = 10,
   RpcStreamResponse = 11,
   RpcStreamChunk = 12,
-  RpcStreamAbort = 13,
+  RpcStreamEnd = 13,
+  RpcStreamAbort = 14,
 
   ServerStreamPush = 20,
   ServerStreamEnd = 21,
   ServerStreamAbort = 22,
+
   ClientStreamAbort = 23,
   ClientStreamPull = 24,
 }

package/src/common/types.ts

@@ -1,9 +1,13 @@
-import type { ProtocolServerBlobStream } from '../client/stream.ts'
-import type {
-  ProtocolBlob,
-  ProtocolBlobInterface,
-  ProtocolBlobMetadata,
-} from './blob.ts'
+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
@@ -12,49 +16,26 @@ export type ProtocolRPC = {
   payload: any
 }
 
-export type ProtocolRPCResponse =
-  | {
+export type ProtocolRPCResponse<T = Stream> = OneOf<
+  [
+    {
       callId: number
-      error: any
-      payload?: never
-    }
-  | {
+      error: BaseProtocolError
+    },
+    {
       callId: number
-      payload: any
-      error?: never
-    }
-
-export interface EncodeRPCContext {
-  getStream: (id: number) => any
-  addStream: (blob: ProtocolBlob) => {
-    id: number
-    metadata: ProtocolBlobMetadata
-  }
-}
-
-export interface DecodeRPCContext {
-  getStream: (id: number) => any
-  addStream: (id: number, metadata: ProtocolBlobMetadata) => any
-}
-
-export interface BaseClientDecoder {
-  decode(buffer: ArrayBuffer): any
-  decodeRPC(buffer: ArrayBuffer, context: DecodeRPCContext): ProtocolRPCResponse
+      result: any
+      streams: Record<number, T>
+    },
+  ]
+>
+
+export interface EncodeRPCContext<T = Stream> {
+  getStream: (id: number) => T
+  addStream: (blob: ProtocolBlob) => T
 }
 
-export interface BaseClientEncoder {
-  encode(data: any): ArrayBuffer
-  encodeRPC(rpc: ProtocolRPC, context: EncodeRPCContext): ArrayBuffer
+export interface DecodeRPCContext<T = Stream> {
+  getStream: (id: number, callId: number) => T
+  addStream: (id: number, callId: number, metadata: ProtocolBlobMetadata) => T
 }
-
-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/server/api.ts

@@ -1,4 +1,9 @@
-import type { Container } from '@nmtjs/core'
+import type {
+  Container,
+  Metadata,
+  MetadataKey,
+  MetadataStore,
+} from '@nmtjs/core'
 import type { Hook } from '@nmtjs/core'
 import type { Connection } from './connection.ts'
 
@@ -9,6 +14,7 @@ export type ProtocolApiCallOptions = {
   container: Container
   payload: any
   signal: AbortSignal
+  metadata?: (metadata: MetadataStore) => void
 }
 
 export type ProtocolAnyIterable<T> =
@@ -34,6 +40,14 @@ export type ProtocolApiCallResult =
   | ProtocolApiCallSubscriptionResult
   | ProtocolApiCallIterableResult
 
+export const isIterableResult = (
+  result: ProtocolApiCallResult,
+): result is ProtocolApiCallIterableResult => 'iterable' in result
+
+export const isSubscriptionResult = (
+  result: ProtocolApiCallResult,
+): result is ProtocolApiCallSubscriptionResult => 'subscription' in result
+
 export interface ProtocolApi {
   call(options: ProtocolApiCallOptions): Promise<ProtocolApiCallResult>
 }

package/src/server/connection.ts

@@ -20,13 +20,9 @@ export class Connection<Data = unknown> {
   }
 }
 
-export type ConnectionCall<T = unknown> = InteractivePromise<T> & {
-  abort: AbortController['abort']
-}
-
 export class ConnectionContext {
   streamId = 1
-  calls = new Map<number, ConnectionCall<ProtocolApiCallResult>>()
+  calls = new Map<number, AbortController>()
   clientStreams = new Map<number, ProtocolClientStream>()
   serverStreams = new Map<number, ProtocolServerStream>()
   rpcStreams = new Map<number, AbortController>()

package/src/server/format.ts

@@ -1,3 +1,4 @@
+import type { OneOf } from '@nmtjs/common'
 import { match, type Pattern } from '@nmtjs/core'
 import type {
   DecodeRPCContext,
@@ -5,17 +6,26 @@ import type {
   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): ProtocolRPC
+  decodeRPC(
+    buffer: ArrayBuffer,
+    context: DecodeRPCContext<ProtocolClientStream>,
+  ): ProtocolRPC
 }
 
 export interface BaseServerEncoder {
   contentType: string
   encode(data: any): ArrayBuffer
-  encodeRPC(rpc: ProtocolRPCResponse, context: EncodeRPCContext): ArrayBuffer
+  encodeRPC(
+    rpc: OneOf<
+      [{ callId: number; error: any }, { callId: number; result: any }]
+    >,
+    context: EncodeRPCContext<ProtocolServerStream>,
+  ): ArrayBuffer
 }
 
 export abstract class BaseServerFormat
@@ -27,12 +37,12 @@ export abstract class BaseServerFormat
   abstract encode(data: any): ArrayBuffer
   abstract encodeRPC(
     rpc: ProtocolRPCResponse,
-    context: EncodeRPCContext,
+    context: EncodeRPCContext<ProtocolServerStream>,
   ): ArrayBuffer
   abstract decode(buffer: ArrayBuffer): any
   abstract decodeRPC(
     buffer: ArrayBuffer,
-    context: DecodeRPCContext,
+    context: DecodeRPCContext<ProtocolClientStream>,
   ): ProtocolRPC
 }
 

package/src/server/index.ts

@@ -7,4 +7,5 @@ export * from './protocol.ts'
 export * from './registry.ts'
 export * from './stream.ts'
 export * from './transport.ts'
+export * from './types.ts'
 export * from './utils.ts'