@rdfc/js-runner 1.0.0 → 2.0.0-alpha.10

package/lib/jsonld.js

@@ -0,0 +1,135 @@
+import { createNamespace, createUriAndTermNamespace } from '@treecg/types';
+import { ReaderInstance } from './reader.js';
+import { WriterInstance } from './writer.js';
+import { JsonLdParser } from 'jsonld-streaming-parser';
+import { pred, ShaclPath } from 'rdf-lens';
+import { NamedNode } from 'n3';
+const RDFL = createUriAndTermNamespace('https://w3id.org/rdf-lens/ontology#', 'CBD', 'Path', 'PathLens', 'Context', 'TypedExtract', 'EnvVariable', 'envKey', 'envDefault', 'datatype');
+const RDFC = createNamespace('https://w3id.org/rdf-connect#', (x) => x, 'Reader', 'Writer');
+function as_string_array(obj) {
+    const out = Array.isArray(obj) ? obj : [obj];
+    return out.filter((x) => typeof x === 'string');
+}
+function cbdToQuads(value) {
+    const quads = [];
+    const parser = new JsonLdParser();
+    const promise = new Promise((res, rej) => parser
+        .on('end', () => res({ value: quads }))
+        .on('error', (e) => rej(e))
+        .on('data', (q) => {
+        quads.push(q);
+    }));
+    if (value instanceof Object && '@type' in value) {
+        delete value['@type'];
+    }
+    parser.write(JSON.stringify(value));
+    parser.end();
+    return promise;
+}
+async function cbdToPath(value) {
+    const qs = (await cbdToQuads({
+        '@id': 'http://example.com/ns#me1234',
+        'http://example.com/ns#innerPred': value,
+    })).value;
+    const path = pred(new NamedNode('http://example.com/ns#innerPred'))
+        .one()
+        .then(ShaclPath)
+        .execute({
+        quads: qs,
+        id: new NamedNode('http://example.com/ns#me1234'),
+    });
+    return { value: path };
+}
+async function jsonldToQuads(value) {
+    const qs = (await cbdToQuads({
+        '@id': 'http://example.com/ns#me1234',
+        'http://example.com/ns#innerPred': value,
+    })).value;
+    const idx = qs.findIndex((x) => x.predicate.equals(new NamedNode('http://example.com/ns#innerPred')) &&
+        x.subject.equals(new NamedNode('http://example.com/ns#me1234')));
+    if (idx < 0)
+        throw 'This cannot happen';
+    const id = qs[idx].object;
+    qs.splice(idx, 1);
+    return {
+        quads: qs,
+        id,
+    };
+}
+function revive(_key, value, logger, promises, runnerItems) {
+    if (typeof value === 'object') {
+        const types = as_string_array(value['@type'] || []);
+        const ids = as_string_array(value['@id'] || [])[0] || '';
+        if (types.includes(RDFC.Reader)) {
+            if (runnerItems.readers[ids] === undefined) {
+                runnerItems.readers[ids] = [];
+            }
+            const reader = new ReaderInstance(ids, runnerItems.client, logger);
+            runnerItems.readers[ids].push(reader);
+            return reader;
+        }
+        if (types.includes(RDFC.Writer)) {
+            if (runnerItems.writers[ids] === undefined) {
+                runnerItems.writers[ids] = [];
+            }
+            const writer = new WriterInstance(ids, runnerItems.client, runnerItems.write, logger);
+            runnerItems.writers[ids].push(writer);
+            return writer;
+        }
+        if (types.includes(RDFL.CBD)) {
+            return cbdToQuads(value);
+        }
+        if (types.includes(RDFL.Path)) {
+            return cbdToPath(value);
+        }
+    }
+    Object.entries(value).forEach(([k, v]) => {
+        if (v instanceof Promise) {
+            logger.info('Found promise');
+            promises.push(v.then((x) => {
+                logger.info('Setting field ' + k);
+                value[k] = x.value;
+            }));
+        }
+    });
+    return value;
+}
+function expandArgs(args, cont, logger) {
+    const context = args['@context'];
+    if (!context)
+        return;
+    for (const key of Object.keys(args)) {
+        if (key == '@context')
+            continue;
+        const ctxObj = context[key];
+        if (!ctxObj) {
+            logger.debug("Didn't find ctx things for " + key);
+            continue;
+        }
+        logger.debug('Did find ctx things for ' +
+            key +
+            ' ' +
+            JSON.stringify(ctxObj) +
+            ': ' +
+            JSON.stringify(Object.entries(args[key]).map(([k, v]) => {
+                let x = 'object';
+                try {
+                    x = JSON.stringify(v);
+                }
+                catch (_e) {
+                }
+                return k + ': ' + x;
+            })));
+        expandArgs(args[key], cont, logger);
+    }
+}
+export async function parse_jsonld(args, logger, items) {
+    const promises = [];
+    logger.info(args);
+    const cont = await jsonldToQuads(JSON.parse(args));
+    const out = JSON.parse(args, (k, v) => revive(k, v, logger, promises, items));
+    await Promise.all(promises);
+    expandArgs(out, cont, logger);
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jsonld.js","sourceRoot":"","sources":["../src/jsonld.ts"],"names":[],"mappings":"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","sourcesContent":["import { OrchestratorMessage, RunnerClient } from '@rdfc/proto'\nimport { createNamespace, createUriAndTermNamespace } from '@treecg/types'\nimport { ReaderInstance } from './reader'\nimport { WriterInstance } from './writer'\nimport { Logger } from 'winston'\nimport { JsonLdParser } from 'jsonld-streaming-parser'\nimport { pred, ShaclPath } from 'rdf-lens'\nimport { Quad, Term } from '@rdfjs/types'\nimport { NamedNode } from 'n3'\n\nexport type RunnerItems = {\n  readers: { [uri: string]: ReaderInstance[] }\n  writers: { [uri: string]: WriterInstance[] }\n  client: RunnerClient\n  write: Writable\n}\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\ntype Writable = (msg: OrchestratorMessage) => Promise<unknown>\nconst RDFC = createNamespace(\n  'https://w3id.org/rdf-connect#',\n  (x) => x,\n  'Reader',\n  'Writer',\n)\n\nfunction as_string_array(obj: unknown): string[] {\n  const out = Array.isArray(obj) ? obj : [obj]\n  return out.filter((x) => typeof x === 'string')\n}\n\nfunction cbdToQuads(value: unknown) {\n  const quads: Quad[] = []\n  const parser = new JsonLdParser()\n  const promise = new Promise<{ value: Quad[] }>((res, rej) =>\n    parser\n      .on('end', () => res({ value: quads }))\n      .on('error', (e) => rej(e))\n      .on('data', (q) => {\n        quads.push(q)\n      }),\n  )\n\n  if (value instanceof Object && '@type' in value) {\n    delete value['@type']\n  }\n  parser.write(JSON.stringify(value))\n  parser.end()\n  return promise\n}\n\nasync function cbdToPath(value: unknown): Promise<{ value: unknown }> {\n  const qs = (\n    await cbdToQuads({\n      '@id': 'http://example.com/ns#me1234',\n      'http://example.com/ns#innerPred': value,\n    })\n  ).value\n\n  const path = pred(new NamedNode('http://example.com/ns#innerPred'))\n    .one()\n    .then(ShaclPath)\n    .execute({\n      quads: qs,\n      id: new NamedNode('http://example.com/ns#me1234'),\n    })\n  return { value: path }\n}\n\ntype Cont = { quads: Quad[]; id: Term }\nasync function jsonldToQuads(value: unknown): Promise<Cont> {\n  const qs = (\n    await cbdToQuads({\n      '@id': 'http://example.com/ns#me1234',\n      'http://example.com/ns#innerPred': value,\n    })\n  ).value\n\n  const idx = qs.findIndex(\n    (x) =>\n      x.predicate.equals(new NamedNode('http://example.com/ns#innerPred')) &&\n      x.subject.equals(new NamedNode('http://example.com/ns#me1234')),\n  )\n  if (idx < 0) throw 'This cannot happen'\n  const id = qs[idx].object\n\n  qs.splice(idx, 1)\n\n  return {\n    quads: qs,\n    id,\n  }\n}\n\n/* eslint-disable  @typescript-eslint/no-explicit-any */\nfunction revive(\n  _key: string,\n  value: any,\n  logger: Logger,\n  promises: Promise<unknown>[],\n  runnerItems: RunnerItems,\n): any {\n  if (typeof value === 'object') {\n    const types = as_string_array(value['@type'] || [])\n    const ids = as_string_array(value['@id'] || [])[0] || ''\n\n    if (types.includes(RDFC.Reader)) {\n      if (runnerItems.readers[ids] === undefined) {\n        runnerItems.readers[ids] = []\n      }\n      const reader = new ReaderInstance(ids, runnerItems.client, logger)\n      runnerItems.readers[ids].push(reader)\n      return reader\n    }\n\n    if (types.includes(RDFC.Writer)) {\n      if (runnerItems.writers[ids] === undefined) {\n        runnerItems.writers[ids] = []\n      }\n      const writer = new WriterInstance(\n        ids,\n        runnerItems.client,\n        runnerItems.write,\n        logger,\n      )\n      runnerItems.writers[ids].push(writer)\n      return writer\n    }\n\n    if (types.includes(RDFL.CBD)) {\n      return cbdToQuads(value)\n    }\n\n    if (types.includes(RDFL.Path)) {\n      return cbdToPath(value)\n    }\n  }\n\n  Object.entries(value).forEach(([k, v]) => {\n    if (v instanceof Promise) {\n      logger.info('Found promise')\n      promises.push(\n        v.then((x) => {\n          logger.info('Setting field ' + k)\n          value[k] = x.value\n        }),\n      )\n    }\n  })\n\n  return value\n}\n\ntype Arg = {\n  [id: string]: any\n}\nfunction expandArgs(args: Arg, cont: Cont, logger: Logger) {\n  const context = args['@context']\n  if (!context) return\n\n  for (const key of Object.keys(args)) {\n    if (key == '@context') continue\n    const ctxObj = context[key]\n    if (!ctxObj) {\n      logger.debug(\"Didn't find ctx things for \" + key)\n      continue\n    }\n\n    logger.debug(\n      'Did find ctx things for ' +\n        key +\n        ' ' +\n        JSON.stringify(ctxObj) +\n        ': ' +\n        JSON.stringify(\n          Object.entries(args[key]).map(([k, v]) => {\n            let x = 'object'\n            try {\n              x = JSON.stringify(v)\n              // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            } catch (_e: unknown) {\n              // default is set\n            }\n\n            return k + ': ' + x\n          }),\n        ),\n    )\n\n    expandArgs(args[key], cont, logger)\n  }\n}\n\nexport async function parse_jsonld(\n  args: string,\n  logger: Logger,\n  items: RunnerItems,\n): Promise<unknown> {\n  const promises: Promise<unknown>[] = []\n  logger.info(args)\n  const cont = await jsonldToQuads(JSON.parse(args))\n  const out = JSON.parse(args, (k, v) => revive(k, v, logger, promises, items))\n\n  await Promise.all(promises)\n\n  expandArgs(out, cont, logger)\n  return out\n}\n"]}

package/lib/logger.d.ts

@@ -0,0 +1,17 @@
+import winston, { Logger } from 'winston';
+import Transport from 'winston-transport';
+import * as grpc from '@grpc/grpc-js';
+import { LogMessage } from '@rdfc/proto';
+export declare class RpcTransport extends Transport {
+    private readonly stream;
+    private readonly entities;
+    private readonly aliases;
+    constructor(opts: {
+        stream: grpc.ClientWritableStream<LogMessage>;
+        entities: string[];
+        aliases?: string[];
+    });
+    log(info: winston.LogEntry, callback: () => void): void;
+    withEntity(entity: string): RpcTransport;
+}
+export declare function extendLogger(baseLogger: Logger, newEntity: string): Logger;

package/lib/logger.js

@@ -0,0 +1,49 @@
+import winston from 'winston';
+import Transport from 'winston-transport';
+export class RpcTransport extends Transport {
+    stream;
+    entities;
+    aliases;
+    constructor(opts) {
+        super({ level: 'debug' });
+        this.stream = opts.stream;
+        this.entities = opts.entities;
+        this.aliases = opts.aliases || [];
+    }
+    log(info, callback) {
+        if (!this.stream.closed) {
+            this.stream.write({
+                msg: info.message,
+                level: info.level,
+                entities: this.entities,
+                aliases: this.aliases,
+            }, callback);
+        }
+        else {
+            console.log('Output stream closed');
+            callback();
+        }
+    }
+    withEntity(entity) {
+        return new RpcTransport({
+            stream: this.stream,
+            entities: [...this.entities, entity],
+            aliases: this.aliases,
+        });
+    }
+}
+export function extendLogger(baseLogger, newEntity) {
+    const newTransports = baseLogger.transports.map((t) => {
+        if (t instanceof RpcTransport) {
+            return t.withEntity(newEntity);
+        }
+        return t;
+    });
+    return winston.createLogger({
+        level: baseLogger.level,
+        format: baseLogger.format,
+        defaultMeta: baseLogger.defaultMeta,
+        transports: newTransports,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/processor.d.ts

@@ -0,0 +1,19 @@
+import { Logger } from 'winston';
+import { Reader } from './reader.js';
+import { Writer } from './writer.js';
+export type Primitive = string | number | Writer | Reader | ProcessorArgs;
+export type ProcessorArgs = {
+    [id: string]: Primitive | Primitive[];
+};
+export type BGetter<T> = {
+    [K in keyof T]: T[K];
+};
+export declare abstract class Processor<T> {
+    protected readonly args: T;
+    protected readonly logger: Logger;
+    constructor(args: T, logger: Logger);
+    protected get<K extends keyof T>(key: K): T[K];
+    abstract init(this: T & this): Promise<void>;
+    abstract transform(this: T & this): Promise<void>;
+    abstract produce(this: T & this): Promise<void>;
+}

package/lib/processor.js

@@ -0,0 +1,13 @@
+export class Processor {
+    args;
+    logger;
+    constructor(args, logger) {
+        Object.assign(this, args);
+        this.args = args;
+        this.logger = logger;
+    }
+    get(key) {
+        return this.args[key];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/reader.d.ts

@@ -0,0 +1,30 @@
+import { Message, RunnerClient, StreamMessage } from '@rdfc/proto';
+import winston from 'winston';
+export type Any = {
+    string: string;
+} | {
+    stream: AsyncGenerator<Uint8Array>;
+} | {
+    buffer: Uint8Array;
+};
+export interface Reader {
+    readonly uri: string;
+    strings(): AsyncIterable<string>;
+    streams(): AsyncIterable<AsyncGenerator<Uint8Array>>;
+    buffers(): AsyncIterable<Uint8Array>;
+    anys(): AsyncIterable<Any>;
+}
+export declare class ReaderInstance implements Reader {
+    private client;
+    readonly uri: string;
+    private logger;
+    private iterators;
+    constructor(uri: string, client: RunnerClient, logger: winston.Logger);
+    anys(): AsyncIterable<Any>;
+    strings(): AsyncIterable<string>;
+    buffers(): AsyncIterable<Uint8Array>;
+    streams(): AsyncIterable<AsyncGenerator<Uint8Array>>;
+    handleMsg(msg: Message): void;
+    close(): void;
+    handleStreamingMessage(msg: StreamMessage): void;
+}

package/lib/reader.js

@@ -0,0 +1,101 @@
+import { AnyConvertor, NoConvertor, StreamConvertor, StringConvertor, } from './convertor.js';
+class MyIter {
+    convertor;
+    queue = [];
+    resolveNext = null;
+    constructor(convertor) {
+        this.convertor = convertor;
+    }
+    push(buffer) {
+        const item = this.convertor.from(buffer);
+        this.queue.push(item);
+        if (this.resolveNext) {
+            this.resolveNext(undefined);
+            this.resolveNext = null;
+        }
+    }
+    close() {
+        this.queue.push(undefined);
+        if (this.resolveNext) {
+            this.resolveNext(undefined);
+            this.resolveNext = null;
+        }
+    }
+    async pushStream(chunks) {
+        const stream = (async function* (stream) {
+            for await (const c of stream) {
+                const chunk = c;
+                yield chunk.data;
+            }
+        })(chunks);
+        const item = await this.convertor.fromStream(stream);
+        this.queue.push(item);
+        if (this.resolveNext) {
+            this.resolveNext(undefined);
+            this.resolveNext = null;
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.queue.length > 0) {
+                const item = this.queue.shift();
+                if (item === undefined)
+                    break;
+                yield item;
+            }
+            else {
+                await new Promise((resolve) => (this.resolveNext = resolve));
+            }
+        }
+    }
+}
+export class ReaderInstance {
+    client;
+    uri;
+    logger;
+    iterators = [];
+    constructor(uri, client, logger) {
+        this.uri = uri;
+        this.client = client;
+        this.logger = logger;
+    }
+    anys() {
+        const iter = new MyIter(AnyConvertor);
+        this.iterators.push(iter);
+        return iter;
+    }
+    strings() {
+        const iter = new MyIter(StringConvertor);
+        this.iterators.push(iter);
+        return iter;
+    }
+    buffers() {
+        const iter = new MyIter(NoConvertor);
+        this.iterators.push(iter);
+        return iter;
+    }
+    streams() {
+        const iter = new MyIter(StreamConvertor);
+        this.iterators.push(iter);
+        return iter;
+    }
+    handleMsg(msg) {
+        this.logger.debug(`${this.uri} handling message`);
+        for (const iter of this.iterators) {
+            iter.push(msg.data);
+        }
+    }
+    close() {
+        for (const iter of this.iterators) {
+            iter.close();
+        }
+    }
+    handleStreamingMessage(msg) {
+        this.logger.debug(`${this.uri} handling streaming message`);
+        const chunks = this.client.receiveStreamMessage(msg.id);
+        for (const iter of this.iterators) {
+            iter.pushStream(chunks);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reader.js","sourceRoot":"","sources":["../src/reader.ts"],"names":[],"mappings":"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","sourcesContent":["import { ClientReadableStream } from '@grpc/grpc-js'\nimport { DataChunk, Message, RunnerClient, StreamMessage } from '@rdfc/proto'\nimport winston from 'winston'\nimport {\n  AnyConvertor,\n  Convertor,\n  NoConvertor,\n  StreamConvertor,\n  StringConvertor,\n} from './convertor'\n\nexport type Any =\n  | {\n      string: string\n    }\n  | {\n      stream: AsyncGenerator<Uint8Array>\n    }\n  | {\n      buffer: Uint8Array\n    }\n\nexport interface Reader {\n  readonly uri: string\n  strings(): AsyncIterable<string>\n  streams(): AsyncIterable<AsyncGenerator<Uint8Array>>\n  buffers(): AsyncIterable<Uint8Array>\n  anys(): AsyncIterable<Any>\n}\n\nclass MyIter<T> implements AsyncIterable<T> {\n  private convertor: Convertor<T>\n  private queue: (T | undefined)[] = []\n  private resolveNext: ((value: undefined) => void) | null = null\n\n  constructor(convertor: Convertor<T>) {\n    this.convertor = convertor\n  }\n\n  push(buffer: Uint8Array) {\n    const item = this.convertor.from(buffer)\n    this.queue.push(item)\n    if (this.resolveNext) {\n      this.resolveNext(undefined)\n      this.resolveNext = null\n    }\n  }\n\n  close() {\n    this.queue.push(undefined)\n    if (this.resolveNext) {\n      this.resolveNext(undefined)\n      this.resolveNext = null\n    }\n  }\n\n  async pushStream(chunks: ClientReadableStream<DataChunk>) {\n    const stream = (async function* (stream) {\n      for await (const c of stream) {\n        const chunk: DataChunk = c\n        yield chunk.data\n      }\n    })(chunks)\n    const item = await this.convertor.fromStream(stream)\n    this.queue.push(item)\n    if (this.resolveNext) {\n      this.resolveNext(undefined)\n      this.resolveNext = null\n    }\n  }\n\n  async *[Symbol.asyncIterator]() {\n    while (true) {\n      if (this.queue.length > 0) {\n        const item = this.queue.shift()!\n        if (item === undefined) break\n        yield item\n      } else {\n        await new Promise<undefined>((resolve) => (this.resolveNext = resolve))\n      }\n    }\n  }\n}\n\nexport class ReaderInstance implements Reader {\n  private client: RunnerClient\n  readonly uri: string\n  private logger: winston.Logger\n\n  private iterators: MyIter<unknown>[] = []\n\n  constructor(uri: string, client: RunnerClient, logger: winston.Logger) {\n    this.uri = uri\n    this.client = client\n    this.logger = logger\n  }\n\n  anys(): AsyncIterable<Any> {\n    const iter = new MyIter(AnyConvertor)\n    this.iterators.push(iter)\n    return iter\n  }\n\n  strings(): AsyncIterable<string> {\n    const iter = new MyIter(StringConvertor)\n    this.iterators.push(iter)\n    return iter\n  }\n\n  buffers(): AsyncIterable<Uint8Array> {\n    const iter = new MyIter(NoConvertor)\n    this.iterators.push(iter)\n    return iter\n  }\n\n  streams(): AsyncIterable<AsyncGenerator<Uint8Array>> {\n    const iter = new MyIter(StreamConvertor)\n    this.iterators.push(iter)\n    return iter\n  }\n\n  handleMsg(msg: Message) {\n    this.logger.debug(`${this.uri} handling message`)\n    for (const iter of this.iterators) {\n      iter.push(msg.data)\n    }\n  }\n\n  close() {\n    for (const iter of this.iterators) {\n      iter.close()\n    }\n  }\n\n  handleStreamingMessage(msg: StreamMessage) {\n    this.logger.debug(`${this.uri} handling streaming message`)\n    const chunks = this.client.receiveStreamMessage(msg.id!)\n    for (const iter of this.iterators) {\n      iter.pushStream(chunks)\n    }\n  }\n}\n"]}

package/lib/reexports.d.ts

@@ -0,0 +1,3 @@
+export * from '@rdfc/proto';
+export { ClientReadableStreamImpl, ClientReadableStream, } from '@grpc/grpc-js/build/src/call.js';
+export * as grpc from '@grpc/grpc-js';

package/lib/reexports.js

@@ -0,0 +1,4 @@
+export * from '@rdfc/proto';
+export { ClientReadableStreamImpl, } from '@grpc/grpc-js/build/src/call.js';
+export * as grpc from '@grpc/grpc-js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVleHBvcnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3JlZXhwb3J0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQTtBQUMzQixPQUFPLEVBQ0wsd0JBQXdCLEdBRXpCLE1BQU0saUNBQWlDLENBQUE7QUFDeEMsT0FBTyxLQUFLLElBQUksTUFBTSxlQUFlLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICdAcmRmYy9wcm90bydcbmV4cG9ydCB7XG4gIENsaWVudFJlYWRhYmxlU3RyZWFtSW1wbCxcbiAgQ2xpZW50UmVhZGFibGVTdHJlYW0sXG59IGZyb20gJ0BncnBjL2dycGMtanMvYnVpbGQvc3JjL2NhbGwuanMnXG5leHBvcnQgKiBhcyBncnBjIGZyb20gJ0BncnBjL2dycGMtanMnXG4iXX0=

package/lib/runner.d.ts

@@ -0,0 +1,26 @@
+import { OrchestratorMessage, Processor, RunnerClient, RunnerMessage } from '@rdfc/proto';
+import { Reader } from './reader.js';
+import { Writer } from './writer.js';
+import { Processor as Proc } from './processor.js';
+import { Logger } from 'winston';
+import { Term } from '@rdfjs/types';
+export type Writable = (msg: OrchestratorMessage) => Promise<unknown>;
+export type FullProc<C extends Proc<unknown>> = C extends Proc<infer T> ? T & C : unknown;
+export declare class Runner {
+    private readonly readers;
+    private readonly writers;
+    private readonly client;
+    private readonly write;
+    private readonly logger;
+    private shapes;
+    private quads;
+    private readonly uri;
+    private readonly processors;
+    private readonly processorTransforms;
+    constructor(client: RunnerClient, write: Writable, uri: string, logger: Logger);
+    addProcessor<P extends Proc<unknown>>(proc: Processor): Promise<FullProc<P>>;
+    start(): Promise<void>;
+    createWriter(uri: Term): Writer;
+    createReader(uri: Term): Reader;
+    handleOrchMessage(msg: RunnerMessage): Promise<void>;
+}

package/lib/runner.js

@@ -0,0 +1,121 @@
+import { ReaderInstance } from './reader.js';
+import { WriterInstance } from './writer.js';
+import winston from 'winston';
+import { RpcTransport } from './logger.js';
+import { empty, extractShapes } from 'rdf-lens';
+import { NamedNode, Parser } from 'n3';
+import { createNamespace, createUriAndTermNamespace, RDF } from '@treecg/types';
+const RDFL = createUriAndTermNamespace('https://w3id.org/rdf-lens/ontology#', 'CBD', 'Path', 'PathLens', 'Context', 'TypedExtract', 'EnvVariable', 'envKey', 'envDefault', 'datatype');
+const RDFC = createNamespace('https://w3id.org/rdf-connect#', (x) => x, 'Reader', 'Writer');
+export class Runner {
+    readers = {};
+    writers = {};
+    client;
+    write;
+    logger;
+    shapes;
+    quads = [];
+    uri;
+    processors = [];
+    processorTransforms = [];
+    constructor(client, write, uri, logger) {
+        this.client = client;
+        this.write = write;
+        this.uri = uri;
+        this.logger = logger;
+    }
+    async addProcessor(proc) {
+        const procLogger = winston.createLogger({
+            transports: [
+                new RpcTransport({
+                    entities: [proc.uri, this.uri],
+                    stream: this.client.logStream(() => { }),
+                }),
+            ],
+        });
+        const ty = JSON.stringify(this.quads
+            .filter((x) => x.subject.value === proc.uri && x.predicate.equals(RDF.terms.type))
+            .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),
+            quads: this.quads,
+        });
+        const config = JSON.parse(proc.config);
+        const jsProgram = await import(config.file);
+        const clazz = jsProgram[config.clazz || 'default'];
+        const instance = new clazz(args, procLogger);
+        await instance.init();
+        this.logger.info('inited ' + proc.uri + ' type ' + ty);
+        this.processors.push(instance);
+        this.processorTransforms.push(instance.transform());
+        await this.write({ init: { uri: proc.uri } });
+        return instance;
+    }
+    async start() {
+        try {
+            await Promise.all(this.processors.map((x) => x.produce()));
+            await Promise.all(this.processorTransforms);
+        }
+        catch (ex) {
+            this.logger.error('Start failed: ' + JSON.stringify(ex));
+        }
+    }
+    createWriter(uri) {
+        const ids = uri.value;
+        if (this.writers[ids] === undefined) {
+            this.writers[ids] = [];
+        }
+        const writer = new WriterInstance(ids, this.client, this.write, this.logger);
+        this.writers[ids].push(writer);
+        return writer;
+    }
+    createReader(uri) {
+        const ids = uri.value;
+        if (this.readers[ids] === undefined) {
+            this.readers[ids] = [];
+        }
+        const reader = new ReaderInstance(ids, this.client, this.logger);
+        this.readers[ids].push(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);
+            }
+        }
+        if (msg.streamMsg) {
+            for (const reader of this.readers[msg.streamMsg.channel] || []) {
+                reader.handleStreamingMessage(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);
+            }
+        }
+        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));
+            }
+        }
+    }
+}
+//# 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"]}

package/lib/testUtils.d.ts

@@ -0,0 +1,24 @@
+import { DataChunk, RunnerClient } from "@rdfc/proto";
+import { ClientReadableStream } from "@grpc/grpc-js";
+import winston from "winston";
+import { WriterInstance } from "./writer.js";
+import { ReaderInstance } from "./reader.js";
+import { Processor } from "./processor.js";
+import { FullProc } from "./runner.js";
+import { Quad } from "@rdfjs/types";
+export declare function getProcessorShape(baseIRI?: string): Promise<import("rdf-lens").Shapes>;
+export declare class TestClient extends RunnerClient {
+    next: (stream: ClientReadableStream<DataChunk>) => unknown;
+    constructor();
+    nextStream(): Promise<ClientReadableStream<DataChunk>>;
+    receiveStreamMessage(): ClientReadableStream<DataChunk>;
+}
+export declare function one<T>(iter: AsyncIterable<T>): Promise<T | undefined>;
+export declare const client: TestClient;
+export declare const uri = "someUri";
+export declare const logger: winston.Logger;
+export declare function createWriter(iri?: string): [WriterInstance, ReaderInstance];
+export declare function createReader(iri?: string): ReaderInstance;
+export declare function importFile(file: string): Promise<Quad[]>;
+export declare function getProc<T extends Processor<unknown>>(config: string, ty: string, configLocation: string, uri?: string): Promise<FullProc<T>>;
+export declare function checkProcDefinition(file: string, n: string): Promise<void>;