@nmtjs/client 0.16.0-beta.1 → 0.16.0-beta.10

package/src/layers/streams.ts

@@ -1,10 +1,16 @@
-import type { ProtocolBlob, ProtocolBlobMetadata } from '@nmtjs/protocol'
 import type {
-  ProtocolClientBlobStream,
-  ProtocolServerBlobConsumer,
-} from '@nmtjs/protocol/client'
+  ProtocolBlob,
+  ProtocolBlobInterface,
+  ProtocolBlobMetadata,
+} from '@nmtjs/protocol'
+import type { ProtocolClientBlobStream } from '@nmtjs/protocol/client'
 import { MAX_UINT32, noopFn } from '@nmtjs/common'
-import { ClientMessageType, kBlobKey, ServerMessageType } from '@nmtjs/protocol'
+import {
+  ClientMessageType,
+  createProtocolBlobReference,
+  getProtocolBlobStreamId,
+  ServerMessageType,
+} from '@nmtjs/protocol'
 import { ProtocolServerBlobStream } from '@nmtjs/protocol/client'
 
 import type { ClientCore } from '../core.ts'
@@ -23,44 +29,36 @@ export interface StreamLayerApi {
   readonly serverStreams: ServerStreams
   getStreamId: () => number
   addClientStream: (blob: ProtocolBlob) => ProtocolClientBlobStream
-  createServerBlobStream: (
+  createServerBlob: (
     streamId: number,
     metadata: ProtocolBlobMetadata,
-  ) => ProtocolServerBlobConsumer
-  addServerBlobStream: (metadata: ProtocolBlobMetadata) => {
+  ) => ProtocolBlobInterface
+  addServerBlobStream: (
+    metadata: ProtocolBlobMetadata,
+    options?: {
+      start?: (
+        stream: ProtocolServerBlobStream,
+        options?: { signal?: AbortSignal },
+      ) => void
+    },
+  ) => {
+    blob: ProtocolBlobInterface
     streamId: number
     stream: ProtocolServerBlobStream
   }
-}
-
-export const createServerBlobConsumer = (
-  metadata: ProtocolBlobMetadata,
-  subscribe: (options?: { signal?: AbortSignal }) => ProtocolServerBlobStream,
-): ProtocolServerBlobConsumer => {
-  const consumer = ((options?: { signal?: AbortSignal }) =>
-    subscribe(options)) as ProtocolServerBlobConsumer
-
-  Object.defineProperties(consumer, {
-    metadata: {
-      configurable: false,
-      enumerable: true,
-      writable: false,
-      value: metadata,
-    },
-    [kBlobKey]: {
-      configurable: false,
-      enumerable: false,
-      writable: false,
-      value: true,
-    },
-  })
-
-  return consumer
+  consumeServerBlob: (
+    blob: ProtocolBlobInterface,
+    options?: { signal?: AbortSignal },
+  ) => ProtocolServerBlobStream
 }
 
 export const createStreamLayer = (core: ClientCore): StreamLayerApi => {
   const clientStreams = new ClientStreams()
-  const serverStreams = new ServerStreams()
+  const serverStreams = new ServerStreams<ProtocolServerBlobStream>()
+  const serverBlobInitializers = new Map<
+    number,
+    (options?: { signal?: AbortSignal }) => void
+  >()
 
   let streamId = 0
 
@@ -77,10 +75,29 @@ export const createStreamLayer = (core: ClientCore): StreamLayerApi => {
     return clientStreams.add(blob.source, id, blob.metadata)
   }
 
-  const createServerBlobStream = (
-    id: number,
-    metadata: ProtocolBlobMetadata,
-  ) => {
+  const abortServerBlob = (streamId: number, reason?: unknown) => {
+    if (core.messageContext) {
+      core.emitStreamEvent({
+        direction: 'outgoing',
+        streamType: 'server_blob',
+        action: 'abort',
+        streamId,
+        reason: toReasonString(reason),
+      })
+
+      const buffer = core.protocol.encodeMessage(
+        core.messageContext,
+        ClientMessageType.ServerStreamAbort,
+        { streamId, reason: toReasonString(reason) },
+      )
+
+      core.send(buffer).catch(noopFn)
+    }
+
+    void serverStreams.abort(streamId).catch(noopFn)
+  }
+
+  const createServerBlob = (id: number, metadata: ProtocolBlobMetadata) => {
     const stream = new ProtocolServerBlobStream(metadata, {
       pull: () => {
         if (!core.messageContext) return
@@ -102,6 +119,7 @@ export const createStreamLayer = (core: ClientCore): StreamLayerApi => {
         core.send(buffer).catch(noopFn)
       },
       close: () => {
+        serverBlobInitializers.delete(id)
         serverStreams.remove(id)
       },
       readableStrategy: { highWaterMark: 0 },
@@ -109,43 +127,64 @@ export const createStreamLayer = (core: ClientCore): StreamLayerApi => {
 
     serverStreams.add(id, stream)
 
-    return createServerBlobConsumer(metadata, ({ signal } = {}) => {
-      if (signal) {
-        signal.addEventListener(
-          'abort',
-          () => {
-            if (!core.messageContext) return
+    return createProtocolBlobReference(id, metadata)
+  }
 
-            core.emitStreamEvent({
-              direction: 'outgoing',
-              streamType: 'server_blob',
-              action: 'abort',
-              streamId: id,
-              reason: toReasonString(signal.reason),
-            })
+  const addServerBlobStream = (
+    metadata: ProtocolBlobMetadata,
+    options?: {
+      start?: (
+        stream: ProtocolServerBlobStream,
+        options?: { signal?: AbortSignal },
+      ) => void
+    },
+  ) => {
+    const id = getStreamId()
+    const stream = new ProtocolServerBlobStream(metadata)
+    serverStreams.add(id, stream)
 
-            const buffer = core.protocol.encodeMessage(
-              core.messageContext,
-              ClientMessageType.ServerStreamAbort,
-              { streamId: id, reason: toReasonString(signal.reason) },
-            )
+    if (options?.start) {
+      let started = false
+      serverBlobInitializers.set(id, (subscriptionOptions) => {
+        if (started) return
+        started = true
+        options.start?.(stream, subscriptionOptions)
+      })
+    }
 
-            core.send(buffer).catch(noopFn)
-            void serverStreams.abort(id).catch(noopFn)
-          },
-          { once: true },
-        )
-      }
+    return {
+      blob: createProtocolBlobReference(id, metadata),
+      streamId: id,
+      stream,
+    }
+  }
+
+  const consumeServerBlob = (
+    blob: ProtocolBlobInterface,
+    options?: { signal?: AbortSignal },
+  ) => {
+    const id = getProtocolBlobStreamId(blob)
+    const stream = serverStreams.get(id)
 
+    if (options?.signal?.aborted) {
+      abortServerBlob(id, options.signal.reason)
       return stream
-    })
-  }
+    }
 
-  const addServerBlobStream = (metadata: ProtocolBlobMetadata) => {
-    const id = getStreamId()
-    const stream = new ProtocolServerBlobStream(metadata)
-    serverStreams.add(id, stream)
-    return { streamId: id, stream }
+    if (options?.signal) {
+      options.signal.addEventListener(
+        'abort',
+        () => {
+          abortServerBlob(id, options.signal?.reason)
+        },
+        { once: true },
+      )
+    }
+
+    serverBlobInitializers.get(id)?.(options)
+    serverBlobInitializers.delete(id)
+
+    return stream
   }
 
   core.on('message', (message: any) => {
@@ -161,6 +200,7 @@ export const createStreamLayer = (core: ClientCore): StreamLayerApi => {
         void serverStreams.push(message.streamId, message.chunk)
         break
       case ServerMessageType.ServerStreamEnd:
+        serverBlobInitializers.delete(message.streamId)
         core.emitStreamEvent({
           direction: 'incoming',
           streamType: 'server_blob',
@@ -170,6 +210,7 @@ export const createStreamLayer = (core: ClientCore): StreamLayerApi => {
         void serverStreams.end(message.streamId)
         break
       case ServerMessageType.ServerStreamAbort:
+        serverBlobInitializers.delete(message.streamId)
         core.emitStreamEvent({
           direction: 'incoming',
           streamType: 'server_blob',
@@ -264,6 +305,7 @@ export const createStreamLayer = (core: ClientCore): StreamLayerApi => {
   core.on('disconnected', (reason) => {
     void clientStreams.clear(reason).catch(noopFn)
     void serverStreams.clear(reason).catch(noopFn)
+    serverBlobInitializers.clear()
   })
 
   return {
@@ -271,7 +313,8 @@ export const createStreamLayer = (core: ClientCore): StreamLayerApi => {
     serverStreams,
     getStreamId,
     addClientStream,
-    createServerBlobStream,
+    createServerBlob,
     addServerBlobStream,
+    consumeServerBlob,
   }
 }

package/src/types.ts

@@ -1,11 +1,7 @@
 import type { CallTypeProvider, OneOf, TypeProvider } from '@nmtjs/common'
 import type { TAnyProcedureContract, TAnyRouterContract } from '@nmtjs/contract'
-import type { ProtocolBlobInterface } from '@nmtjs/protocol'
-import type {
-  ProtocolError,
-  ProtocolServerBlobConsumer,
-} from '@nmtjs/protocol/client'
-import type { BaseTypeAny, PlainType, t } from '@nmtjs/type'
+import type { ProtocolError } from '@nmtjs/protocol/client'
+import type { BaseTypeAny, t } from '@nmtjs/type'
 
 export const ResolvedType: unique symbol = Symbol('ResolvedType')
 export type ResolvedType = typeof ResolvedType
@@ -25,12 +21,6 @@ export type BlobSubscriptionOptions = { signal?: AbortSignal }
 
 export type StreamSubscriptionOptions = Partial<StreamCallOptions>
 
-export type ClientOutputType<T> = T extends ProtocolBlobInterface
-  ? ProtocolServerBlobConsumer
-  : T extends { [PlainType]?: true }
-    ? { [K in keyof Omit<T, PlainType>]: ClientOutputType<T[K]> }
-    : T
-
 export interface StaticInputContractTypeProvider extends TypeProvider {
   output: this['input'] extends BaseTypeAny
     ? t.infer.decode.input<this['input']>
@@ -45,13 +35,13 @@ export interface RuntimeInputContractTypeProvider extends TypeProvider {
 
 export interface StaticOutputContractTypeProvider extends TypeProvider {
   output: this['input'] extends BaseTypeAny
-    ? ClientOutputType<t.infer.encodeRaw.output<this['input']>>
+    ? t.infer.encode.output<this['input']>
     : never
 }
 
 export interface RuntimeOutputContractTypeProvider extends TypeProvider {
   output: this['input'] extends BaseTypeAny
-    ? ClientOutputType<t.infer.decodeRaw.output<this['input']>>
+    ? t.infer.decode.output<this['input']>
     : never
 }