@rdfc/js-runner 1.0.0-alpha.7 → 2.0.0-alpha.1

package/index.ttl

@@ -0,0 +1,63 @@
+@prefix prov: <http://www.w3.org/ns/prov#>.
+@prefix sds: <https://w3id.org/sds#>.
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
+@prefix owl: <http://www.w3.org/2002/07/owl#>.
+@prefix rdfl: <https://w3id.org/rdf-lens/ontology#>.
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+@prefix sh: <http://www.w3.org/ns/shacl#>.
+@prefix rdfc: <https://w3id.org/rdf-connect/ontology#>.
+
+# rdfc:JsRunner a rdfc:CommandRunner;
+#   rdfc:command "npx js-runner";
+#   rdfc:processor_definition <JsProcessorShape>.
+#
+rdfc:JsRunner a rdfc:CommandRunner;
+  rdfc:handles rdfc:JsProcessor;
+  rdfc:handlesSubjectsOf rdfc:jsImplementationOf;
+  rdfc:command "npx js-runner";
+  rdfc:processor_definition <JsProcessorShape>.
+
+sds:Activity rdfs:subClassOf prov:Activity.
+rdfc:Processor rdfs:subClassOf sds:Activity.
+sds:implementationOf rdfs:subPropertyOf rdfs:subClassOf.
+rdfc:jsImplementationOf rdfs:subPropertyOf sds:implementationOf.
+
+# rdfc:LogProcessor sds:jsImplementationOf rdfc:Processor;
+#   rdfs:label "Simple Log Processor";
+#   rdfs:comment "Logs incoming messages";
+#   rdfc:entrypoint <./>;
+#   rdfc:file <./lib/util_processors.js>;
+#   rdfc:class "LogProcessor".
+#
+# [ ] a sh:NodeShape;
+#   sh:targetClass rdfc:LogProcessor;
+#   sh:property [
+#     sh:path rdfc:reader;
+#     sh:name "reader";
+#     sh:minCount 1;
+#     sh:maxCount 1;
+#     sh:class rdfc:Reader;
+#   ].
+
+[ ] a sh:NodeShape;
+  sh:targetClass <JsProcessorShape>;
+  sh:property [
+    sh:path rdfc:entrypoint;
+    sh:name "location";
+    sh:minCount 1;
+    sh:maxCount 1;
+    sh:datatype xsd:iri;
+  ], [
+    sh:path rdfc:file;
+    sh:name "file";
+    sh:minCount 1;
+    sh:maxCount 1;
+    sh:datatype xsd:string;
+  ], [
+    sh:path rdfc:class;
+    sh:name "clazz";
+    sh:maxCount 1;
+    sh:datatype xsd:string;
+  ].
+

package/jest.config.js

@@ -0,0 +1,2 @@
+export const preset = 'ts-jest'
+export const testEnvironment = 'node'

package/lib/client.d.ts

@@ -0,0 +1 @@
+export declare function start(addr: string, uri: string): Promise<void>;

package/lib/client.js

@@ -0,0 +1,43 @@
+import * as grpc from '@grpc/grpc-js';
+import { promisify } from 'util';
+import { RunnerClient } from '@rdfc/proto';
+import winston from 'winston';
+import { RpcTransport } from './logger.js';
+import { Runner } from './runner.js';
+export async function start(addr, uri) {
+    const client = new RunnerClient(addr, grpc.credentials.createInsecure());
+    const logger = winston.createLogger({
+        transports: [
+            new RpcTransport({
+                entities: [uri, 'cli'],
+                stream: client.logStream(() => { }),
+            }),
+        ],
+    });
+    const stream = client.connect();
+    logger.info('Connected with server ' + addr);
+    const writable = promisify(stream.write.bind(stream));
+    const runner = new Runner(client, writable, uri, logger);
+    await writable({ identify: { uri } });
+    let processorsEnd;
+    const processorsEnded = new Promise((res) => (processorsEnd = res));
+    (async () => {
+        for await (const chunk of stream) {
+            const msg = chunk;
+            if (msg.proc) {
+                await runner.addProcessor(msg.proc);
+            }
+            if (msg.start) {
+                runner.start().then(processorsEnd);
+            }
+            await runner.handleOrchMessage(msg);
+        }
+        logger.error('Stream ended');
+    })();
+    await processorsEnded;
+    logger.info('All processors are finished');
+    stream.end();
+    client.close();
+    process.exit(0);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/convertor.d.ts

@@ -0,0 +1,9 @@
+import { Any } from './reader.js';
+export interface Convertor<T> {
+    from(buffer: Uint8Array): T;
+    fromStream(stream: AsyncIterable<Uint8Array>): Promise<T>;
+}
+export declare const AnyConvertor: Convertor<Any>;
+export declare const StringConvertor: Convertor<string>;
+export declare const StreamConvertor: Convertor<AsyncGenerator<Uint8Array>>;
+export declare const NoConvertor: Convertor<Uint8Array>;

package/lib/convertor.js

@@ -0,0 +1,51 @@
+const decoder = new TextDecoder();
+export const AnyConvertor = {
+    from: function (buffer) {
+        return {
+            buffer,
+        };
+    },
+    fromStream: async function (inp) {
+        const stream = (async function* () {
+            yield* inp;
+        })();
+        return { stream };
+    },
+};
+export const StringConvertor = {
+    from(buffer) {
+        return decoder.decode(buffer);
+    },
+    async fromStream(stream) {
+        const chunks = [];
+        for await (const chunk of stream) {
+            chunks.push(chunk);
+        }
+        return decoder.decode(Buffer.concat(chunks));
+    },
+};
+export const StreamConvertor = {
+    from(buffer) {
+        return (async function* () {
+            yield buffer;
+        })();
+    },
+    async fromStream(stream) {
+        return (async function* () {
+            yield* stream;
+        })();
+    },
+};
+export const NoConvertor = {
+    from(buffer) {
+        return buffer;
+    },
+    async fromStream(stream) {
+        const chunks = [];
+        for await (const chunk of stream) {
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks);
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udmVydG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbnZlcnRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sR0FBRyxJQUFJLFdBQVcsRUFBRSxDQUFBO0FBTWpDLE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBbUI7SUFDMUMsSUFBSSxFQUFFLFVBQVUsTUFBa0I7UUFDaEMsT0FBTztZQUNMLE1BQU07U0FDUCxDQUFBO0lBQ0gsQ0FBQztJQUNELFVBQVUsRUFBRSxLQUFLLFdBQVcsR0FBOEI7UUFDeEQsTUFBTSxNQUFNLEdBQUcsQ0FBQyxLQUFLLFNBQVMsQ0FBQztZQUM3QixLQUFLLENBQUMsQ0FBQyxHQUFHLENBQUE7UUFDWixDQUFDLENBQUMsRUFBRSxDQUFBO1FBQ0osT0FBTyxFQUFFLE1BQU0sRUFBRSxDQUFBO0lBQ25CLENBQUM7Q0FDRixDQUFBO0FBRUQsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFzQjtJQUNoRCxJQUFJLENBQUMsTUFBTTtRQUNULE9BQU8sT0FBTyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQTtJQUMvQixDQUFDO0lBQ0QsS0FBSyxDQUFDLFVBQVUsQ0FBQyxNQUFNO1FBQ3JCLE1BQU0sTUFBTSxHQUFpQixFQUFFLENBQUE7UUFDL0IsSUFBSSxLQUFLLEVBQUUsTUFBTSxLQUFLLElBQUksTUFBTSxFQUFFLENBQUM7WUFDakMsTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQTtRQUNwQixDQUFDO1FBQ0QsT0FBTyxPQUFPLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQTtJQUM5QyxDQUFDO0NBQ0YsQ0FBQTtBQUNELE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBMEM7SUFDcEUsSUFBSSxDQUFDLE1BQU07UUFDVCxPQUFPLENBQUMsS0FBSyxTQUFTLENBQUM7WUFDckIsTUFBTSxNQUFNLENBQUE7UUFDZCxDQUFDLENBQUMsRUFBRSxDQUFBO0lBQ04sQ0FBQztJQUVELEtBQUssQ0FBQyxVQUFVLENBQUMsTUFBTTtRQUNyQixPQUFPLENBQUMsS0FBSyxTQUFTLENBQUM7WUFDckIsS0FBSyxDQUFDLENBQUMsTUFBTSxDQUFBO1FBQ2YsQ0FBQyxDQUFDLEVBQUUsQ0FBQTtJQUNOLENBQUM7Q0FDRixDQUFBO0FBQ0QsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUEwQjtJQUNoRCxJQUFJLENBQUMsTUFBTTtRQUNULE9BQU8sTUFBTSxDQUFBO0lBQ2YsQ0FBQztJQUNELEtBQUssQ0FBQyxVQUFVLENBQUMsTUFBTTtRQUNyQixNQUFNLE1BQU0sR0FBaUIsRUFBRSxDQUFBO1FBQy9CLElBQUksS0FBSyxFQUFFLE1BQU0sS0FBSyxJQUFJLE1BQU0sRUFBRSxDQUFDO1lBQ2pDLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUE7UUFDcEIsQ0FBQztRQUNELE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQTtJQUM5QixDQUFDO0NBQ0YsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFueSB9IGZyb20gJy4vcmVhZGVyJ1xuXG5jb25zdCBkZWNvZGVyID0gbmV3IFRleHREZWNvZGVyKClcbmV4cG9ydCBpbnRlcmZhY2UgQ29udmVydG9yPFQ+IHtcbiAgZnJvbShidWZmZXI6IFVpbnQ4QXJyYXkpOiBUXG4gIGZyb21TdHJlYW0oc3RyZWFtOiBBc3luY0l0ZXJhYmxlPFVpbnQ4QXJyYXk+KTogUHJvbWlzZTxUPlxufVxuXG5leHBvcnQgY29uc3QgQW55Q29udmVydG9yOiBDb252ZXJ0b3I8QW55PiA9IHtcbiAgZnJvbTogZnVuY3Rpb24gKGJ1ZmZlcjogVWludDhBcnJheSk6IEFueSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIGJ1ZmZlcixcbiAgICB9XG4gIH0sXG4gIGZyb21TdHJlYW06IGFzeW5jIGZ1bmN0aW9uIChpbnA6IEFzeW5jSXRlcmFibGU8VWludDhBcnJheT4pOiBQcm9taXNlPEFueT4ge1xuICAgIGNvbnN0IHN0cmVhbSA9IChhc3luYyBmdW5jdGlvbiogKCkge1xuICAgICAgeWllbGQqIGlucFxuICAgIH0pKClcbiAgICByZXR1cm4geyBzdHJlYW0gfVxuICB9LFxufVxuXG5leHBvcnQgY29uc3QgU3RyaW5nQ29udmVydG9yOiBDb252ZXJ0b3I8c3RyaW5nPiA9IHtcbiAgZnJvbShidWZmZXIpIHtcbiAgICByZXR1cm4gZGVjb2Rlci5kZWNvZGUoYnVmZmVyKVxuICB9LFxuICBhc3luYyBmcm9tU3RyZWFtKHN0cmVhbSkge1xuICAgIGNvbnN0IGNodW5rczogVWludDhBcnJheVtdID0gW11cbiAgICBmb3IgYXdhaXQgKGNvbnN0IGNodW5rIG9mIHN0cmVhbSkge1xuICAgICAgY2h1bmtzLnB1c2goY2h1bmspXG4gICAgfVxuICAgIHJldHVybiBkZWNvZGVyLmRlY29kZShCdWZmZXIuY29uY2F0KGNodW5rcykpXG4gIH0sXG59XG5leHBvcnQgY29uc3QgU3RyZWFtQ29udmVydG9yOiBDb252ZXJ0b3I8QXN5bmNHZW5lcmF0b3I8VWludDhBcnJheT4+ID0ge1xuICBmcm9tKGJ1ZmZlcikge1xuICAgIHJldHVybiAoYXN5bmMgZnVuY3Rpb24qICgpIHtcbiAgICAgIHlpZWxkIGJ1ZmZlclxuICAgIH0pKClcbiAgfSxcblxuICBhc3luYyBmcm9tU3RyZWFtKHN0cmVhbSkge1xuICAgIHJldHVybiAoYXN5bmMgZnVuY3Rpb24qICgpIHtcbiAgICAgIHlpZWxkKiBzdHJlYW1cbiAgICB9KSgpXG4gIH0sXG59XG5leHBvcnQgY29uc3QgTm9Db252ZXJ0b3I6IENvbnZlcnRvcjxVaW50OEFycmF5PiA9IHtcbiAgZnJvbShidWZmZXIpIHtcbiAgICByZXR1cm4gYnVmZmVyXG4gIH0sXG4gIGFzeW5jIGZyb21TdHJlYW0oc3RyZWFtKSB7XG4gICAgY29uc3QgY2h1bmtzOiBVaW50OEFycmF5W10gPSBbXVxuICAgIGZvciBhd2FpdCAoY29uc3QgY2h1bmsgb2Ygc3RyZWFtKSB7XG4gICAgICBjaHVua3MucHVzaChjaHVuaylcbiAgICB9XG4gICAgcmV0dXJuIEJ1ZmZlci5jb25jYXQoY2h1bmtzKVxuICB9LFxufVxuIl19

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './client.js';
+export * from './writer.js';
+export * from './reader.js';
+export * from './processor.js';

package/lib/index.js

@@ -0,0 +1,5 @@
+export * from './client.js';
+export * from './writer.js';
+export * from './reader.js';
+export * from './processor.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxVQUFVLENBQUE7QUFDeEIsY0FBYyxVQUFVLENBQUE7QUFDeEIsY0FBYyxVQUFVLENBQUE7QUFDeEIsY0FBYyxhQUFhLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NsaWVudCdcbmV4cG9ydCAqIGZyb20gJy4vd3JpdGVyJ1xuZXhwb3J0ICogZnJvbSAnLi9yZWFkZXInXG5leHBvcnQgKiBmcm9tICcuL3Byb2Nlc3NvcidcbiJdfQ==

package/lib/jsonld.d.ts

@@ -0,0 +1,17 @@
+import { OrchestratorMessage, RunnerClient } from '@rdfc/proto';
+import { ReaderInstance } from './reader.js';
+import { WriterInstance } from './writer.js';
+import { Logger } from 'winston';
+export type RunnerItems = {
+    readers: {
+        [uri: string]: ReaderInstance[];
+    };
+    writers: {
+        [uri: string]: WriterInstance[];
+    };
+    client: RunnerClient;
+    write: Writable;
+};
+type Writable = (msg: OrchestratorMessage) => Promise<unknown>;
+export declare function parse_jsonld(args: string, logger: Logger, items: RunnerItems): Promise<unknown>;
+export {};

package/lib/jsonld.js

@@ -0,0 +1,134 @@
+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/ontology#', (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/ontology#',\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            } catch (e) {}\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,15 @@
+import winston 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;
+}

package/lib/logger.js

@@ -0,0 +1,27 @@
+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();
+        }
+    }
+}
+//# 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,29 @@
+import { Message, RunnerClient, StreamMessage } from '@rdfc/proto';
+import winston from 'winston';
+export type Any = {
+    string: string;
+} | {
+    stream: AsyncGenerator<Uint8Array>;
+} | {
+    buffer: Uint8Array;
+};
+export interface Reader {
+    strings(): AsyncIterable<string>;
+    streams(): AsyncIterable<AsyncGenerator<Uint8Array>>;
+    buffers(): AsyncIterable<Uint8Array>;
+    anys(): AsyncIterable<Any>;
+}
+export declare class ReaderInstance implements Reader {
+    private client;
+    private uri;
+    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,110 @@
+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);
+        if (this.resolveNext) {
+            this.resolveNext(item);
+            this.resolveNext = null;
+        }
+        else {
+            this.queue.push(item);
+        }
+    }
+    close() {
+        if (this.resolveNext) {
+            this.resolveNext(undefined);
+            this.resolveNext = null;
+        }
+        else {
+            this.queue.push(undefined);
+        }
+    }
+    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);
+        if (this.resolveNext) {
+            this.resolveNext(item);
+            this.resolveNext = null;
+        }
+        else {
+            this.queue.push(item);
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.queue.length > 0) {
+                const item = this.queue.shift();
+                if (item === undefined)
+                    break;
+                yield item;
+            }
+            else {
+                const item = await new Promise((resolve) => (this.resolveNext = resolve));
+                if (item === undefined)
+                    break;
+                yield item;
+            }
+        }
+    }
+}
+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  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: T | 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    if (this.resolveNext) {\n      this.resolveNext(item)\n      this.resolveNext = null\n    } else {\n      this.queue.push(item)\n    }\n  }\n\n  close() {\n    if (this.resolveNext) {\n      this.resolveNext(undefined)\n      this.resolveNext = null\n    } else {\n      this.queue.push(undefined)\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    if (this.resolveNext) {\n      this.resolveNext(item)\n      this.resolveNext = null\n    } else {\n      this.queue.push(item)\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        const item = await new Promise<T | undefined>(\n          (resolve) => (this.resolveNext = resolve),\n        )\n        if (item === undefined) break\n        yield item\n      }\n    }\n  }\n}\n\nexport class ReaderInstance implements Reader {\n  private client: RunnerClient\n  private 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/runner.d.ts

@@ -0,0 +1,25 @@
+import { OrchestratorMessage, Processor, RunnerClient, RunnerMessage } from '@rdfc/proto';
+import { Reader } from './reader.js';
+import { Writer } from './writer.js';
+import { Logger } from 'winston';
+import { Term } from '@rdfjs/types';
+type Writable = (msg: OrchestratorMessage) => Promise<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(proc: Processor): Promise<void>;
+    start(): Promise<void>;
+    createWriter(uri: Term): Writer;
+    createReader(uri: Term): Reader;
+    handleOrchMessage(msg: RunnerMessage): Promise<void>;
+}
+export {};