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

package/src/testUtils.ts

@@ -1,20 +1,22 @@
-import { DataChunk, OrchestratorMessage, RunnerClient } from '@rdfc/proto'
+import { DataChunk, RunnerClient } from '@rdfc/proto'
 import { ClientReadableStream } from '@grpc/grpc-js'
 import * as grpc from '@grpc/grpc-js'
 import { ClientReadableStreamImpl } from './reexports'
-import { extractShapes } from 'rdf-lens';
-import { Parser } from 'n3';
-import { readFile } from 'fs/promises';
-import winston, { createLogger } from 'winston';
-import { WriterInstance } from './writer';
-import { ReaderInstance } from './reader';
+import { extractShapes } from 'rdf-lens'
+import { Parser } from 'n3'
+import { readFile } from 'fs/promises'
+import winston, { createLogger } from 'winston'
+import { WriterInstance } from './writer'
+import { ReaderInstance } from './reader'
 
-export async function getProcessorShape(baseIRI = process.cwd() + "/node_modules/@rdfc/js-runner/index.ttl") {
-  const configFile = await readFile(baseIRI, { encoding: "utf8" });
-  const configQuads = new Parser().parse(configFile);
-  const shapes = extractShapes(configQuads);
+export async function getProcessorShape(
+  baseIRI = process.cwd() + '/node_modules/@rdfc/js-runner/index.ttl',
+) {
+  const configFile = await readFile(baseIRI, { encoding: 'utf8' })
+  const configQuads = new Parser().parse(configFile)
+  const shapes = extractShapes(configQuads)
 
-  return shapes;
+  return shapes
 }
 
 export class TestClient extends RunnerClient {
@@ -46,23 +48,30 @@ export async function one<T>(iter: AsyncIterable<T>): Promise<T | undefined> {
 export const client = new TestClient()
 export const uri = 'someUri'
 export const logger = createLogger({
-  transports: new winston.transports.Console({ level: process.env['DEBUG'] || 'info' }),
+  transports: new winston.transports.Console({
+    level: process.env['DEBUG'] || 'info',
+  }),
 })
 
 export function createWriter(iri = uri): [WriterInstance, ReaderInstance] {
-  const reader = createReader(iri);
-  const writeStream = new WriterInstance(iri, client, async (msg) => {
-    if (msg.msg) {
-      reader.handleMsg(msg.msg);
-    }
-    if(msg.close) {
-      reader.close()
-    }
-  }, logger)
-  return [writeStream, reader];
+  const reader = createReader(iri)
+  const writeStream = new WriterInstance(
+    iri,
+    client,
+    async (msg) => {
+      if (msg.msg) {
+        reader.handleMsg(msg.msg)
+      }
+      if (msg.close) {
+        reader.close()
+      }
+    },
+    logger,
+  )
+  return [writeStream, reader]
 }
 
 export function createReader(iri = uri): ReaderInstance {
-  const reader = new ReaderInstance(iri, client, logger);
-  return reader;
+  const reader = new ReaderInstance(iri, client, logger)
+  return reader
 }

package/src/util_processors.ts

@@ -16,5 +16,5 @@ export class LogProcessor extends Processor<LogArgs> {
     }
   }
 
-  async produce() { }
+  async produce() {}
 }

package/src/writer.ts

@@ -5,86 +5,86 @@ import { Any } from './reader'
 
 type Writable = (msg: OrchestratorMessage) => Promise<unknown>
 export interface Writer {
-    readonly uri: string;
-    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 {
-    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
+  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)
     }
-    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 ('buffer' in any) {
+      await this.buffer(any.buffer)
     }
-
-    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 } })
+    if ('string' in any) {
+      await this.string(any.string)
     }
+  }
 
-    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 buffer(buffer: Uint8Array): Promise<void> {
+    this.logger.debug(`${this.uri} sends buffer ${buffer.length} bytes`)
+    await this.write({ msg: { data: buffer, channel: this.uri } })
+  }
 
-        const write = promisify(stream.write.bind(stream))
-        for await (const msg of buffer) {
-            await write({ data: t(msg) })
-        }
+  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 } })
 
-        this.logger.debug(`${this.uri} is done streaming message with id ${id.id}`)
-        stream.end()
+    const write = promisify(stream.write.bind(stream))
+    for await (const msg of buffer) {
+      await write({ data: t(msg) })
     }
 
-    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 },
-        })
-    }
+    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 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 },
+      })
     }
+  }
 }

package/vite.config.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("vitest/config");
+exports.default = (0, config_1.defineConfig)({
+    test: {
+        coverage: {
+            enabled: true,
+            include: ['src/'],
+        },
+    },
+});