@rdfc/js-runner 2.0.0 → 3.0.1

package/lib/runner.js

@@ -1,6 +1,6 @@
 import { ReaderInstance } from './reader.js';
 import { WriterInstance } from './writer.js';
-import winston from 'winston';
+import { createLogger } from 'winston';
 import { RpcTransport } from './logger.js';
 import { empty, extractShapes } from 'rdf-lens';
 import { NamedNode, Parser } from 'n3';
@@ -11,21 +11,21 @@ export class Runner {
     readers = {};
     writers = {};
     client;
-    write;
+    notifyOrchestrator;
     logger;
     shapes;
     quads = [];
     uri;
     processors = [];
     processorTransforms = [];
-    constructor(client, write, uri, logger) {
+    constructor(client, notifyOrchestrator, uri, logger) {
         this.client = client;
-        this.write = write;
+        this.notifyOrchestrator = notifyOrchestrator;
         this.uri = uri;
         this.logger = logger;
     }
     async addProcessor(proc) {
-        const procLogger = winston.createLogger({
+        const procLogger = createLogger({
             transports: [
                 new RpcTransport({
                     entities: [proc.uri, this.uri],
@@ -33,9 +33,9 @@ export class Runner {
                 }),
             ],
         });
-        const ty = JSON.stringify(this.quads
+        const ty = this.quads
             .filter((x) => x.subject.value === proc.uri && x.predicate.equals(RDF.terms.type))
-            .map((x) => x.object.value));
+            .map((x) => x.object.value);
         this.logger.info('parsing ' + proc.uri + ' type ' + ty);
         const args = this.shapes.lenses[RDFL.TypedExtract].execute({
             id: new NamedNode(proc.uri),
@@ -49,7 +49,7 @@ export class Runner {
         this.logger.info('inited ' + proc.uri + ' type ' + ty);
         this.processors.push(instance);
         this.processorTransforms.push(instance.transform());
-        await this.write({ init: { uri: proc.uri } });
+        await this.notifyOrchestrator({ initialized: { uri: proc.uri } });
         return instance;
     }
     async start() {
@@ -62,60 +62,100 @@ export class Runner {
         }
     }
     createWriter(uri) {
-        const ids = uri.value;
-        if (this.writers[ids] === undefined) {
-            this.writers[ids] = [];
+        const id = uri.value;
+        if (this.writers[id] !== undefined) {
+            return this.writers[id];
         }
-        const writer = new WriterInstance(ids, this.client, this.write, this.logger);
-        this.writers[ids].push(writer);
+        const writer = new WriterInstance(id, this.client, this.notifyOrchestrator, this.uri, this.logger);
+        this.writers[id] = writer;
         return writer;
     }
     createReader(uri) {
         const ids = uri.value;
-        if (this.readers[ids] === undefined) {
-            this.readers[ids] = [];
+        if (this.readers[ids] !== undefined) {
+            return this.readers[ids];
         }
-        const reader = new ReaderInstance(ids, this.client, this.logger);
-        this.readers[ids].push(reader);
+        const reader = new ReaderInstance(ids, this.client, this.notifyOrchestrator, this.logger);
+        this.readers[ids] = reader;
         return reader;
     }
     async handleOrchMessage(msg) {
         if (msg.msg) {
-            this.logger.debug('Handling data msg for ' + msg.msg.channel);
-            for (const reader of this.readers[msg.msg.channel] || []) {
-                reader.handleMsg(msg.msg);
-            }
+            this.handleMsg(msg.msg);
         }
         if (msg.streamMsg) {
-            for (const reader of this.readers[msg.streamMsg.channel] || []) {
-                reader.handleStreamingMessage(msg.streamMsg);
-            }
+            await this.handleStreamMsg(msg.streamMsg);
         }
         if (msg.close) {
-            const uri = msg.close.channel;
-            for (const reader of this.readers[uri] || []) {
-                reader.close();
-            }
-            for (const writer of this.writers[uri] || []) {
-                await writer.close(true);
-            }
+            await this.handleClose(msg.close);
         }
         if (msg.pipeline) {
-            try {
-                const quads = new Parser().parse(msg.pipeline);
-                this.shapes = extractShapes(quads, {
-                    [RDFC.Reader]: (x) => this.createReader(x.id),
-                    [RDFC.Writer]: (x) => this.createWriter(x.id),
-                }, {
-                    [RDFC.Reader]: empty(),
-                    [RDFC.Writer]: empty(),
-                });
-                this.quads = quads;
-            }
-            catch (ex) {
-                this.logger.error('Pipeline failed: ' + JSON.stringify(ex));
-            }
+            this.handlePipeline(msg.pipeline);
+        }
+        if (msg.processed) {
+            this.handleProcessed(msg.processed);
+        }
+    }
+    async handleClose(close) {
+        const uri = close.channel;
+        const r = this.readers[uri];
+        let closed = false;
+        if (r) {
+            r.close();
+            closed = true;
+        }
+        const w = this.writers[uri];
+        if (w) {
+            closed = true;
+            await w.close(true);
+        }
+        if (!closed) {
+            this.logger.error(`Received a close event for channel ${uri}, but neither reader nor writer is present.`);
+        }
+    }
+    handlePipeline(pipeline) {
+        try {
+            const quads = new Parser().parse(pipeline);
+            this.shapes = extractShapes(quads, {
+                [RDFC.Reader]: (x) => this.createReader(x.id),
+                [RDFC.Writer]: (x) => this.createWriter(x.id),
+            }, {
+                [RDFC.Reader]: empty(),
+                [RDFC.Writer]: empty(),
+            });
+            this.quads = quads;
+        }
+        catch (ex) {
+            this.logger.error('Pipeline failed: ' + JSON.stringify(ex));
+        }
+    }
+    handleMsg(msg) {
+        this.logger.debug('Handling data msg for ' + msg.channel);
+        const r = this.readers[msg.channel];
+        if (r) {
+            r.handleMsg(msg);
+        }
+        else {
+            this.logger.error(`Received message for channel ${msg.channel}, but no reader was present.`);
+        }
+    }
+    async handleStreamMsg(streamMsg) {
+        const r = this.readers[streamMsg.channel];
+        if (r) {
+            await r.handleStreamingMessage(streamMsg);
+        }
+        else {
+            this.logger.error(`Received stream message for channel ${streamMsg.channel}, but no reader was present.`);
+        }
+    }
+    handleProcessed(processed) {
+        const writer = this.writers[processed.channel];
+        if (writer) {
+            writer.handled();
+        }
+        else {
+            this.logger.error(`Received processed message for channel ${processed.channel}, but no writer was present.`);
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runner.js","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  OrchestratorMessage,\n  Processor,\n  RunnerClient,\n  RunnerMessage,\n} from '@rdfc/proto'\nimport { Reader, ReaderInstance } from './reader'\nimport { Writer, WriterInstance } from './writer'\nimport { Processor as Proc } from './processor'\nimport { Logger } from 'winston'\n\nimport winston from 'winston'\nimport { RpcTransport } from './logger'\nimport { Cont, empty, extractShapes, Shapes } from 'rdf-lens'\nimport { NamedNode, Parser } from 'n3'\nimport { createNamespace, createUriAndTermNamespace, RDF } from '@treecg/types'\nimport { Quad, Term } from '@rdfjs/types'\n\nconst RDFL = createUriAndTermNamespace(\n  'https://w3id.org/rdf-lens/ontology#',\n  'CBD',\n  'Path',\n  'PathLens',\n  'Context',\n  'TypedExtract',\n  'EnvVariable',\n  'envKey',\n  'envDefault',\n  'datatype',\n)\n\nconst RDFC = createNamespace(\n  'https://w3id.org/rdf-connect#',\n  (x) => x,\n  'Reader',\n  'Writer',\n)\n\nexport type Writable = (msg: OrchestratorMessage) => Promise<unknown>\n\ntype ProcessorConfig = {\n  location: string\n  file: string\n  clazz?: string\n}\n\nexport type FullProc<C extends Proc<unknown>> =\n  C extends Proc<infer T> ? T & C : unknown\nexport class Runner {\n  private readonly readers: { [uri: string]: ReaderInstance[] } = {}\n  private readonly writers: { [uri: string]: WriterInstance[] } = {}\n  private readonly client: RunnerClient\n  private readonly write: Writable\n  private readonly logger: Logger\n  private shapes: Shapes\n  private quads: Quad[] = []\n\n  private readonly uri: string\n\n  private readonly processors: Proc<unknown>[] = []\n  private readonly processorTransforms: Promise<unknown>[] = []\n\n  constructor(\n    client: RunnerClient,\n    write: Writable,\n    uri: string,\n    logger: Logger,\n  ) {\n    this.client = client\n    this.write = write\n    this.uri = uri\n    this.logger = logger\n  }\n\n  async addProcessor<P extends Proc<unknown>>(\n    proc: Processor,\n  ): Promise<FullProc<P>> {\n    const procLogger = winston.createLogger({\n      transports: [\n        new RpcTransport({\n          entities: [proc.uri, this.uri],\n          stream: this.client.logStream(() => {}),\n        }),\n      ],\n    })\n\n    const ty = JSON.stringify(\n      this.quads\n        .filter(\n          (x) =>\n            x.subject.value === proc.uri && x.predicate.equals(RDF.terms.type),\n        )\n        .map((x) => x.object.value),\n    )\n    this.logger.info('parsing ' + proc.uri + ' type ' + ty)\n    const args = this.shapes.lenses[RDFL.TypedExtract].execute({\n      id: new NamedNode(proc.uri),\n      quads: this.quads,\n    })\n\n    const config: ProcessorConfig = JSON.parse(proc.config)\n    // const url = new URL(config.location)\n    // process.chdir(url.pathname)\n    const jsProgram = await import(config.file)\n    const clazz = jsProgram[config.clazz || 'default']\n    const instance: Proc<unknown> = new clazz(args, procLogger)\n    await instance.init()\n\n    this.logger.info('inited ' + proc.uri + ' type ' + ty)\n\n    this.processors.push(instance)\n    this.processorTransforms.push(instance.transform())\n\n    await this.write({ init: { uri: proc.uri } })\n\n    return <FullProc<P>>instance\n  }\n\n  async start() {\n    try {\n      await Promise.all(this.processors.map((x) => x.produce()))\n      await Promise.all(this.processorTransforms)\n    } catch (ex: unknown) {\n      this.logger.error('Start failed: ' + JSON.stringify(ex))\n    }\n  }\n\n  createWriter(uri: Term): Writer {\n    const ids = uri.value\n\n    if (this.writers[ids] === undefined) {\n      this.writers[ids] = []\n    }\n    const writer = new WriterInstance(ids, this.client, this.write, this.logger)\n    this.writers[ids].push(writer)\n    return writer\n  }\n\n  createReader(uri: Term): Reader {\n    const ids = uri.value\n\n    if (this.readers[ids] === undefined) {\n      this.readers[ids] = []\n    }\n    const reader = new ReaderInstance(ids, this.client, this.logger)\n    this.readers[ids].push(reader)\n    return reader\n  }\n\n  async handleOrchMessage(msg: RunnerMessage) {\n    if (msg.msg) {\n      this.logger.debug('Handling data msg for ' + msg.msg.channel)\n      for (const reader of this.readers[msg.msg.channel] || []) {\n        reader.handleMsg(msg.msg)\n      }\n    }\n\n    if (msg.streamMsg) {\n      for (const reader of this.readers[msg.streamMsg.channel] || []) {\n        reader.handleStreamingMessage(msg.streamMsg)\n      }\n    }\n\n    if (msg.close) {\n      const uri = msg.close.channel\n\n      for (const reader of this.readers[uri] || []) {\n        reader.close()\n      }\n\n      for (const writer of this.writers[uri] || []) {\n        await writer.close(true)\n      }\n    }\n\n    if (msg.pipeline) {\n      try {\n        // here\n        const quads = new Parser().parse(msg.pipeline)\n        this.shapes = extractShapes(\n          quads,\n          {\n            [RDFC.Reader]: (x: Cont) => this.createReader(x.id),\n            [RDFC.Writer]: (x: Cont) => this.createWriter(x.id),\n          },\n          {\n            [RDFC.Reader]: empty<Cont>(),\n            [RDFC.Writer]: empty<Cont>(),\n          },\n        )\n        this.quads = quads\n      } catch (ex: unknown) {\n        this.logger.error('Pipeline failed: ' + JSON.stringify(ex))\n      }\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runner.js","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Close,\n  FromRunner,\n  Processor,\n  RunnerClient,\n  ToRunner,\n  LocalAck,\n  ReceivingMessage,\n  ReceivingStreamMessage,\n} from '@rdfc/proto'\nimport { Reader, ReaderInstance } from './reader'\nimport { Writer, WriterInstance } from './writer'\nimport { Processor as Proc } from './processor'\nimport { createLogger, Logger } from 'winston'\n\nimport { RpcTransport } from './logger'\nimport { Cont, empty, extractShapes, Shapes } from 'rdf-lens'\nimport { NamedNode, Parser } from 'n3'\nimport { createNamespace, createUriAndTermNamespace, RDF } from '@treecg/types'\nimport { Quad, Term } from '@rdfjs/types'\n\nconst RDFL = createUriAndTermNamespace(\n  'https://w3id.org/rdf-lens/ontology#',\n  'CBD',\n  'Path',\n  'PathLens',\n  'Context',\n  'TypedExtract',\n  'EnvVariable',\n  'envKey',\n  'envDefault',\n  'datatype',\n)\n\nconst RDFC = createNamespace(\n  'https://w3id.org/rdf-connect#',\n  (x) => x,\n  'Reader',\n  'Writer',\n)\n\nexport type Writable = (msg: FromRunner) => Promise<unknown>\n\ntype ProcessorConfig = {\n  location: string\n  file: string\n  clazz?: string\n}\n\nexport type FullProc<C> = C extends Proc<infer T> ? T & C : never\nexport class Runner {\n  private readonly readers: { [uri: string]: ReaderInstance } = {}\n  private readonly writers: { [uri: string]: WriterInstance } = {}\n  private readonly client: RunnerClient\n  private readonly notifyOrchestrator: Writable\n  private readonly logger: Logger\n  private shapes: Shapes\n  private quads: Quad[] = []\n\n  private readonly uri: string\n\n  private readonly processors: Proc<unknown>[] = []\n  private readonly processorTransforms: Promise<unknown>[] = []\n\n  constructor(\n    client: RunnerClient,\n    notifyOrchestrator: Writable,\n    uri: string,\n    logger: Logger,\n  ) {\n    this.client = client\n    this.notifyOrchestrator = notifyOrchestrator\n    this.uri = uri\n    this.logger = logger\n  }\n\n  async addProcessor<P extends Proc<unknown>>(\n    proc: Processor,\n  ): Promise<FullProc<P>> {\n    const procLogger = createLogger({\n      transports: [\n        new RpcTransport({\n          entities: [proc.uri, this.uri],\n          stream: this.client.logStream(() => {}),\n        }),\n      ],\n    })\n\n    const ty = this.quads\n      .filter(\n        (x) =>\n          x.subject.value === proc.uri && x.predicate.equals(RDF.terms.type),\n      )\n      .map((x) => x.object.value)\n\n    this.logger.info('parsing ' + proc.uri + ' type ' + ty)\n    const args = this.shapes.lenses[RDFL.TypedExtract].execute({\n      id: new NamedNode(proc.uri),\n      quads: this.quads,\n    })\n\n    const config: ProcessorConfig = JSON.parse(proc.config)\n    const jsProgram = await import(config.file)\n    const clazz = jsProgram[config.clazz || 'default']\n    const instance: Proc<unknown> = new clazz(args, procLogger)\n    await instance.init()\n\n    this.logger.info('inited ' + proc.uri + ' type ' + ty)\n\n    this.processors.push(instance)\n    this.processorTransforms.push(instance.transform())\n\n    await this.notifyOrchestrator({ initialized: { uri: proc.uri } })\n\n    return <FullProc<P>>instance\n  }\n\n  async start() {\n    try {\n      await Promise.all(this.processors.map((x) => x.produce()))\n      await Promise.all(this.processorTransforms)\n    } catch (ex: unknown) {\n      this.logger.error('Start failed: ' + JSON.stringify(ex))\n    }\n  }\n\n  createWriter(uri: Term): Writer {\n    const id = uri.value\n\n    if (this.writers[id] !== undefined) {\n      return this.writers[id]\n    }\n    const writer = new WriterInstance(\n      id,\n      this.client,\n      this.notifyOrchestrator,\n      this.uri,\n      this.logger,\n    )\n    this.writers[id] = writer\n    return writer\n  }\n\n  createReader(uri: Term): Reader {\n    const ids = uri.value\n\n    if (this.readers[ids] !== undefined) {\n      return this.readers[ids]\n    }\n    const reader = new ReaderInstance(\n      ids,\n      this.client,\n      this.notifyOrchestrator,\n      this.logger,\n    )\n    this.readers[ids] = reader\n    return reader\n  }\n\n  async handleOrchMessage(msg: ToRunner) {\n    if (msg.msg) {\n      this.handleMsg(msg.msg)\n    }\n\n    if (msg.streamMsg) {\n      await this.handleStreamMsg(msg.streamMsg)\n    }\n\n    if (msg.close) {\n      await this.handleClose(msg.close)\n    }\n\n    if (msg.pipeline) {\n      this.handlePipeline(msg.pipeline)\n    }\n\n    if (msg.processed) {\n      this.handleProcessed(msg.processed)\n    }\n  }\n\n  private async handleClose(close: Close) {\n    const uri = close.channel\n    const r = this.readers[uri]\n\n    let closed = false\n    if (r) {\n      r.close()\n      closed = true\n    }\n    const w = this.writers[uri]\n    if (w) {\n      closed = true\n      await w.close(true)\n    }\n\n    if (!closed) {\n      this.logger.error(\n        `Received a close event for channel ${uri}, but neither reader nor writer is present.`,\n      )\n    }\n  }\n\n  private handlePipeline(pipeline: string) {\n    try {\n      const quads = new Parser().parse(pipeline)\n      this.shapes = extractShapes(\n        quads,\n        {\n          [RDFC.Reader]: (x: Cont) => this.createReader(x.id),\n          [RDFC.Writer]: (x: Cont) => this.createWriter(x.id),\n        },\n        {\n          [RDFC.Reader]: empty<Cont>(),\n          [RDFC.Writer]: empty<Cont>(),\n        },\n      )\n      this.quads = quads\n    } catch (ex: unknown) {\n      this.logger.error('Pipeline failed: ' + JSON.stringify(ex))\n    }\n  }\n\n  private handleMsg(msg: ReceivingMessage) {\n    this.logger.debug('Handling data msg for ' + msg.channel)\n    const r = this.readers[msg.channel]\n\n    if (r) {\n      r.handleMsg(msg)\n    } else {\n      this.logger.error(\n        `Received message for channel ${msg.channel}, but no reader was present.`,\n      )\n    }\n  }\n\n  private async handleStreamMsg(streamMsg: ReceivingStreamMessage) {\n    const r = this.readers[streamMsg.channel]\n\n    if (r) {\n      await r.handleStreamingMessage(streamMsg)\n    } else {\n      this.logger.error(\n        `Received stream message for channel ${streamMsg.channel}, but no reader was present.`,\n      )\n    }\n  }\n\n  private handleProcessed(processed: LocalAck) {\n    const writer = this.writers[processed.channel]\n    if (writer) {\n      writer.handled()\n    } else {\n      this.logger.error(\n        `Received processed message for channel ${processed.channel}, but no writer was present.`,\n      )\n    }\n  }\n}\n"]}

package/lib/testUtils/duplex.d.ts

@@ -0,0 +1,25 @@
+import { Duplex } from 'stream';
+import type { ClientDuplexStream, InterceptingCallInterface } from '@grpc/grpc-js';
+import { AuthContext } from '@grpc/grpc-js/build/src/auth-context';
+type Matcher<Req, T> = (req: Req) => T | undefined;
+type Handler<Req, Res> = (req: Req, send: (res: Res) => void) => void;
+export declare class MockClientDuplexStream<Req, Res> extends Duplex implements ClientDuplexStream<Req, Res> {
+    private capabilities;
+    private onceCapabilities;
+    readonly id: number;
+    call?: InterceptingCallInterface | undefined;
+    constructor();
+    getAuthContext(): AuthContext | null;
+    cancel(): void;
+    getPeer(): string;
+    _write(chunk: Req, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    _read(): void;
+    serialize(value: Req): Buffer;
+    deserialize(chunk: Buffer): Res;
+    send(response: Res): void;
+    end(): this;
+    register<T>(matcher: Matcher<Req, T>, handler: Handler<T, Res>): void;
+    registerOnce<T>(matcher: Matcher<Req, T>, handler: Handler<T, Res>): void;
+    awaitMsg<T>(matcher: Matcher<Req, T>): Promise<T>;
+}
+export {};

package/lib/testUtils/duplex.js

@@ -0,0 +1,70 @@
+import { Duplex } from 'stream';
+let count = 0;
+export class MockClientDuplexStream extends Duplex {
+    capabilities = [];
+    onceCapabilities = [];
+    id;
+    call;
+    constructor() {
+        super({ objectMode: true });
+        this.id = count++;
+    }
+    getAuthContext() {
+        return null;
+    }
+    cancel() { }
+    getPeer() {
+        return 'mock-peer';
+    }
+    _write(chunk, _encoding, callback) {
+        let handled = false;
+        for (const { matcher, handler } of this.capabilities) {
+            const o = matcher(chunk);
+            if (o !== undefined) {
+                handled = true;
+                handler(o, (res) => this.send(res));
+            }
+        }
+        const newOnce = [];
+        for (const { matcher, handler } of this.onceCapabilities) {
+            const o = matcher(chunk);
+            if (o !== undefined) {
+                handled = true;
+                handler(o, (res) => this.send(res));
+            }
+            else {
+                newOnce.push({ matcher, handler });
+            }
+        }
+        this.onceCapabilities = newOnce;
+        if (!handled) {
+            console.error('Unhandled!', Object.keys(chunk));
+        }
+        callback();
+    }
+    _read() {
+    }
+    serialize(value) {
+        return Buffer.from(JSON.stringify(value));
+    }
+    deserialize(chunk) {
+        return JSON.parse(chunk.toString());
+    }
+    send(response) {
+        this.push(response);
+    }
+    end() {
+        this.push(null);
+        return this;
+    }
+    register(matcher, handler) {
+        this.capabilities.push({ matcher, handler });
+    }
+    registerOnce(matcher, handler) {
+        this.onceCapabilities.push({ matcher, handler });
+    }
+    awaitMsg(matcher) {
+        return new Promise((res) => this.registerOnce(matcher, res));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/testUtils/index.d.ts

@@ -0,0 +1,51 @@
+import { DataChunk, FromRunner, LogMessage, ToRunner } from '@rdfc/proto';
+import { NamedNode } from 'n3';
+import { Processor } from '../processor.js';
+import { FullProc, Runner } from '../runner.js';
+import { Quad } from '@rdfjs/types';
+import { ReceivingStreamControl, SendingStreamControl, StreamChunk, StreamIdentify } from '@rdfc/proto/lib/generated/common';
+import { MockClientDuplexStream } from './duplex.js';
+import { Reader } from '../reader.js';
+import { Writer } from '../writer.js';
+export declare function channel(runner: Runner, name: string): [Writer, Reader];
+export declare class StreamMsgMock {
+    data: DataChunk[];
+    private readonly resolveId;
+    constructor(resolveId: (id: StreamIdentify) => number);
+    sendStreamMessage(): MockClientDuplexStream<StreamChunk, ReceivingStreamControl>;
+}
+export declare class OrchestratorMock {
+    connectStream: MockClientDuplexStream<FromRunner, ToRunner>;
+    streamMsgs: {
+        [id: string]: {
+            toProducingStream: (id: ReceivingStreamControl) => void;
+            receivingStream?: MockClientDuplexStream<SendingStreamControl, DataChunk>;
+        };
+    };
+    streamMsgCount: number;
+    connect(): MockClientDuplexStream<FromRunner, ToRunner>;
+    sendStreamMessage(): MockClientDuplexStream<StreamChunk, ReceivingStreamControl>;
+    receiveStreamMessage(): MockClientDuplexStream<SendingStreamControl, DataChunk>;
+    logStream(): MockClientDuplexStream<LogMessage, null>;
+}
+export declare function createRunner(uri?: string): Runner;
+export declare function one<T>(iter: AsyncIterable<T>): Promise<T | undefined>;
+export type ConfigType = {
+    location: string;
+    file: string;
+    clazz: string;
+};
+export declare function importFile(file: string, content?: string): Promise<Quad[]>;
+export declare class ProcHelper<T extends Processor<unknown>> {
+    runner: Runner;
+    quads: Quad[];
+    config: ConfigType;
+    proc: FullProc<T>;
+    constructor(uri?: string);
+    importInline(baseIRI: string, config: string): Promise<void>;
+    importFile(file: string): Promise<void>;
+    getConfig(ty: string | NamedNode): ConfigType;
+    getProcessor(uri?: string): Promise<FullProc<T>>;
+}
+export declare function getProcInline<T extends Processor<unknown>>(config: string, ty: string, runner: Runner, baseIRI: string, uri?: string): Promise<FullProc<T>>;
+export declare function getProc<T extends Processor<unknown>>(config: string, ty: string, runner: Runner, configLocation: string, uri?: string): Promise<FullProc<T>>;