@rdfc/js-runner 2.0.0 → 3.0.1

package/lib/writer.d.ts

@@ -1,26 +1,33 @@
-import { OrchestratorMessage, RunnerClient } from '@rdfc/proto';
+import { FromRunner, RunnerClient } from '@rdfc/proto';
 import { Logger } from 'winston';
 import { Any } from './reader.js';
-type Writable = (msg: OrchestratorMessage) => Promise<unknown>;
+type Writable = (msg: FromRunner) => Promise<unknown>;
 export interface Writer {
     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<T>(buffer: AsyncIterable<T>, transform: (x: T) => Uint8Array): Promise<void>;
     string(buffer: string): Promise<void>;
     any(any: Any): Promise<void>;
     close(): Promise<void>;
 }
 export declare class WriterInstance implements Writer {
     readonly uri: string;
+    localSequenceNumber: number;
     private readonly client;
-    private readonly write;
+    private readonly notifyOrchestrator;
     private readonly logger;
-    constructor(uri: string, client: RunnerClient, write: Writable, logger: Logger);
+    private awaitingProcessed;
+    private openStreams;
+    private shouldClose;
+    private readonly runnerId;
+    constructor(uri: string, client: RunnerClient, notifyOrchestrator: Writable, runnerId: string, logger: Logger);
+    private awaitProcessed;
     any(any: Any): Promise<void>;
     buffer(buffer: Uint8Array): Promise<void>;
     stream<T = Uint8Array>(buffer: AsyncIterable<T>, transform?: (x: T) => Uint8Array): Promise<void>;
     string(msg: string): Promise<void>;
     close(issued?: boolean): Promise<void>;
+    handled(): void;
 }
 export {};

package/lib/writer.js

@@ -2,14 +2,23 @@ import { promisify } from 'util';
 const encoder = new TextEncoder();
 export class WriterInstance {
     uri;
+    localSequenceNumber = 1;
     client;
-    write;
+    notifyOrchestrator;
     logger;
-    constructor(uri, client, write, logger) {
+    awaitingProcessed = [];
+    openStreams = 0;
+    shouldClose = [];
+    runnerId;
+    constructor(uri, client, notifyOrchestrator, runnerId, logger) {
         this.client = client;
-        this.write = write;
+        this.notifyOrchestrator = notifyOrchestrator;
         this.uri = uri;
         this.logger = logger;
+        this.runnerId = runnerId;
+    }
+    awaitProcessed() {
+        return new Promise((res) => this.awaitingProcessed.push(res));
     }
     async any(any) {
         if ('stream' in any) {
@@ -24,34 +33,78 @@ export class WriterInstance {
     }
     async buffer(buffer) {
         this.logger.debug(`${this.uri} sends buffer ${buffer.length} bytes`);
-        await this.write({ msg: { data: buffer, channel: this.uri } });
+        const localSequenceNumber = this.localSequenceNumber++;
+        const handledPromise = this.awaitProcessed();
+        await this.notifyOrchestrator({
+            msg: { data: buffer, channel: this.uri, localSequenceNumber },
+        });
+        await handledPromise;
     }
     async stream(buffer, transform) {
+        this.openStreams += 1;
         const t = transform || ((x) => x);
         const stream = this.client.sendStreamMessage();
+        const handledPromise = this.awaitProcessed();
+        const writeStreamMessageChunk = promisify(stream.write.bind(stream));
+        const localSequenceNumber = this.localSequenceNumber++;
+        await writeStreamMessageChunk({
+            id: {
+                channel: this.uri,
+                localSequenceNumber,
+                runner: this.runnerId,
+            },
+        });
         const 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));
+        this.logger.debug(`${this.uri} streams message with id ${JSON.stringify(id)}`);
         for await (const msg of buffer) {
-            await write({ data: t(msg) });
+            const processedPromise = new Promise((res) => stream.once('data', res));
+            await writeStreamMessageChunk({ data: { data: t(msg) } });
+            await processedPromise;
         }
-        this.logger.debug(`${this.uri} is done streaming message with id ${id.id}`);
         stream.end();
+        await handledPromise;
+        this.openStreams -= 1;
+        if (this.shouldClose.length > 0)
+            await this.close();
     }
     async string(msg) {
         this.logger.debug(`${this.uri} sends string ${msg.length} characters`);
-        await this.write({
-            msg: { data: encoder.encode(msg), channel: this.uri },
+        const localSequenceNumber = this.localSequenceNumber++;
+        const handledPromise = this.awaitProcessed();
+        await this.notifyOrchestrator({
+            msg: {
+                data: encoder.encode(msg),
+                channel: this.uri,
+                localSequenceNumber,
+            },
         });
+        await handledPromise;
     }
     async close(issued = false) {
+        if (this.openStreams !== 0) {
+            await new Promise((resolve) => this.shouldClose.push(resolve));
+            return;
+        }
         this.logger.debug(`${this.uri} closes stream`);
         if (!issued) {
-            await this.write({
+            await this.notifyOrchestrator({
                 close: { channel: this.uri },
             });
         }
+        let resolve = this.shouldClose.pop();
+        while (resolve) {
+            resolve();
+            resolve = this.shouldClose.pop();
+        }
+    }
+    handled() {
+        if (this.awaitingProcessed.length > 0) {
+            this.awaitingProcessed.shift()();
+        }
+        else {
+            this.logger.error('Expected to be waiting for a message to be processed, but this is not the case ' +
+                this.uri);
+        }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writer.js","sourceRoot":"","sources":["../src/writer.ts"],"names":[],"mappings":"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","sourcesContent":["import { FromRunner, RunnerClient } from '@rdfc/proto'\nimport { promisify } from 'util'\nimport { Logger } from 'winston'\nimport { Any } from './reader'\n\ntype Writable = (msg: FromRunner) => Promise<unknown>\nexport interface Writer {\n  readonly uri: string\n  buffer(buffer: Uint8Array): Promise<void>\n\n  stream(buffer: AsyncIterable<Uint8Array>): Promise<void>\n  stream<T>(\n    buffer: AsyncIterable<T>,\n    transform: (x: T) => Uint8Array,\n  ): Promise<void>\n\n  string(buffer: string): Promise<void>\n  any(any: Any): Promise<void>\n  close(): Promise<void>\n}\nconst encoder = new TextEncoder()\nexport class WriterInstance implements Writer {\n  readonly uri: string\n  localSequenceNumber: number = 1\n  private readonly client: RunnerClient\n  private readonly notifyOrchestrator: Writable\n  private readonly logger: Logger\n\n  private awaitingProcessed: Array<() => void> = []\n\n  private openStreams: number = 0\n  private shouldClose: Array<() => void> = []\n\n  private readonly runnerId: string\n\n  constructor(\n    uri: string,\n    client: RunnerClient,\n    notifyOrchestrator: Writable,\n    runnerId: string,\n    logger: Logger,\n  ) {\n    this.client = client\n    this.notifyOrchestrator = notifyOrchestrator\n    this.uri = uri\n    this.logger = logger\n    this.runnerId = runnerId\n  }\n\n  private awaitProcessed(): Promise<void> {\n    return new Promise((res) => this.awaitingProcessed.push(res))\n  }\n\n  async any(any: Any): Promise<void> {\n    if ('stream' in any) {\n      await this.stream(any.stream)\n    }\n    if ('buffer' in any) {\n      await this.buffer(any.buffer)\n    }\n    if ('string' in any) {\n      await this.string(any.string)\n    }\n  }\n\n  async buffer(buffer: Uint8Array): Promise<void> {\n    this.logger.debug(`${this.uri} sends buffer ${buffer.length} bytes`)\n    const localSequenceNumber = this.localSequenceNumber++\n    const handledPromise = this.awaitProcessed()\n\n    await this.notifyOrchestrator({\n      msg: { data: buffer, channel: this.uri, localSequenceNumber },\n    })\n    await handledPromise\n  }\n\n  async stream<T = Uint8Array>(\n    buffer: AsyncIterable<T>,\n    transform?: (x: T) => Uint8Array,\n  ) {\n    this.openStreams += 1\n    const t = transform || ((x: unknown) => <Uint8Array>x)\n    const stream = this.client.sendStreamMessage()\n\n    const handledPromise = this.awaitProcessed()\n    const writeStreamMessageChunk = promisify(stream.write.bind(stream))\n    const localSequenceNumber = this.localSequenceNumber++\n    await writeStreamMessageChunk({\n      id: {\n        channel: this.uri,\n        localSequenceNumber,\n        runner: this.runnerId,\n      },\n    })\n\n    const id = await new Promise((res) => stream.once('data', res))\n\n    this.logger.debug(\n      `${this.uri} streams message with id ${JSON.stringify(id)}`,\n    )\n\n    for await (const msg of buffer) {\n      const processedPromise = new Promise((res) => stream.once('data', res))\n      await writeStreamMessageChunk({ data: { data: t(msg) } })\n      // Await a message on the stream, indicating that the chunk has been processed\n      await processedPromise\n    }\n\n    stream.end()\n\n    await handledPromise\n\n    this.openStreams -= 1\n\n    if (this.shouldClose.length > 0) await this.close()\n  }\n\n  async string(msg: string): Promise<void> {\n    this.logger.debug(`${this.uri} sends string ${msg.length} characters`)\n    const localSequenceNumber = this.localSequenceNumber++\n    const handledPromise = this.awaitProcessed()\n\n    await this.notifyOrchestrator({\n      msg: {\n        data: encoder.encode(msg),\n        channel: this.uri,\n        localSequenceNumber,\n      },\n    })\n\n    await handledPromise\n  }\n\n  /**\n   * Gracefully closes this channel.\n   *\n   * Behavior:\n   * - If there are still active streams, closing is deferred until they complete.\n   * - If multiple callers invoke `close()` while waiting, their Promises are queued and\n   *   resolved once the channel actually closes.\n   * - If this side initiated the close (`issued = false`), a close message is sent to the remote.\n   *\n   * @param issued - If true, indicates the close request originated remotely\n   */\n  async close(issued = false): Promise<void> {\n    // Case 1: Active streams still running → wait until they finish\n    if (this.openStreams !== 0) {\n      await new Promise<void>((resolve) => this.shouldClose.push(resolve))\n      return\n    }\n\n    // Case 2: No active streams → perform actual close\n    this.logger.debug(`${this.uri} closes stream`)\n    if (!issued) {\n      await this.notifyOrchestrator({\n        close: { channel: this.uri },\n      })\n    }\n\n    let resolve = this.shouldClose.pop()\n    while (resolve) {\n      resolve()\n      resolve = this.shouldClose.pop()\n    }\n  }\n\n  /**\n   * A message is handled, let's notify the fifo {@link awaitProcessed}\n   */\n  handled(): void {\n    if (this.awaitingProcessed.length > 0) {\n      this.awaitingProcessed.shift()!()\n    } else {\n      this.logger.error(\n        'Expected to be waiting for a message to be processed, but this is not the case ' +\n          this.uri,\n      )\n    }\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rdfc/js-runner",
-  "version": "2.0.0",
+  "version": "3.0.1",
   "main": "lib/index.js",
   "type": "module",
   "scripts": {
@@ -29,38 +29,38 @@
   "license": "ISC",
   "description": "",
   "devDependencies": {
-    "@eslint/js": "^9.21.0",
+    "@eslint/js": "^9.38.0",
     "@rdfjs/types": "^2.0.1",
-    "@types/jest": "^29.5.14",
+    "@types/jest": "^30.0.0",
     "@types/jsonld": "^1.5.15",
-    "@types/n3": "^1.21.1",
-    "@types/node": "^22.13.5",
-    "@typescript-eslint/eslint-plugin": "^8.25.0",
-    "@typescript-eslint/parser": "^8.25.0",
+    "@types/n3": "^1.26.1",
+    "@types/node": "^22.18.12",
+    "@typescript-eslint/eslint-plugin": "^8.46.2",
+    "@typescript-eslint/parser": "^8.46.2",
     "@vitest/coverage-v8": "^3.2.4",
     "eslint": "^9.21.0",
-    "eslint-config-prettier": "^10.0.1",
-    "eslint-plugin-prettier": "^5.2.3",
-    "globals": "^16.0.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^16.4.0",
     "husky": "^9.1.7",
-    "jest": "^29.7.0",
-    "lint-staged": "^15.4.3",
-    "prettier": "^3.5.2",
-    "ts-jest": "^29.2.6",
-    "tsc-alias": "^1.8.10",
-    "typescript": "^5.7.3",
-    "typescript-eslint": "^8.25.0",
+    "jest": "^30.2.0",
+    "lint-staged": "^15.5.2",
+    "prettier": "^3.6.2",
+    "ts-jest": "^29.4.5",
+    "tsc-alias": "^1.8.16",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.2",
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "@grpc/grpc-js": "^1.12.6",
-    "@rdfc/proto": "^0.1.2-alpha.1",
+    "@grpc/grpc-js": "^1.14.0",
+    "@rdfc/proto": "^0.1.2",
     "@treecg/types": "^0.4.6",
     "jsonld": "^8.3.3",
     "jsonld-streaming-parser": "^5.0.0",
-    "n3": "^1.23.1",
-    "rdf-lens": "^1.3.5",
-    "winston": "^3.17.0",
+    "n3": "^1.26.0",
+    "rdf-lens": "^1.3.6",
+    "winston": "^3.18.3",
     "winston-transport": "^4.9.0"
   }
 }

package/src/client.ts

@@ -1,14 +1,14 @@
 import * as grpc from '@grpc/grpc-js'
 import { promisify } from 'util'
-import { RunnerClient, RunnerMessage } from '@rdfc/proto'
-import winston from 'winston'
+import { RunnerClient, ToRunner } from '@rdfc/proto'
+import { createLogger } from 'winston'
 import { RpcTransport } from './logger'
 import { Runner } from './runner'
 
 export async function start(addr: string, uri: string) {
   const client = new RunnerClient(addr, grpc.credentials.createInsecure())
 
-  const logger = winston.createLogger({
+  const logger = createLogger({
     transports: [
       new RpcTransport({
         entities: [uri, 'cli'],
@@ -25,25 +25,22 @@ export async function start(addr: string, uri: string) {
 
   await writable({ identify: { uri } })
 
-  let processorsEnd!: (v: unknown) => unknown
-  const processorsEnded = new Promise((res) => (processorsEnd = res))
-  ;(async () => {
+  /* eslint-disable no-async-promise-executor */
+  await new Promise(async (res) => {
     for await (const chunk of stream) {
-      const msg: RunnerMessage = chunk
+      const msg: ToRunner = chunk
       if (msg.proc) {
         await runner.addProcessor(msg.proc)
       }
       if (msg.start) {
-        runner.start().then(processorsEnd)
+        runner.start().then(res)
       }
 
       await runner.handleOrchMessage(msg)
     }
 
     logger.error('Stream ended')
-  })()
-
-  await processorsEnded
+  })
 
   logger.info('All processors are finished')
   stream.end()

package/src/logger.ts

@@ -1,4 +1,4 @@
-import winston, { Logger } from 'winston'
+import { createLogger, LogEntry, Logger } from 'winston'
 import Transport from 'winston-transport'
 
 import * as grpc from '@grpc/grpc-js'
@@ -21,7 +21,7 @@ export class RpcTransport extends Transport {
     this.aliases = opts.aliases || []
   }
 
-  log(info: winston.LogEntry, callback: () => void) {
+  log(info: LogEntry, callback: () => void) {
     if (!this.stream.closed) {
       this.stream.write(
         {
@@ -55,7 +55,7 @@ export function extendLogger(baseLogger: Logger, newEntity: string): Logger {
     return t
   })
 
-  return winston.createLogger({
+  return createLogger({
     level: baseLogger.level,
     format: baseLogger.format,
     defaultMeta: baseLogger.defaultMeta,