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

package/lib/testUtils.js

@@ -0,0 +1,150 @@
+import { RunnerClient } from "@rdfc/proto";
+import * as grpc from "@grpc/grpc-js";
+import { ClientReadableStreamImpl } from "./reexports.js";
+import { extractShapes } from "rdf-lens";
+import { NamedNode, Parser, Writer } from "n3";
+import { readFile } from "fs/promises";
+import winston, { createLogger } from "winston";
+import { WriterInstance } from "./writer.js";
+import { ReaderInstance } from "./reader.js";
+import { Runner } from "./runner.js";
+import { createTermNamespace } from "@treecg/types";
+import { expect } from "vitest";
+export async function getProcessorShape(baseIRI = process.cwd() + "/node_modules/@rdfc/js-runner/index.ttl") {
+    const configFile = await readFile(baseIRI, { encoding: "utf8" });
+    const configQuads = new Parser().parse(configFile);
+    const shapes = extractShapes(configQuads);
+    return shapes;
+}
+export class TestClient extends RunnerClient {
+    next;
+    constructor() {
+        super("localhost:5400", grpc.credentials.createInsecure());
+    }
+    nextStream() {
+        return new Promise((res) => (this.next = res));
+    }
+    receiveStreamMessage() {
+        const stream = new ClientReadableStreamImpl((data) => {
+            return { data };
+        });
+        this.next(stream);
+        return stream;
+    }
+}
+export async function one(iter) {
+    for await (const item of iter) {
+        return item;
+    }
+}
+export const client = new TestClient();
+export const uri = "someUri";
+export const logger = createLogger({
+    transports: new winston.transports.Console({
+        level: process.env["DEBUG"] || "info",
+    }),
+});
+export function createWriter(iri = uri) {
+    const reader = createReader(iri);
+    const writeStream = new WriterInstance(iri, client, async (msg) => {
+        if (msg.msg) {
+            reader.handleMsg(msg.msg);
+        }
+        if (msg.close) {
+            reader.close();
+        }
+    }, logger);
+    return [writeStream, reader];
+}
+export function createReader(iri = uri) {
+    const reader = new ReaderInstance(iri, client, logger);
+    return reader;
+}
+const shapeQuads = `
+@prefix rdfc: <https://w3id.org/rdf-connect#>.
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+@prefix sh: <http://www.w3.org/ns/shacl#>.
+[ ] a sh:NodeShape;
+  sh:targetClass <JsProcessorShape>;
+  sh:property [
+    sh:path rdfc:entrypoint;
+    sh:name "location";
+    sh:minCount 1;
+    sh:maxCount 1;
+    sh:datatype xsd:string;
+  ], [
+    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;
+  ].
+`;
+const OWL = createTermNamespace("http://www.w3.org/2002/07/owl#", "imports");
+const processorShapes = extractShapes(new Parser().parse(shapeQuads));
+const base = "https://w3id.org/rdf-connect#";
+export async function importFile(file) {
+    const done = new Set();
+    const todo = [new URL("file://" + file)];
+    const quads = [];
+    let item = todo.pop();
+    while (item !== undefined) {
+        if (done.has(item.toString())) {
+            item = todo.pop();
+            continue;
+        }
+        done.add(item.toString());
+        if (item.protocol !== "file:") {
+            throw "No supported protocol " + item.protocol;
+        }
+        const txt = await readFile(item.pathname, { encoding: "utf8" });
+        const extras = new Parser({ baseIRI: item.toString() }).parse(txt);
+        for (const o of extras
+            .filter((x) => x.subject.value === item?.toString() &&
+            x.predicate.equals(OWL.imports))
+            .map((x) => x.object.value)) {
+            todo.push(new URL(o));
+        }
+        quads.push(...extras);
+        item = todo.pop();
+    }
+    return quads;
+}
+export async function getProc(config, ty, configLocation, uri = "http://example.com/ns#processor") {
+    const configQuads = await importFile(configLocation);
+    const procConfig = processorShapes.lenses["JsProcessorShape"].execute({
+        id: new NamedNode(base + ty),
+        quads: configQuads,
+    });
+    const msgs = [];
+    const write = async (x) => {
+        msgs.push(x);
+    };
+    const runner = new Runner(new TestClient(), write, "http://example.com/ns#", logger);
+    configQuads.push(...new Parser().parse(config));
+    await runner.handleOrchMessage({
+        pipeline: new Writer().quadsToString(configQuads),
+    });
+    const proc = await runner.addProcessor({
+        config: JSON.stringify(procConfig),
+        arguments: "",
+        uri,
+    });
+    return proc;
+}
+export async function checkProcDefinition(file, n) {
+    const quads = await importFile(file);
+    const procConfig = (processorShapes.lenses["JsProcessorShape"].execute({
+        id: new NamedNode(base + n),
+        quads: quads,
+    }));
+    expect(procConfig.file, n + " has file").toBeDefined();
+    expect(procConfig.location, n + " has location").toBeDefined();
+    expect(procConfig.clazz, n + " has clazz").toBeDefined();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"testUtils.js","sourceRoot":"","sources":["../src/testUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,YAAY,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,IAAI,MAAM,eAAe,CAAC;AAEtC,OAAO,EAAE,wBAAwB,EAAuB,MAAM,aAAa,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,OAAO,EAAE,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE1C,OAAO,EAAY,MAAM,EAAE,MAAM,UAAU,CAAC;AAE5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACnC,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,yCAAyC;IAEnE,MAAM,UAAU,GAAG,MAAM,QAAQ,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;IACjE,MAAM,WAAW,GAAG,IAAI,MAAM,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IACnD,MAAM,MAAM,GAAG,aAAa,CAAC,WAAW,CAAC,CAAC;IAE1C,OAAO,MAAM,CAAC;AAClB,CAAC;AAED,MAAM,OAAO,UAAW,SAAQ,YAAY;IACxC,IAAI,CAAuD;IAE3D;QACI,KAAK,CAAC,gBAAgB,EAAE,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC,CAAC;IAC/D,CAAC;IAED,UAAU;QACN,OAAO,IAAI,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC;IACnD,CAAC;IAED,oBAAoB;QAChB,MAAM,MAAM,GAAG,IAAI,wBAAwB,CAAY,CAAC,IAAY,EAAE,EAAE;YACpE,OAAO,EAAE,IAAI,EAAE,CAAC;QACpB,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAClB,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ;AAED,MAAM,CAAC,KAAK,UAAU,GAAG,CAAI,IAAsB;IAC/C,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,IAAI,EAAE,CAAC;QAC5B,OAAO,IAAI,CAAC;IAChB,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;AACvC,MAAM,CAAC,MAAM,GAAG,GAAG,SAAS,CAAC;AAC7B,MAAM,CAAC,MAAM,MAAM,GAAG,YAAY,CAAC;IAC/B,UAAU,EAAE,IAAI,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC;QACvC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,MAAM;KACxC,CAAC;CACL,CAAC,CAAC;AAEH,MAAM,UAAU,YAAY,CAAC,GAAG,GAAG,GAAG;IAClC,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,WAAW,GAAG,IAAI,cAAc,CAClC,GAAG,EACH,MAAM,EACN,KAAK,EAAE,GAAG,EAAE,EAAE;QACV,IAAI,GAAG,CAAC,GAAG,EAAE,CAAC;YACV,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC9B,CAAC;QACD,IAAI,GAAG,CAAC,KAAK,EAAE,CAAC;YACZ,MAAM,CAAC,KAAK,EAAE,CAAC;QACnB,CAAC;IACL,CAAC,EACD,MAAM,CACT,CAAC;IACF,OAAO,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;AACjC,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,GAAG,GAAG,GAAG;IAClC,MAAM,MAAM,GAAG,IAAI,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACvD,OAAO,MAAM,CAAC;AAClB,CAAC;AAED,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;CAwBlB,CAAC;AACF,MAAM,GAAG,GAAG,mBAAmB,CAAC,gCAAgC,EAAE,SAAS,CAAC,CAAC;AAC7E,MAAM,eAAe,GAAG,aAAa,CAAC,IAAI,MAAM,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;AACtE,MAAM,IAAI,GAAG,+BAA+B,CAAC;AAE7C,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,IAAY;IACzC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,IAAI,GAAG,CAAC,IAAI,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC;IACzC,MAAM,KAAK,GAAW,EAAE,CAAC;IAEzB,IAAI,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACtB,OAAO,IAAI,KAAK,SAAS,EAAE,CAAC;QACxB,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC;YAC5B,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAClB,SAAS;QACb,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC1B,IAAI,IAAI,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;YAC5B,MAAM,wBAAwB,GAAG,IAAI,CAAC,QAAQ,CAAC;QACnD,CAAC;QAED,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;QAChE,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAEnE,KAAK,MAAM,CAAC,IAAI,MAAM;aACjB,MAAM,CACH,CAAC,CAAC,EAAE,EAAE,CACF,CAAC,CAAC,OAAO,CAAC,KAAK,KAAK,IAAI,EAAE,QAAQ,EAAE;YACpC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CACtC;aACA,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9B,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1B,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC;QAEtB,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACtB,CAAC;IAED,OAAO,KAAK,CAAC;AACjB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,OAAO,CACzB,MAAc,EACd,EAAU,EACV,cAAsB,EACtB,GAAG,GAAG,iCAAiC;IAEvC,MAAM,WAAW,GAAG,MAAM,UAAU,CAAC,cAAc,CAAC,CAAC;IACrD,MAAM,UAAU,GAAG,eAAe,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,OAAO,CAAC;QAClE,EAAE,EAAE,IAAI,SAAS,CAAC,IAAI,GAAG,EAAE,CAAC;QAC5B,KAAK,EAAE,WAAW;KACrB,CAAC,CAAC;IAEH,MAAM,IAAI,GAA0B,EAAE,CAAC;IACvC,MAAM,KAAK,GAAG,KAAK,EAAE,CAAsB,EAAE,EAAE;QAC3C,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACjB,CAAC,CAAC;IACF,MAAM,MAAM,GAAG,IAAI,MAAM,CACrB,IAAI,UAAU,EAAE,EAChB,KAAK,EACL,wBAAwB,EACxB,MAAM,CACT,CAAC;IACF,WAAW,CAAC,IAAI,CAAC,GAAG,IAAI,MAAM,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;IAChD,MAAM,MAAM,CAAC,iBAAiB,CAAC;QAC3B,QAAQ,EAAE,IAAI,MAAM,EAAE,CAAC,aAAa,CAAC,WAAW,CAAC;KACpD,CAAC,CAAC;IAEH,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,YAAY,CAAI;QACtC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC;QAClC,SAAS,EAAE,EAAE;QACb,GAAG;KACN,CAAC,CAAC;IAEH,OAAO,IAAI,CAAC;AAChB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,IAAY,EAAE,CAAS;IAC7D,MAAM,KAAK,GAAG,MAAM,UAAU,CAAC,IAAI,CAAC,CAAC;IACrC,MAAM,UAAU,GAAoD,CAChE,eAAe,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,OAAO,CAAC;QAC/C,EAAE,EAAE,IAAI,SAAS,CAAC,IAAI,GAAG,CAAC,CAAC;QAC3B,KAAK,EAAE,KAAK;KACf,CAAC,CACL,CAAC;IACF,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,WAAW,EAAE,CAAC;IACvD,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,GAAG,eAAe,CAAC,CAAC,WAAW,EAAE,CAAC;IAC/D,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,WAAW,EAAE,CAAC;AAC7D,CAAC","sourcesContent":["import { DataChunk, RunnerClient } from \"@rdfc/proto\";\nimport * as grpc from \"@grpc/grpc-js\";\nimport { ClientReadableStream } from \"@grpc/grpc-js\";\nimport { ClientReadableStreamImpl, OrchestratorMessage } from \"./reexports\";\nimport { extractShapes } from \"rdf-lens\";\nimport { NamedNode, Parser, Writer } from \"n3\";\nimport { readFile } from \"fs/promises\";\nimport winston, { createLogger } from \"winston\";\nimport { WriterInstance } from \"./writer\";\nimport { ReaderInstance } from \"./reader\";\nimport { Processor } from \"./processor\";\nimport { FullProc, Runner } from \"./runner\";\nimport { Quad, Term } from \"@rdfjs/types\";\nimport { createTermNamespace } from \"@treecg/types\";\nimport { expect } from \"vitest\";\n\nexport async function getProcessorShape(\n    baseIRI = process.cwd() + \"/node_modules/@rdfc/js-runner/index.ttl\",\n) {\n    const configFile = await readFile(baseIRI, { encoding: \"utf8\" });\n    const configQuads = new Parser().parse(configFile);\n    const shapes = extractShapes(configQuads);\n\n    return shapes;\n}\n\nexport class TestClient extends RunnerClient {\n    next: (stream: ClientReadableStream<DataChunk>) => unknown;\n\n    constructor() {\n        super(\"localhost:5400\", grpc.credentials.createInsecure());\n    }\n\n    nextStream(): Promise<ClientReadableStream<DataChunk>> {\n        return new Promise((res) => (this.next = res));\n    }\n\n    receiveStreamMessage(): ClientReadableStream<DataChunk> {\n        const stream = new ClientReadableStreamImpl<DataChunk>((data: Buffer) => {\n            return { data };\n        });\n        this.next(stream);\n        return stream;\n    }\n}\n\nexport async function one<T>(iter: AsyncIterable<T>): Promise<T | undefined> {\n    for await (const item of iter) {\n        return item;\n    }\n}\n\nexport const client = new TestClient();\nexport const uri = \"someUri\";\nexport const logger = createLogger({\n    transports: new winston.transports.Console({\n        level: process.env[\"DEBUG\"] || \"info\",\n    }),\n});\n\nexport function createWriter(iri = uri): [WriterInstance, ReaderInstance] {\n    const reader = createReader(iri);\n    const writeStream = new WriterInstance(\n        iri,\n        client,\n        async (msg) => {\n            if (msg.msg) {\n                reader.handleMsg(msg.msg);\n            }\n            if (msg.close) {\n                reader.close();\n            }\n        },\n        logger,\n    );\n    return [writeStream, reader];\n}\n\nexport function createReader(iri = uri): ReaderInstance {\n    const reader = new ReaderInstance(iri, client, logger);\n    return reader;\n}\n\nconst shapeQuads = `\n@prefix rdfc: <https://w3id.org/rdf-connect#>.\n@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.\n@prefix sh: <http://www.w3.org/ns/shacl#>.\n[ ] a sh:NodeShape;\n  sh:targetClass <JsProcessorShape>;\n  sh:property [\n    sh:path rdfc:entrypoint;\n    sh:name \"location\";\n    sh:minCount 1;\n    sh:maxCount 1;\n    sh:datatype xsd:string;\n  ], [\n    sh:path rdfc:file;\n    sh:name \"file\";\n    sh:minCount 1;\n    sh:maxCount 1;\n    sh:datatype xsd:string;\n  ], [\n    sh:path rdfc:class;\n    sh:name \"clazz\";\n    sh:maxCount 1;\n    sh:datatype xsd:string;\n  ].\n`;\nconst OWL = createTermNamespace(\"http://www.w3.org/2002/07/owl#\", \"imports\");\nconst processorShapes = extractShapes(new Parser().parse(shapeQuads));\nconst base = \"https://w3id.org/rdf-connect#\";\n\nexport async function importFile(file: string): Promise<Quad[]> {\n    const done = new Set<string>();\n    const todo = [new URL(\"file://\" + file)];\n    const quads: Quad[] = [];\n\n    let item = todo.pop();\n    while (item !== undefined) {\n        if (done.has(item.toString())) {\n            item = todo.pop();\n            continue;\n        }\n        done.add(item.toString());\n        if (item.protocol !== \"file:\") {\n            throw \"No supported protocol \" + item.protocol;\n        }\n\n        const txt = await readFile(item.pathname, { encoding: \"utf8\" });\n        const extras = new Parser({ baseIRI: item.toString() }).parse(txt);\n\n        for (const o of extras\n            .filter(\n                (x) =>\n                    x.subject.value === item?.toString() &&\n                    x.predicate.equals(OWL.imports),\n            )\n            .map((x) => x.object.value)) {\n            todo.push(new URL(o));\n        }\n        quads.push(...extras);\n\n        item = todo.pop();\n    }\n\n    return quads;\n}\n\nexport async function getProc<T extends Processor<unknown>>(\n    config: string,\n    ty: string,\n    configLocation: string,\n    uri = \"http://example.com/ns#processor\",\n): Promise<FullProc<T>> {\n    const configQuads = await importFile(configLocation);\n    const procConfig = processorShapes.lenses[\"JsProcessorShape\"].execute({\n        id: new NamedNode(base + ty),\n        quads: configQuads,\n    });\n\n    const msgs: OrchestratorMessage[] = [];\n    const write = async (x: OrchestratorMessage) => {\n        msgs.push(x);\n    };\n    const runner = new Runner(\n        new TestClient(),\n        write,\n        \"http://example.com/ns#\",\n        logger,\n    );\n    configQuads.push(...new Parser().parse(config));\n    await runner.handleOrchMessage({\n        pipeline: new Writer().quadsToString(configQuads),\n    });\n\n    const proc = await runner.addProcessor<T>({\n        config: JSON.stringify(procConfig),\n        arguments: \"\",\n        uri,\n    });\n\n    return proc;\n}\n\nexport async function checkProcDefinition(file: string, n: string) {\n    const quads = await importFile(file);\n    const procConfig = <{ file: Term; location: string; clazz: string }>(\n        processorShapes.lenses[\"JsProcessorShape\"].execute({\n            id: new NamedNode(base + n),\n            quads: quads,\n        })\n    );\n    expect(procConfig.file, n + \" has file\").toBeDefined();\n    expect(procConfig.location, n + \" has location\").toBeDefined();\n    expect(procConfig.clazz, n + \" has clazz\").toBeDefined();\n}\n"]}