jsonld-dataset-proxy and subscribable-dataset tests fixed

packages/jsonld-dataset-proxy/src/arrayProxy/arrayMethods.ts

@@ -42,11 +42,11 @@ export const arrayMethodsBuilders: ArrayMethodBuildersType = {
           target,
           key,
           quadsToDelete: (quads) => {
-            if (!start) {
+            const oldQuads = [...quads];
-              return [];
+            const newQuadSet = new Set(
-            }
+              quads.copyWithin(targetIndex, start, end),
-            const realEnd = end || quads.length;
+            );
-            return quads.slice(targetIndex, targetIndex + (realEnd - start));
+            return oldQuads.filter((oldQuad) => !newQuadSet.has(oldQuad));
           },
           modifyCoreArray: (coreArray) => {
             coreArray.copyWithin(targetIndex, start, end);

packages/jsonld-dataset-proxy/test/jsonldDatasetProxy.test.ts

@@ -854,6 +854,18 @@ describe("jsonldDatasetProxy", () => {
         );
       });
 
+      it("handles copyWithin with the optional start variable missing", async () => {
+        const [dataset, patient] = await getArrayLoadedDataset();
+        const arr = patient.name as string[];
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        expect(() => arr.copyWithin(0, undefined, 2)).not.toThrowError();
+        expect(arr).toEqual(["Garrett", "Bobby", "Ferguson"]);
+        expect(dataset.toString()).toEqual(
+          '<http://example.com/Patient1> <http://hl7.org/fhir/name> "Garrett" .\n<http://example.com/Patient1> <http://hl7.org/fhir/name> "Bobby" .\n<http://example.com/Patient1> <http://hl7.org/fhir/name> "Ferguson" .\n',
+        );
+      });
+
       it("handles fill", async () => {
         const [dataset, patient] = await getArrayLoadedDataset();
         const arr = patient.name as string[];

packages/rdf-utils/src/nodeSerialization.ts

@@ -209,12 +209,13 @@ export function stringToNode(
   expectTermType?: NodeTermTypes<Term>,
 ): AnyNode {
   const node = stringToTerm(input);
-  if (expectTermType && expectTermType.has(node.termType)) {
+  if (expectTermType && !expectTermType.has(node.termType)) {
     throw new Error(
-      `Expected term one of term type: [${Array.from(expectTermType).reduce(
+      `Expected term to be one of term type: [${Array.from(
-        (agg, termType) => `${agg}${termType}, `,
+        expectTermType,
-        "",
+      ).reduce((agg, termType) => `${agg}${termType}, `, "")}], but got ${
-      )}], but got ${node.termType}.`,
+        node.termType
+      }.`,
     );
   }
   return node as AnyNode;
@@ -226,7 +227,11 @@ export function stringToNode(
  * @returns Quad
  */
 export function stringToQuad(input: string) {
-  return stringQuadToQuad(JSON.parse(input));
+  try {
+    return stringQuadToQuad(JSON.parse(input));
+  } catch (err) {
+    throw new Error("Invalid Quad String");
+  }
 }
 
 /**
@@ -235,11 +240,21 @@ export function stringToQuad(input: string) {
  * @returns QuadMatch
  */
 export function stringToQuadMatch(input: string): QuadMatch {
-  const jsonRep = JSON.parse(input);
+  try {
-  return [
+    const jsonRep = JSON.parse(input);
-    jsonRep.subject ? stringToSubjectNode(jsonRep.subject) : undefined,
+    return [
-    jsonRep.predicate ? stringToPredicateNode(jsonRep.predicate) : undefined,
+      jsonRep.subject != undefined
-    jsonRep.object ? stringToObjectNode(jsonRep.object) : undefined,
+        ? stringToSubjectNode(jsonRep.subject)
-    jsonRep.graph ? stringToGraphNode(jsonRep.graph) : undefined,
+        : undefined,
-  ];
+      jsonRep.predicate != undefined
+        ? stringToPredicateNode(jsonRep.predicate)
+        : undefined,
+      jsonRep.object != undefined
+        ? stringToObjectNode(jsonRep.object)
+        : undefined,
+      jsonRep.graph != undefined ? stringToGraphNode(jsonRep.graph) : undefined,
+    ];
+  } catch (err) {
+    throw new Error("Invalid Quad Match String");
+  }
 }

packages/subscribable-dataset/example/subscribableDatasetExample.ts

@@ -1,6 +1,6 @@
 import { createSubscribableDataset } from "../src";
-import { quad, namedNode, literal } from "@ldo/rdf-utils";
+import { quad, namedNode, literal } from "@rdfjs/data-model";
-import type { Dataset, DatasetChanges } from "@ldo/rdf-utils";
+import type { DatasetChanges } from "@ldo/rdf-utils";
 
 // Create an empty subscribable dataset
 const subscribableDataset = createSubscribableDataset();
@@ -23,10 +23,8 @@ subscribableDataset.addAll([
 // Listener that will trigger whenever a quad containing the named
 // node "http://example.org/cartoons#Zuko" is added or removed.
 subscribableDataset.on(
-  namedNode("http://example.org/cartoons#Zuko"),
+  [namedNode("http://example.org/cartoons#Zuko"), null, null, null],
-  (zukoQuads: Dataset, changes: DatasetChanges) => {
+  (changes: DatasetChanges) => {
-    console.log("ZUKO NODE CHANGED ============");
-    console.log(zukoQuads.toString());
     console.log("Added Quads:");
     console.log(changes.added?.toString());
     console.log("Removed Quads:");
@@ -38,10 +36,9 @@ subscribableDataset.on(
 // node "http://example.org/cartoons" is added or removed. This is
 // useful for keeping track of the cartoons graph.
 subscribableDataset.on(
-  namedNode("http://example.org/cartoons"),
+  [namedNode("http://example.org/cartoons"), null, null, null],
-  (cartoonGraphQuads: Dataset, changes: DatasetChanges) => {
+  (changes: DatasetChanges) => {
     console.log("CARTOON GRAPH CHANGED ============");
-    console.log(cartoonGraphQuads.toString());
     console.log("Added Quads:");
     console.log(changes.added?.toString());
     console.log("Removed Quads:");

packages/subscribable-dataset/package.json

@@ -22,7 +22,9 @@
   },
   "homepage": "https://github.com/o-development/o-dataset-pack#readme",
   "devDependencies": {
+    "@rdfjs/data-model": "^1.2.0",
     "@rdfjs/dataset": "^1.1.0",
+    "@rdfjs/types": "^1.0.1",
     "@types/jest": "^27.0.3",
     "@types/jsonld": "^1.5.6",
     "@types/rdfjs__dataset": "^1.0.4",

packages/subscribable-dataset/src/ProxyTransactionalDataset.ts

@@ -1,10 +1,5 @@
-import type {
+import type { Dataset, BaseQuad, Term, DatasetFactory } from "@rdfjs/types";
-  Dataset,
+import type { DatasetChanges } from "@ldo/rdf-utils";
-  BaseQuad,
-  Term,
-  DatasetFactory,
-  DatasetChanges,
-} from "@ldo/rdf-utils";
 import type { BulkEditableDataset, TransactionalDataset } from "./types";
 import { ExtendedDataset } from "@ldo/dataset";
 

packages/subscribable-dataset/src/WrapperSubscribableDataset.ts

@@ -2,16 +2,19 @@ import { EventEmitter } from "events";
 import { quadMatchToString, stringToQuadMatch } from "@ldo/rdf-utils";
 import type {
   DatasetChanges,
-  Dataset,
-  BaseQuad,
-  Stream,
-  Term,
-  DatasetFactory,
   QuadMatch,
   SubjectNode,
   PredicateNode,
   ObjectNode,
+  GraphNode,
 } from "@ldo/rdf-utils";
+import type {
+  Dataset,
+  BaseQuad,
+  Stream,
+  Term,
+  DatasetFactory,
+} from "@rdfjs/types";
 import type {
   nodeEventListener,
   SubscribableDataset,
@@ -39,10 +42,6 @@ export default class WrapperSubscribableDataset<
    * The underlying event emitter
    */
   private eventEmitter: EventEmitter;
-  /**
-   * EventNames as a Set for O(1) lookup
-   */
-  private eventNamesSet: Set<string>;
 
   /**
    *
@@ -56,7 +55,6 @@ export default class WrapperSubscribableDataset<
     this.datasetFactory = datasetFactory;
     this.dataset = initialDataset || this.datasetFactory.dataset();
     this.eventEmitter = new EventEmitter();
-    this.eventNamesSet = new Set();
   }
 
   /**
@@ -379,6 +377,7 @@ export default class WrapperSubscribableDataset<
           subject: SubjectNode;
           predicate: PredicateNode;
           object: ObjectNode;
+          graph: GraphNode;
         };
         // All possible matches that could match with this triple
         const quadMatches: QuadMatch[] = [
@@ -390,6 +389,14 @@ export default class WrapperSubscribableDataset<
           [null, quad.predicate, quad.object, null],
           [null, null, quad.object, null],
           [quad.subject, quad.predicate, quad.object, null],
+          [null, null, null, quad.graph],
+          [quad.subject, null, null, quad.graph],
+          [quad.subject, quad.predicate, null, quad.graph],
+          [quad.subject, null, quad.object, quad.graph],
+          [null, quad.predicate, null, quad.graph],
+          [null, quad.predicate, quad.object, quad.graph],
+          [null, null, quad.object, quad.graph],
+          [quad.subject, quad.predicate, quad.object, quad.graph],
         ];
         quadMatches.forEach((quadMatch) => {
           const eventName = quadMatchToString(quadMatch);

packages/subscribable-dataset/src/WrapperSubscribableDatasetFactory.ts

@@ -1,4 +1,4 @@
-import type { DatasetFactory, BaseQuad, Dataset } from "@ldo/rdf-utils";
+import type { DatasetFactory, BaseQuad, Dataset } from "@rdfjs/types";
 import WrapperSubscribableDataset from "./WrapperSubscribableDataset";
 
 /**

packages/subscribable-dataset/src/createWrapperSubscribableDataset.ts

@@ -1,4 +1,4 @@
-import type { Dataset, DatasetFactory, Quad } from "@ldo/rdf-utils";
+import type { Dataset, DatasetFactory, Quad } from "@rdfjs/types";
 import type { WrapperSubscribableDataset } from ".";
 import { createDataset } from "@ldo/dataset";
 import WrapperSubscribableDatasetFactory from "./WrapperSubscribableDatasetFactory";

packages/subscribable-dataset/src/createWrapperSubscribableDatasetFromSerializedInput.ts

@@ -1,4 +1,5 @@
-import type { ParserOptions, Quad } from "@ldo/rdf-utils";
+import type { Quad } from "@rdfjs/types";
+import type { ParserOptions } from "@ldo/rdf-utils";
 import { createDatasetFromSerializedInput } from "@ldo/dataset";
 import { createWrapperSubscribableDatasetFactory } from "./createWrapperSubscribableDataset";
 import type WrapperSubscribableDataset from "./WrapperSubscribableDataset";

packages/subscribable-dataset/src/types.ts

@@ -1,9 +1,5 @@
-import type {
+import type { DatasetChanges, QuadMatch } from "@ldo/rdf-utils";
-  Dataset,
+import type { Dataset, BaseQuad } from "@rdfjs/types";
-  BaseQuad,
-  DatasetChanges,
-  QuadMatch,
-} from "@ldo/rdf-utils";
 
 /**
  * An event listeners for nodes

packages/subscribable-dataset/test/ProxyTransactionalDataset.test.ts

@@ -1,10 +1,10 @@
-import { namedNode, literal, quad } from "@ldo/rdf-utils";
+import { namedNode, literal, quad } from "@rdfjs/data-model";
 import type {
   Dataset,
   DatasetCoreFactory,
   Quad,
   DatasetCore,
-} from "@ldo/rdf-utils";
+} from "@rdfjs/types";
 import type { BulkEditableDataset } from "../src";
 import { ExtendedDatasetFactory } from "@ldo/dataset";
 import { ProxyTransactionalDataset } from "../src";

packages/subscribable-dataset/test/WrapperSubscribableDataset.test.ts

@@ -7,8 +7,8 @@ import {
   quad,
   defaultGraph,
   blankNode,
-} from "@ldo/rdf-utils";
+} from "@rdfjs/data-model";
-import type { Quad, BlankNode } from "@ldo/rdf-utils";
+import type { Quad, BlankNode } from "@rdfjs/types";
 import testDataset from "@ldo/dataset/test/dataset.testHelper";
 
 describe("WrapperSubscribableDataset", () => {
@@ -125,6 +125,19 @@ describe("WrapperSubscribableDataset", () => {
     expect(callbackFuncTom.mock.calls[0][0].added).toBe(undefined);
   });
 
+  it("Alerts when emit is called", () => {
+    const callbackFuncTom = jest.fn();
+    subscribableDatastet.on(
+      [namedNode("http://example.org/cartoons#Tom"), null, null, null],
+      callbackFuncTom,
+    );
+    subscribableDatastet.emit(
+      [namedNode("http://example.org/cartoons#Tom"), null, null, null],
+      {},
+    );
+    expect(callbackFuncTom.mock.calls[0][0]).toEqual({});
+  });
+
   it("Alerts when bulk updated", () => {
     const callbackFuncLicky = jest.fn();
     const callbackFuncTom = jest.fn();
@@ -229,7 +242,7 @@ describe("WrapperSubscribableDataset", () => {
     expect(callbackFunc).toBeCalledTimes(1);
     expect(
       callbackFunc.mock.calls[0][0].added.equals(
-        createDataset([blankNodeQuadA, blankNodeAdditionA]),
+        createDataset([blankNodeAdditionA]),
       ),
     ).toBe(true);
   });
@@ -262,9 +275,9 @@ describe("WrapperSubscribableDataset", () => {
       ),
     ).toBe(true);
     expect(
-      subscribableTerms.some(
+      subscribableTerms.some((curQuadMatch) => {
-        (curQuadMatch) => curQuadMatch[3]?.equals(defaultGraph()),
+        return curQuadMatch[3]?.equals(defaultGraph());
-      ),
+      }),
     ).toBe(true);
   });
 
@@ -276,7 +289,7 @@ describe("WrapperSubscribableDataset", () => {
       /* Do Nothing */
     });
     expect(() => subscribableDatastet.eventNames()).toThrowError(
-      "Invalid Subscription Key",
+      "Invalid Quad Match String",
     );
   });