@rdfc/js-runner 2.0.0-alpha.6 → 2.0.0-alpha.7

package/src/writer.ts

@@ -5,85 +5,86 @@ import { Any } from './reader'
 
 type Writable = (msg: OrchestratorMessage) => Promise<unknown>
 export interface Writer {
-  buffer(buffer: Uint8Array): Promise<void>
+    readonly uri: string;
+    buffer(buffer: Uint8Array): Promise<void>
 
-  stream(buffer: AsyncIterable<Uint8Array>): Promise<void>
-  stream<T>(
-    buffer: AsyncIterable<T>,
-    tranform: (x: T) => Uint8Array,
-  ): Promise<void>
+    stream(buffer: AsyncIterable<Uint8Array>): Promise<void>
+    stream<T>(
+        buffer: AsyncIterable<T>,
+        tranform: (x: T) => Uint8Array,
+    ): Promise<void>
 
-  string(buffer: string): Promise<void>
-  any(any: Any): Promise<void>
-  close(): Promise<void>
+    string(buffer: string): Promise<void>
+    any(any: Any): Promise<void>
+    close(): Promise<void>
 }
 const encoder = new TextEncoder()
 export class WriterInstance implements Writer {
-  private readonly uri: string
-  private readonly client: RunnerClient
-  private readonly write: Writable
-  private readonly logger: Logger
+    readonly uri: string
+    private readonly client: RunnerClient
+    private readonly write: Writable
+    private readonly logger: Logger
 
-  constructor(
-    uri: string,
-    client: RunnerClient,
-    write: Writable,
-    logger: Logger,
-  ) {
-    this.client = client
-    this.write = write
-    this.uri = uri
-    this.logger = logger
-  }
-  async any(any: Any): Promise<void> {
-    if ('stream' in any) {
-      await this.stream(any.stream)
+    constructor(
+        uri: string,
+        client: RunnerClient,
+        write: Writable,
+        logger: Logger,
+    ) {
+        this.client = client
+        this.write = write
+        this.uri = uri
+        this.logger = logger
     }
-    if ('buffer' in any) {
-      await this.buffer(any.buffer)
+    async any(any: Any): Promise<void> {
+        if ('stream' in any) {
+            await this.stream(any.stream)
+        }
+        if ('buffer' in any) {
+            await this.buffer(any.buffer)
+        }
+        if ('string' in any) {
+            await this.string(any.string)
+        }
     }
-    if ('string' in any) {
-      await this.string(any.string)
+
+    async buffer(buffer: Uint8Array): Promise<void> {
+        this.logger.debug(`${this.uri} sends buffer ${buffer.length} bytes`)
+        await this.write({ msg: { data: buffer, channel: this.uri } })
     }
-  }
 
-  async buffer(buffer: Uint8Array): Promise<void> {
-    this.logger.debug(`${this.uri} sends buffer ${buffer.length} bytes`)
-    await this.write({ msg: { data: buffer, channel: this.uri } })
-  }
+    async stream<T = Uint8Array>(
+        buffer: AsyncIterable<T>,
+        transform?: (x: T) => Uint8Array,
+    ) {
+        const t = transform || ((x: unknown) => <Uint8Array>x)
+        const stream = this.client.sendStreamMessage()
+        const id: Id = await new Promise((res) => stream.once('data', res))
+        this.logger.debug(`${this.uri} streams message with id ${id.id}`)
+        await this.write({ streamMsg: { id, channel: this.uri } })
 
-  async stream<T = Uint8Array>(
-    buffer: AsyncIterable<T>,
-    transform?: (x: T) => Uint8Array,
-  ) {
-    const t = transform || ((x: unknown) => <Uint8Array>x)
-    const stream = this.client.sendStreamMessage()
-    const id: Id = await new Promise((res) => stream.once('data', res))
-    this.logger.debug(`${this.uri} streams message with id ${id.id}`)
-    await this.write({ streamMsg: { id, channel: this.uri } })
+        const write = promisify(stream.write.bind(stream))
+        for await (const msg of buffer) {
+            await write({ data: t(msg) })
+        }
 
-    const write = promisify(stream.write.bind(stream))
-    for await (const msg of buffer) {
-      await write({ data: t(msg) })
+        this.logger.debug(`${this.uri} is done streaming message with id ${id.id}`)
+        stream.end()
     }
 
-    this.logger.debug(`${this.uri} is done streaming message with id ${id.id}`)
-    stream.end()
-  }
-
-  async string(msg: string): Promise<void> {
-    this.logger.debug(`${this.uri} sends string ${msg.length} characters`)
-    await this.write({
-      msg: { data: encoder.encode(msg), channel: this.uri },
-    })
-  }
+    async string(msg: string): Promise<void> {
+        this.logger.debug(`${this.uri} sends string ${msg.length} characters`)
+        await this.write({
+            msg: { data: encoder.encode(msg), channel: this.uri },
+        })
+    }
 
-  async close(issued = false): Promise<void> {
-    this.logger.debug(`${this.uri} closes stream`)
-    if (!issued) {
-      await this.write({
-        close: { channel: this.uri },
-      })
+    async close(issued = false): Promise<void> {
+        this.logger.debug(`${this.uri} closes stream`)
+        if (!issued) {
+            await this.write({
+                close: { channel: this.uri },
+            })
+        }
     }
-  }
 }