Laurin Weger
1 week ago
parent
43c3356942
commit
2dc6136d51
@ -1,217 +0,0 @@ |
||||
import { describe, test, expect } from "vitest"; |
||||
import { |
||||
applyDiff, |
||||
} from "@nextgraph-monorepo/ng-signals"; |
||||
import type { Patch } from "@nextgraph-monorepo/ng-signals"; |
||||
|
||||
/** |
||||
* Build a patch path string from segments (auto-prefix /) |
||||
*/ |
||||
function p(...segs: (string | number)[]) { |
||||
return "/" + segs.map(String).join("/"); |
||||
} |
||||
|
||||
describe("applyDiff - set operations (primitives)", () => { |
||||
test("add single primitive into new set", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", type: "set", path: p("tags"), value: "a" }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(state.tags).toBeInstanceOf(Set); |
||||
expect([...state.tags]).toEqual(["a"]); |
||||
}); |
||||
test("add multiple primitives into new set", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", type: "set", path: p("nums"), value: [1, 2, 3] }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect([...state.nums]).toEqual([1, 2, 3]); |
||||
}); |
||||
test("add primitives merging into existing set", () => { |
||||
const state: any = { nums: new Set([1]) }; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", type: "set", path: p("nums"), value: [2, 3] }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect([...state.nums].sort()).toEqual([1, 2, 3]); |
||||
}); |
||||
test("remove single primitive from set", () => { |
||||
const state: any = { tags: new Set(["a", "b"]) }; |
||||
const diff: Patch[] = [ |
||||
{ op: "remove", type: "set", path: p("tags"), value: "a" }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect([...state.tags]).toEqual(["b"]); |
||||
}); |
||||
test("remove multiple primitives from set", () => { |
||||
const state: any = { nums: new Set([1, 2, 3, 4]) }; |
||||
const diff: Patch[] = [ |
||||
{ op: "remove", type: "set", path: p("nums"), value: [2, 4] }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect([...state.nums].sort()).toEqual([1, 3]); |
||||
}); |
||||
}); |
||||
|
||||
describe("applyDiff - set operations (object sets)", () => { |
||||
test("add object entries to new object-set", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [ |
||||
{ |
||||
op: "add", |
||||
type: "set", |
||||
path: p("users"), |
||||
value: { u1: { id: "u1", n: 1 }, u2: { id: "u2", n: 2 } }, |
||||
}, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(state.users.u1).toEqual({ id: "u1", n: 1 }); |
||||
expect(state.users.u2).toEqual({ id: "u2", n: 2 }); |
||||
}); |
||||
test("merge object entries into existing object-set", () => { |
||||
const state: any = { users: { u1: { id: "u1", n: 1 } } }; |
||||
const diff: Patch[] = [ |
||||
{ |
||||
op: "add", |
||||
type: "set", |
||||
path: p("users"), |
||||
value: { u2: { id: "u2", n: 2 } }, |
||||
}, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(Object.keys(state.users).sort()).toEqual(["u1", "u2"]); |
||||
}); |
||||
test("remove object entries from object-set", () => { |
||||
const state: any = { users: { u1: {}, u2: {}, u3: {} } }; |
||||
const diff: Patch[] = [ |
||||
{ op: "remove", type: "set", path: p("users"), value: ["u1", "u3"] }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(Object.keys(state.users)).toEqual(["u2"]); |
||||
}); |
||||
test("adding primitives to existing object-set replaces with Set", () => { |
||||
const state: any = { mixed: { a: {}, b: {} } }; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", type: "set", path: p("mixed"), value: [1, 2] }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(state.mixed).toBeInstanceOf(Set); |
||||
expect([...state.mixed]).toEqual([1, 2]); |
||||
}); |
||||
}); |
||||
|
||||
describe("applyDiff - object & literal operations", () => { |
||||
test("add object (create empty object)", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [{ op: "add", path: p("address"), type: "object" }]; |
||||
applyDiff(state, diff); |
||||
expect(state.address).toEqual({}); |
||||
}); |
||||
test("add nested object path with ensurePathExists", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", path: p("a", "b", "c"), type: "object" }, |
||||
]; |
||||
applyDiff(state, diff, true); |
||||
expect(state.a.b.c).toEqual({}); |
||||
}); |
||||
test("add primitive value", () => { |
||||
const state: any = { address: {} }; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", path: p("address", "street"), value: "1st" }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(state.address.street).toBe("1st"); |
||||
}); |
||||
test("overwrite primitive value", () => { |
||||
const state: any = { address: { street: "old" } }; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", path: p("address", "street"), value: "new" }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(state.address.street).toBe("new"); |
||||
}); |
||||
test("remove primitive", () => { |
||||
const state: any = { address: { street: "1st", country: "Greece" } }; |
||||
const diff: Patch[] = [{ op: "remove", path: p("address", "street") }]; |
||||
applyDiff(state, diff); |
||||
expect(state.address.street).toBeUndefined(); |
||||
expect(state.address.country).toBe("Greece"); |
||||
}); |
||||
test("remove object branch", () => { |
||||
const state: any = { address: { street: "1st" }, other: 1 }; |
||||
const diff: Patch[] = [{ op: "remove", path: p("address") }]; |
||||
applyDiff(state, diff); |
||||
expect(state.address).toBeUndefined(); |
||||
expect(state.other).toBe(1); |
||||
}); |
||||
}); |
||||
|
||||
describe("applyDiff - multiple mixed patches in a single diff", () => { |
||||
test("sequence of mixed set/object/literal add & remove", () => { |
||||
const state: any = { |
||||
users: { u1: { id: "u1" } }, |
||||
tags: new Set(["old"]), |
||||
}; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", type: "set", path: p("users"), value: { u2: { id: "u2" } } }, |
||||
{ op: "add", path: p("profile"), type: "object" }, |
||||
{ op: "add", path: p("profile", "name"), value: "Alice" }, |
||||
{ op: "add", type: "set", path: p("tags"), value: ["new"] }, |
||||
{ op: "remove", type: "set", path: p("tags"), value: "old" }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(Object.keys(state.users).sort()).toEqual(["u1", "u2"]); |
||||
expect(state.profile.name).toBe("Alice"); |
||||
expect([...state.tags]).toEqual(["new"]); |
||||
}); |
||||
|
||||
test("complex nested path creation and mutations with ensurePathExists", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", path: p("a", "b"), type: "object" }, |
||||
{ op: "add", path: p("a", "b", "c"), value: 1 }, |
||||
{ op: "add", type: "set", path: p("a", "nums"), value: [1, 2, 3] }, |
||||
{ op: "remove", type: "set", path: p("a", "nums"), value: 2 }, |
||||
{ op: "add", path: p("a", "b", "d"), value: 2 }, |
||||
{ op: "remove", path: p("a", "b", "c") }, |
||||
]; |
||||
applyDiff(state, diff, true); |
||||
expect(state.a.b.c).toBeUndefined(); |
||||
expect(state.a.b.d).toBe(2); |
||||
expect(state.a.nums).toBeInstanceOf(Set); |
||||
expect([...state.a.nums].sort()).toEqual([1, 3]); |
||||
}); |
||||
}); |
||||
|
||||
describe("applyDiff - ignored / invalid scenarios", () => { |
||||
test("skip patch with non-leading slash path", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [{ op: "add", path: "address/street", value: "x" }]; |
||||
applyDiff(state, diff); |
||||
expect(state).toEqual({}); |
||||
}); |
||||
test("missing parent without ensurePathExists -> patch skipped and no mutation", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [{ op: "add", path: p("a", "b", "c"), value: 1 }]; |
||||
applyDiff(state, diff, false); |
||||
expect(state).toEqual({}); |
||||
}); |
||||
}); |
||||
|
||||
describe("applyDiff - ignored / invalid scenarios", () => { |
||||
test("skip patch with non-leading slash path", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [{ op: "add", path: "address/street", value: "x" }]; |
||||
applyDiff(state, diff); |
||||
expect(state).toEqual({}); |
||||
}); |
||||
test("missing parent without ensurePathExists -> patch skipped and no mutation", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [{ op: "add", path: p("a", "b", "c"), value: 1 }]; |
||||
applyDiff(state, diff, false); |
||||
expect(state).toEqual({}); |
||||
}); |
||||
}); |
||||
@ -1,56 +0,0 @@ |
||||
import { describe, expect, test } from "vitest"; |
||||
import { createSignalObjectForShape } from "@nextgraph-monorepo/ng-signals"; |
||||
|
||||
const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms)); |
||||
|
||||
describe("Signal modification and propagation to backend with or without signal pooling", () => { |
||||
for (const withPooling of [true, false]) { |
||||
test(`shape object notification comes back to others ${ |
||||
withPooling ? "with" : "without" |
||||
} signal pooling`, async () => {
|
||||
const object1 = createSignalObjectForShape( |
||||
"TestShape", |
||||
undefined, |
||||
withPooling |
||||
); |
||||
const object2 = createSignalObjectForShape( |
||||
"TestShape", |
||||
undefined, |
||||
withPooling |
||||
); |
||||
|
||||
const object3 = createSignalObjectForShape( |
||||
"Shape2", |
||||
undefined, |
||||
withPooling |
||||
); |
||||
const object4 = createSignalObjectForShape( |
||||
"Shape2", |
||||
undefined, |
||||
withPooling |
||||
); |
||||
|
||||
await wait(10); |
||||
|
||||
// Update object 1 and expect object 2 to update as well.
|
||||
// @ts-expect-error
|
||||
object1.name = "Updated name from object1"; |
||||
|
||||
await wait(10); |
||||
// @ts-expect-error
|
||||
expect(object2.name).toBe("Updated name from object1"); |
||||
|
||||
// Expect object of different shape not to have changed.
|
||||
// @ts-expect-error
|
||||
expect(object3.name).toBe("Niko's cat"); |
||||
|
||||
// Update object 4 and expect object 3 with same shape to have updated.
|
||||
// @ts-expect-error
|
||||
object4.name = "Updated name from object4"; |
||||
|
||||
await wait(10); |
||||
// @ts-expect-error
|
||||
expect(object3!.name).toBe("Updated name from object4"); |
||||
}); |
||||
} |
||||
}); |
||||
@ -1,147 +0,0 @@ |
||||
import type { |
||||
ShapeType, |
||||
Shape, |
||||
Predicate, |
||||
Schema, |
||||
} from "@nextgraph-monorepo/ng-shex-orm"; |
||||
|
||||
interface Triple { |
||||
s: string; |
||||
p: string; |
||||
o: string; |
||||
} |
||||
interface TrackedSubject { |
||||
shape: Shape; |
||||
parentObject?: TrackedSubject; |
||||
valid?: boolean; |
||||
trackedPredicates: Record<string, TrackedPredicate>; |
||||
/** For Sub-objects only */ |
||||
untracked?: boolean; |
||||
} |
||||
|
||||
interface TrackedPredicate { |
||||
shape: Predicate; |
||||
currentCardinality: number; |
||||
childSubjects?: TrackedSubject[]; |
||||
} |
||||
|
||||
export function buildObjects(shapeType: ShapeType<any>) { |
||||
//
|
||||
} |
||||
|
||||
export function onTriplesRemoved( |
||||
trackedSubjects: Record<string, TrackedSubject[]>, |
||||
triplesRemoved: string[][], |
||||
shapeType: ShapeType<any> |
||||
) { |
||||
//
|
||||
} |
||||
|
||||
/** |
||||
* Adds new triples to tracked subjects and creates and returns |
||||
* new tracked (possibly nested) subjects. |
||||
*/ |
||||
export function onTriplesAdded( |
||||
trackedSubjects: Record<string, TrackedSubject[]>, |
||||
triplesAdded: Triple[], |
||||
schema: Schema, |
||||
rootShape?: Shape |
||||
): { newTrackedSubjects: Record<string, TrackedSubject[]> } { |
||||
// Track for secondary iterations.
|
||||
const newTrackedSubjectsCreated: Record<string, TrackedSubject[]> = {}; |
||||
|
||||
for (const triple of triplesAdded) { |
||||
if (!trackedSubjects[triple.s]) { |
||||
// If rootShape is not set, we are applying the triples new nested objects
|
||||
// and we don't create new tracked subjects.
|
||||
if (!rootShape) continue; |
||||
|
||||
// Check if predicate is in root shape type.
|
||||
const matchedPredicate = rootShape.predicates.find((p) => triple.p); |
||||
if (!matchedPredicate) { |
||||
// Nothing to track.
|
||||
continue; |
||||
} |
||||
// The triple should be tracked. Create new tracked subject.
|
||||
const newTrackedSubject: TrackedSubject = { |
||||
shape: rootShape, |
||||
trackedPredicates: { |
||||
[triple.p]: { |
||||
shape: matchedPredicate, |
||||
currentCardinality: 1, |
||||
}, |
||||
}, |
||||
}; |
||||
trackedSubjects[triple.s] = [newTrackedSubject]; |
||||
} else { |
||||
// Add triple to tracked subject(s).
|
||||
// In the case of nested shapes, the same subject can be tracked
|
||||
// in multiple shapes.
|
||||
const trackedSubjectsMatching = trackedSubjects[triple.s]; |
||||
for (const trackedSubject of trackedSubjectsMatching) { |
||||
// Is predicate tracked in this subject's shape?
|
||||
const matchedPredShape = trackedSubject.shape.predicates.find( |
||||
(predShape) => predShape.iri === triple.p |
||||
); |
||||
if (!matchedPredShape) continue; |
||||
// Get or create tracked predicate for tracked shape.
|
||||
let trackedPredicate = |
||||
trackedSubject.trackedPredicates[matchedPredShape?.iri]; |
||||
if (!trackedSubjects) { |
||||
trackedPredicate = { |
||||
currentCardinality: 0, |
||||
shape: matchedPredShape, |
||||
}; |
||||
} |
||||
// Increase cardinality.
|
||||
trackedPredicate.currentCardinality += 1; |
||||
|
||||
// If predicate shape has nested object, track that too.
|
||||
if (trackedPredicate.shape.nestedShape) { |
||||
const newTrackedObject: TrackedSubject = { |
||||
shape: schema[matchedPredShape.nestedShape as string], |
||||
trackedPredicates: {}, |
||||
parentObject: trackedSubject, |
||||
}; |
||||
// Remember for adding to registry and for re-running on nested shapes.
|
||||
const newTracked = newTrackedSubjectsCreated[triple.o]; |
||||
if (!newTracked) |
||||
newTrackedSubjectsCreated[triple.o] = [ |
||||
newTrackedObject, |
||||
]; |
||||
newTracked.push(newTrackedObject); |
||||
|
||||
// Link to parent
|
||||
const childSubjects = trackedPredicate.childSubjects; |
||||
if (childSubjects) childSubjects.push(newTrackedObject); |
||||
else trackedPredicate.childSubjects = [newTrackedObject]; |
||||
} |
||||
|
||||
// TODO: Inform tracked subjects about change
|
||||
} |
||||
} |
||||
} |
||||
|
||||
// Rerun triples on new tracked subjects created.
|
||||
// Then merge with parent tracked subjects
|
||||
const newNestedSubjectsCreated = onTriplesAdded( |
||||
newTrackedSubjectsCreated, |
||||
triplesAdded, |
||||
schema |
||||
); |
||||
|
||||
// TODO: Is it correct to do this?
|
||||
const ret: Record<string, TrackedSubject[]> = {}; |
||||
for (const subjectIri of Object.keys(newTrackedSubjectsCreated)) { |
||||
ret[subjectIri] = [ |
||||
...newTrackedSubjectsCreated[subjectIri], |
||||
...newNestedSubjectsCreated.newTrackedSubjects[subjectIri], |
||||
]; |
||||
} |
||||
|
||||
// Update Valid invalid
|
||||
|
||||
return { newTrackedSubjects: ret }; |
||||
} |
||||
|
||||
// Do we have infinite-loop issues?
|
||||
@ -1,172 +0,0 @@ |
||||
import * as shapeManager from "./shapeManager"; |
||||
import type { WasmConnection, Diff, Scope } from "./types"; |
||||
import type { ShapeType, BaseType } from "@nextgraph-monorepo/ng-shex-orm"; |
||||
import * as ng from "@nextgraph-monorepo/ng-sdk-js"; |
||||
import type { Person } from "../../shapes/ldo/personShape.typings"; |
||||
import type { Cat } from "../../shapes/ldo/catShape.typings"; |
||||
import type { TestObject } from "../../shapes/ldo/testShape.typings"; |
||||
import updateShape from "./updateShape"; |
||||
import { testShapeSchema } from "../../shapes/ldo/testShape.schema"; |
||||
import { TestObjectShapeType } from "../../shapes/ldo/testShape.shapeTypes"; |
||||
|
||||
// Messages exchanged over the BroadcastChannel("shape-manager")
|
||||
interface WasmMessage { |
||||
type: |
||||
| "Request" |
||||
| "InitialResponse" |
||||
| "FrontendUpdate" |
||||
| "BackendUpdate" |
||||
| "Stop"; |
||||
connectionId: string; |
||||
diff?: Diff; |
||||
shapeType?: ShapeType<any>; |
||||
initialData?: BaseType; |
||||
} |
||||
|
||||
export const mockTestObject = { |
||||
id: "ex:mock-id-1", |
||||
type: "TestObject", |
||||
stringValue: "string", |
||||
numValue: 42, |
||||
boolValue: true, |
||||
arrayValue: [1, 2, 3], |
||||
objectValue: { |
||||
id: "urn:obj-1", |
||||
nestedString: "nested", |
||||
nestedNum: 7, |
||||
|
||||
nestedArray: [10, 12], |
||||
}, |
||||
anotherObject: { |
||||
"id:1": { |
||||
id: "id:1", |
||||
prop1: "prop1 value", |
||||
prop2: 100, |
||||
}, |
||||
"id:2": { |
||||
id: "id:1", |
||||
prop1: "prop2 value", |
||||
prop2: 200, |
||||
}, |
||||
}, |
||||
} satisfies TestObject; |
||||
|
||||
const mockShapeObject1 = { |
||||
id: "ex:person-1", |
||||
type: "Person", |
||||
name: "Bob", |
||||
address: { |
||||
id: "urn:person-home-1", |
||||
street: "First street", |
||||
houseNumber: "15", |
||||
}, |
||||
hasChildren: true, |
||||
numberOfHouses: 0, |
||||
} satisfies Person; |
||||
|
||||
const mockShapeObject2 = { |
||||
id: "ex:cat-1", |
||||
type: "Cat", |
||||
name: "Niko's cat", |
||||
age: 12, |
||||
numberOfHomes: 3, |
||||
address: { |
||||
id: "Nikos-cat-home", |
||||
street: "Niko's street", |
||||
houseNumber: "15", |
||||
floor: 0, |
||||
}, |
||||
} satisfies Cat; |
||||
|
||||
// Single BroadcastChannel for wasm-land side
|
||||
const communicationChannel = new BroadcastChannel("shape-manager"); |
||||
|
||||
function getInitialObjectByShapeId<T extends BaseType>(shapeId?: string): T { |
||||
if (shapeId?.includes("TestObject")) return mockTestObject as unknown as T; |
||||
if (shapeId?.includes("Person")) return mockShapeObject1 as unknown as T; |
||||
if (shapeId?.includes("Cat")) return mockShapeObject2 as unknown as T; |
||||
console.warn( |
||||
"BACKEND: requestShape for unknown shape, returning empty object.", |
||||
shapeId |
||||
); |
||||
return {} as T; |
||||
} |
||||
|
||||
// Register handler for messages coming from js-land
|
||||
communicationChannel.addEventListener( |
||||
"message", |
||||
(event: MessageEvent<WasmMessage>) => { |
||||
console.log("BACKEND: Received message", event.data); |
||||
// call WASM ng-sdk-js
|
||||
const { type, connectionId, shapeType } = event.data; |
||||
|
||||
if (type === "Request") { |
||||
ng.orm_update("", "", {}, 1); |
||||
/* unsub = await ng.orm_start(scope, shapeType, session_id, |
||||
async (response) => { |
||||
//console.log("GOT APP RESPONSE", response);
|
||||
if (response.V0.OrmInitial) {
|
||||
|
||||
} else if (response.V0.OrmUpdate) { |
||||
let diff = response.V0.OrmUpdate.diff |
||||
const msg: WasmMessage = { |
||||
type: "BackendUpdate", |
||||
connectionId, |
||||
diff, |
||||
}; |
||||
communicationChannel.postMessage(msg); |
||||
} else if (response.V0.OrmError) { |
||||
|
||||
}
|
||||
*/ |
||||
|
||||
const shapeId = shapeType?.shape; |
||||
const initialData = getInitialObjectByShapeId(shapeId); |
||||
|
||||
// Store connection. We store the shapeId string to allow equality across connections.
|
||||
shapeManager.connections.set(connectionId, { |
||||
id: connectionId, |
||||
// Cast to any to satisfy WasmConnection type, comparison in updateShape uses ==
|
||||
shape: (shapeId ?? "__unknown__") as any, |
||||
state: initialData, |
||||
callback: (diff: Diff, conId: WasmConnection["id"]) => { |
||||
// Notify js-land about backend updates
|
||||
const msg: WasmMessage = { |
||||
type: "BackendUpdate", |
||||
connectionId, |
||||
diff, |
||||
}; |
||||
communicationChannel.postMessage(msg); |
||||
}, |
||||
}); |
||||
|
||||
const msg: WasmMessage = { |
||||
type: "InitialResponse", |
||||
connectionId, |
||||
initialData, |
||||
}; |
||||
communicationChannel.postMessage(msg); |
||||
return; |
||||
} |
||||
|
||||
if (type === "Stop") { |
||||
shapeManager.connections.delete(connectionId); |
||||
// await ng.app_request ( OrmStop )
|
||||
return; |
||||
} |
||||
|
||||
if (type === "FrontendUpdate" && event.data.diff) { |
||||
updateShape(connectionId, event.data.diff); |
||||
return; |
||||
} |
||||
|
||||
console.warn( |
||||
"BACKEND: Unknown message type or missing diff", |
||||
event.data |
||||
); |
||||
} |
||||
); |
||||
|
||||
ng.orm_start("", TestObjectShapeType, 12, (...params: any) => { |
||||
console.log("updates received with params", params); |
||||
}).catch((err) => console.error(err)); |
||||
@ -1,10 +0,0 @@ |
||||
import type { Diff, ObjectState, WasmConnection } from "./types"; |
||||
|
||||
const connections: Map<WasmConnection["id"], WasmConnection> = new Map(); |
||||
|
||||
/** Mock function to apply diffs. Just uses a copy of the diff as the new object. */ |
||||
export function applyDiff(currentState: ObjectState, diff: Diff): ObjectState { |
||||
return JSON.parse(JSON.stringify(diff)); |
||||
} |
||||
|
||||
export { connections }; |
||||
@ -1,220 +0,0 @@ |
||||
import type { Predicate, Shape, Schema } from "@nextgraph-monorepo/ng-shex-orm"; |
||||
|
||||
/** |
||||
* Build a SPARQL CONSTRUCT query from a ShapeConstraint definition. |
||||
* The WHERE mirrors the graph template. Optional predicates (min=0) are wrapped in OPTIONAL in WHERE |
||||
* but still appear in the CONSTRUCT template so that matched triples are constructed. |
||||
*/ |
||||
export function buildConstructQuery( |
||||
shape: Shape, |
||||
schema: Schema, |
||||
options?: SparqlBuildOptions |
||||
): string { |
||||
const ctx: BuildContext = { usedVars: new Set<string>() }; |
||||
const prefixes = prefixesToText(options?.prefixes); |
||||
const subject = shape.iri; |
||||
|
||||
const templateLines: string[] = []; |
||||
const whereLines: string[] = []; |
||||
const postFilters: string[] = []; |
||||
const valuesBlocks: string[] = []; |
||||
|
||||
const rootVar = |
||||
subject.startsWith("?") || subject.startsWith("$") |
||||
? subject |
||||
: uniqueVar(ctx, "s"); |
||||
if (!subject.startsWith("?") && !subject.startsWith("$")) { |
||||
valuesBlocks.push(valuesBlock(rootVar, [subject] as any)); |
||||
} |
||||
|
||||
const predicates = Array.isArray(shape.predicates) |
||||
? shape.predicates |
||||
: [...shape.predicates]; |
||||
for (const pred of predicates) { |
||||
addConstructPattern( |
||||
ctx, |
||||
pred, |
||||
rootVar, |
||||
templateLines, |
||||
whereLines, |
||||
postFilters, |
||||
valuesBlocks, |
||||
options |
||||
); |
||||
} |
||||
|
||||
const graphWrap = (body: string) => |
||||
options?.graph |
||||
? `GRAPH ${toIriOrCurie(options.graph)} {\n${body}\n}` |
||||
: body; |
||||
|
||||
const where = [ |
||||
...valuesBlocks, |
||||
graphWrap(whereLines.join("\n")), |
||||
...postFilters, |
||||
] |
||||
.filter(Boolean) |
||||
.join("\n"); |
||||
|
||||
const template = templateLines.join("\n"); |
||||
|
||||
return [prefixes, `CONSTRUCT {`, template, `} WHERE {`, where, `}`].join( |
||||
"\n" |
||||
); |
||||
} |
||||
|
||||
function addConstructPattern( |
||||
ctx: BuildContext, |
||||
pred: Predicate, |
||||
subjectVar: string, |
||||
template: string[], |
||||
where: string[], |
||||
postFilters: string[], |
||||
valuesBlocks: string[], |
||||
options?: SparqlBuildOptions |
||||
) { |
||||
const p = `<${pred.iri}>`; |
||||
const objVar = uniqueVar(ctx, pred.readablePredicate); |
||||
|
||||
const triple = `${subjectVar} ${p} ${objTerm} .`; |
||||
|
||||
const isOptional = |
||||
(pred.minCardinality ?? 0) === 0 && |
||||
(options?.includeOptionalForMinZero ?? true); |
||||
|
||||
if (pred.dataTypes === "nested" && pred.nestedShape) { |
||||
template.push(triple); |
||||
const nestedBody: string[] = [triple]; |
||||
const nestedPreds = pred.nestedShape.predicates; |
||||
|
||||
for (const n of nestedPreds) { |
||||
addConstructPattern( |
||||
ctx, |
||||
n, |
||||
objTerm, |
||||
template, |
||||
nestedBody, |
||||
postFilters, |
||||
valuesBlocks, |
||||
options |
||||
); |
||||
} |
||||
const block = nestedBody.join("\n"); |
||||
where.push(isOptional ? `OPTIONAL {\n${block}\n}` : block); |
||||
return; |
||||
} |
||||
|
||||
// Non-nested
|
||||
template.push(triple); |
||||
const blockLines: string[] = [triple]; |
||||
|
||||
if (pred.dataTypes === "literal" && pred.literalValue !== undefined) { |
||||
if (Array.isArray(pred.literalValue)) { |
||||
valuesBlocks.push(valuesBlock(objVar, pred.literalValue as any[])); |
||||
} else { |
||||
const lit = |
||||
typeof pred.literalValue === "string" || |
||||
typeof pred.literalValue === "number" || |
||||
typeof pred.literalValue === "boolean" |
||||
? pred.literalValue |
||||
: String(pred.literalValue); |
||||
postFilters.push( |
||||
`FILTER(${objVar} = ${typeof lit === "string" ? `"${String(lit).replace(/"/g, '\\"')}"` : lit})` |
||||
); |
||||
} |
||||
} |
||||
|
||||
const block = blockLines.join("\n"); |
||||
where.push(isOptional ? `OPTIONAL {\n${block}\n}` : block); |
||||
} |
||||
|
||||
export type LiteralKind = |
||||
| "number" |
||||
| "string" |
||||
| "boolean" |
||||
| "nested" |
||||
| "literal"; |
||||
|
||||
export interface SparqlBuildOptions { |
||||
prefixes?: Record<string, string>; |
||||
graph?: string; // IRI of the named graph to query, if any
|
||||
includeOptionalForMinZero?: boolean; // default true
|
||||
} |
||||
|
||||
export const defaultPrefixes: Record<string, string> = { |
||||
xsd: "http://www.w3.org/2001/XMLSchema#", |
||||
rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#", |
||||
rdfs: "http://www.w3.org/2000/01/rdf-schema#", |
||||
}; |
||||
|
||||
export function prefixesToText(prefixes?: Record<string, string>): string { |
||||
const all = { ...defaultPrefixes, ...(prefixes ?? {}) }; |
||||
return Object.entries(all) |
||||
.map(([p, iri]) => `PREFIX ${p}: <${iri}>`) |
||||
.join("\n"); |
||||
} |
||||
|
||||
export function safeVarName(name: string): string { |
||||
const base = name |
||||
.replace(/[^a-zA-Z0-9_]/g, "_") |
||||
.replace(/^([0-9])/, "_$1") |
||||
.slice(0, 60); |
||||
return base || "v"; |
||||
} |
||||
|
||||
export function varToken(name: string): string { |
||||
const n = |
||||
name.startsWith("?") || name.startsWith("$") ? name.slice(1) : name; |
||||
return `?${safeVarName(n)}`; |
||||
} |
||||
|
||||
export function formatLiteral(value: string | number | boolean): string { |
||||
if (typeof value === "number") return String(value); |
||||
if (typeof value === "boolean") return value ? "true" : "false"; |
||||
// default string literal
|
||||
const escaped = value.replace(/"/g, '\\"'); |
||||
return `"${escaped}"`; |
||||
} |
||||
|
||||
export function formatTermForValues(value: string | number | boolean): string { |
||||
if (typeof value === "number" || typeof value === "boolean") |
||||
return formatLiteral(value); |
||||
// strings: detect IRI or CURIE and keep raw; otherwise quote
|
||||
const v = value.trim(); |
||||
const looksLikeIri = v.startsWith("<") && v.endsWith(">"); |
||||
const looksLikeHttp = v.includes("://"); |
||||
const looksLikeCurie = |
||||
/^[A-Za-z_][A-Za-z0-9_-]*:.+$/u.test(v) && !looksLikeHttp; |
||||
if (looksLikeIri || looksLikeHttp || looksLikeCurie) { |
||||
return looksLikeHttp ? `<${v}>` : v; |
||||
} |
||||
return formatLiteral(v); |
||||
} |
||||
|
||||
export function valuesBlock( |
||||
varName: string, |
||||
values: Array<string | number | boolean> |
||||
): string { |
||||
const rendered = values.map(formatTermForValues).join(" "); |
||||
return `VALUES ${varName} { ${rendered} }`; |
||||
} |
||||
|
||||
export interface BuildContext { |
||||
// Tracks used variable names to avoid collisions
|
||||
usedVars: Set<string>; |
||||
} |
||||
|
||||
export function uniqueVar(ctx: BuildContext, base: string): string { |
||||
let candidate = varToken(base); |
||||
if (!ctx.usedVars.has(candidate)) { |
||||
ctx.usedVars.add(candidate); |
||||
return candidate; |
||||
} |
||||
let i = 2; |
||||
while (ctx.usedVars.has(`${candidate}_${i}`)) i++; |
||||
const unique = `${candidate}_${i}`; |
||||
ctx.usedVars.add(unique); |
||||
return unique; |
||||
} |
||||
|
||||
export default buildConstructQuery; |
||||
@ -1,140 +0,0 @@ |
||||
import type { Predicate, Shape, Schema } from "@nextgraph-monorepo/ng-shex-orm"; |
||||
|
||||
export const buildConstructQuery = ({ |
||||
schema, |
||||
shapeId, |
||||
}: { |
||||
schema: Schema; |
||||
shapeId: keyof Schema; |
||||
}): string => { |
||||
const rootShape = schema[shapeId]; |
||||
|
||||
const constructStatements: { |
||||
s: string; |
||||
p: string; |
||||
o: string; |
||||
optional: boolean; |
||||
literals: Predicate["literalValue"]; |
||||
}[] = []; |
||||
|
||||
const idToVarName: Record<string, string> = {}; |
||||
const getVarNameFor = (id: string) => { |
||||
const currentName = idToVarName[id]; |
||||
if (currentName) return currentName; |
||||
|
||||
const newVar = `o${Object.entries(idToVarName).length + 1}`; |
||||
idToVarName[id] = newVar; |
||||
return newVar; |
||||
}; |
||||
|
||||
// Create s,p,o records where subject and object var names are mapped to shape or predicate ids.
|
||||
const addTriples = (shape: Shape) => { |
||||
const predicates = shape.predicates; |
||||
const shapeId = shape.iri; |
||||
|
||||
for (const pred of predicates) { |
||||
const subjectVarName = getVarNameFor(shapeId); |
||||
|
||||
if (pred.dataTypes === "nested") { |
||||
if (typeof pred.nestedShape !== "string") |
||||
throw new Error("Nested shapes must be by reference"); |
||||
|
||||
// If a name for this shape was assigned already, it's triples have been added
|
||||
// and we don't have to recurse.
|
||||
const shapeAlreadyRegistered = !!idToVarName[pred.nestedShape]; |
||||
|
||||
const shapeVarName = getVarNameFor(pred.nestedShape); |
||||
|
||||
constructStatements.push({ |
||||
s: `?${subjectVarName}`, |
||||
p: `<${pred.iri}>`, |
||||
o: `?${shapeVarName}`, |
||||
optional: pred.minCardinality < 1, |
||||
literals: pred.literalValue, |
||||
// TODO: eitherOf ?
|
||||
}); |
||||
|
||||
if (!shapeAlreadyRegistered) |
||||
addTriples(schema[pred.nestedShape]); |
||||
} else { |
||||
const objVarName = getVarNameFor( |
||||
shapeId + "__separator__" + pred.iri |
||||
); |
||||
|
||||
constructStatements.push({ |
||||
s: `?${subjectVarName}`, |
||||
p: `<${pred.iri}>`, |
||||
o: `?${objVarName}`, |
||||
optional: pred.minCardinality < 1, |
||||
literals: pred.literalValue, |
||||
// TODO: eitherOf ?
|
||||
}); |
||||
} |
||||
} |
||||
}; |
||||
|
||||
addTriples(rootShape); |
||||
|
||||
const construct = `CONSTRUCT {
|
||||
${constructStatements.map(({ s, p, o }) => ` ${s} ${p} ${o} .\n`).join("")} }`;
|
||||
|
||||
const statementToWhere = ({ |
||||
s, |
||||
p, |
||||
o, |
||||
optional, |
||||
}: { |
||||
s: string; |
||||
p: string; |
||||
o: string; |
||||
optional: boolean; |
||||
}) => { |
||||
if (optional) return ` OPTIONAL { ${s} ${p} ${o} . }\n`; |
||||
else return ` ${s} ${p} ${o} .\n`; |
||||
}; |
||||
|
||||
const literalToSparqlFormat = ( |
||||
literal: string | number | boolean |
||||
): string => { |
||||
if (typeof literal === "number") return String(literal); |
||||
if (typeof literal === "boolean") return literal ? "true" : "false"; |
||||
if (typeof literal === "string") { |
||||
return isIri(literal) |
||||
? `<${literal}>` |
||||
: `"${escapeString(literal)}"`; |
||||
} |
||||
return `"${String(literal)}"`; |
||||
}; |
||||
|
||||
// Filters for optional values.
|
||||
const filters = constructStatements |
||||
.filter((statement) => statement.literals !== undefined) |
||||
.map((statement) => { |
||||
const vals = arrayOf(statement.literals!); |
||||
if (vals.length === 0) return ""; |
||||
if (vals.length === 1) { |
||||
return ` FILTER(${statement.o} = ${literalToSparqlFormat(vals[0]!)})\n`; |
||||
} |
||||
const list = vals.map(literalToSparqlFormat).join(", "); |
||||
return ` FILTER(${statement.o} IN (${list}))\n`; |
||||
}) |
||||
.join(""); |
||||
|
||||
const where = `WHERE {
|
||||
${constructStatements.map(statementToWhere).join("")} |
||||
${filters} |
||||
}`;
|
||||
|
||||
return `${construct}\n${where}`; |
||||
}; |
||||
|
||||
const arrayOf = <T extends any>(arrayOrLiteral: T | T[]) => { |
||||
if (typeof arrayOrLiteral === "undefined" || arrayOrLiteral === null) |
||||
return []; |
||||
if (Array.isArray(arrayOrLiteral)) return arrayOrLiteral; |
||||
return [arrayOrLiteral]; |
||||
}; |
||||
|
||||
const isIri = (str: string) => /^[a-zA-Z][a-zA-Z0-9+.-]{1,7}:/.test(str); |
||||
|
||||
const escapeString = (str: string) => str.replace(/["\\]/g, "\\$&"); |
||||
@ -1,9 +0,0 @@ |
||||
import { buildConstructQuery } from "./buildSparqlConstructFromShape.ts"; |
||||
import { testShapeSchema } from "./testShape.schema.ts"; |
||||
|
||||
console.log( |
||||
buildConstructQuery({ |
||||
schema: testShapeSchema, |
||||
shapeId: "http://example.org/TestObject", |
||||
}) |
||||
); |
||||
@ -1,129 +0,0 @@ |
||||
import type { Schema } from "@nextgraph-monorepo/ng-shex-orm"; |
||||
|
||||
/** |
||||
* ============================================================================= |
||||
* testShapeSchema: Schema for testShape |
||||
* ============================================================================= |
||||
*/ |
||||
export const testShapeSchema: Schema = { |
||||
"http://example.org/TestObject": { |
||||
iri: "http://example.org/TestObject", |
||||
predicates: [ |
||||
{ |
||||
dataTypes: "literal", |
||||
literalValue: ["TestObject"], |
||||
maxCardinality: 1, |
||||
minCardinality: 1, |
||||
iri: "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", |
||||
readablePredicate: "type", |
||||
extra: true, |
||||
}, |
||||
{ |
||||
dataTypes: "string", |
||||
maxCardinality: 1, |
||||
minCardinality: 1, |
||||
iri: "http://example.org/stringValue", |
||||
readablePredicate: "stringValue", |
||||
}, |
||||
{ |
||||
dataTypes: "number", |
||||
maxCardinality: 1, |
||||
minCardinality: 1, |
||||
iri: "http://example.org/numValue", |
||||
readablePredicate: "numValue", |
||||
}, |
||||
{ |
||||
dataTypes: "boolean", |
||||
maxCardinality: 1, |
||||
minCardinality: 1, |
||||
iri: "http://example.org/boolValue", |
||||
readablePredicate: "boolValue", |
||||
}, |
||||
{ |
||||
dataTypes: "number", |
||||
maxCardinality: -1, |
||||
minCardinality: 0, |
||||
iri: "http://example.org/arrayValue", |
||||
readablePredicate: "arrayValue", |
||||
}, |
||||
{ |
||||
dataTypes: "nested", |
||||
nestedShape: |
||||
"http://example.org/TestObject||http://example.org/objectValue", |
||||
maxCardinality: 1, |
||||
minCardinality: 1, |
||||
iri: "http://example.org/objectValue", |
||||
readablePredicate: "objectValue", |
||||
}, |
||||
{ |
||||
dataTypes: "nested", |
||||
nestedShape: |
||||
"http://example.org/TestObject||http://example.org/anotherObject", |
||||
maxCardinality: -1, |
||||
minCardinality: 0, |
||||
iri: "http://example.org/anotherObject", |
||||
readablePredicate: "anotherObject", |
||||
}, |
||||
{ |
||||
dataTypes: "eitherOf", |
||||
eitherOf: [ |
||||
{ |
||||
valType: "string", |
||||
}, |
||||
{ |
||||
valType: "number", |
||||
}, |
||||
], |
||||
maxCardinality: 1, |
||||
minCardinality: 1, |
||||
iri: "http://example.org/numOrStr", |
||||
readablePredicate: "numOrStr", |
||||
}, |
||||
], |
||||
}, |
||||
"http://example.org/TestObject||http://example.org/objectValue": { |
||||
iri: "http://example.org/TestObject||http://example.org/objectValue", |
||||
predicates: [ |
||||
{ |
||||
dataTypes: "string", |
||||
maxCardinality: 1, |
||||
minCardinality: 1, |
||||
iri: "http://example.org/nestedString", |
||||
readablePredicate: "nestedString", |
||||
}, |
||||
{ |
||||
dataTypes: "number", |
||||
maxCardinality: 1, |
||||
minCardinality: 1, |
||||
iri: "http://example.org/nestedNum", |
||||
readablePredicate: "nestedNum", |
||||
}, |
||||
{ |
||||
dataTypes: "number", |
||||
maxCardinality: -1, |
||||
minCardinality: 0, |
||||
iri: "http://example.org/nestedArray", |
||||
readablePredicate: "nestedArray", |
||||
}, |
||||
], |
||||
}, |
||||
"http://example.org/TestObject||http://example.org/anotherObject": { |
||||
iri: "http://example.org/TestObject||http://example.org/anotherObject", |
||||
predicates: [ |
||||
{ |
||||
dataTypes: "string", |
||||
maxCardinality: 1, |
||||
minCardinality: 1, |
||||
iri: "http://example.org/prop1", |
||||
readablePredicate: "prop1", |
||||
}, |
||||
{ |
||||
dataTypes: "number", |
||||
maxCardinality: 1, |
||||
minCardinality: 1, |
||||
iri: "http://example.org/prop2", |
||||
readablePredicate: "prop2", |
||||
}, |
||||
], |
||||
}, |
||||
}; |
||||
@ -1,18 +0,0 @@ |
||||
import type { ShapeType, BaseType } from "@nextgraph-monorepo/ng-shex-orm"; |
||||
import type { Patch } from "@nextgraph-monorepo/ng-signals"; |
||||
|
||||
/** The Scope of a shape request */ |
||||
export type Scope = string | string[]; |
||||
|
||||
/** The diff format used to communicate updates between wasm-land and js-land. */ |
||||
export type Diff = Patch[]; |
||||
|
||||
export type ObjectState = object; |
||||
|
||||
/** A connection established between wasm-land and js-land for subscription of a shape. */ |
||||
export type WasmConnection<T extends BaseType = BaseType> = { |
||||
id: string; |
||||
shape: ShapeType<T>; |
||||
state: ObjectState; |
||||
callback: (diff: Diff, connectionId: WasmConnection["id"]) => void; |
||||
}; |
||||
@ -1,22 +0,0 @@ |
||||
import * as shapeManager from "./shapeManager"; |
||||
import type { WasmConnection, Diff } from "./types"; |
||||
|
||||
export default async function updateShape( |
||||
connectionId: WasmConnection["id"], |
||||
diff: Diff, |
||||
) { |
||||
const connection = shapeManager.connections.get(connectionId); |
||||
if (!connection) throw new Error("No Connection found."); |
||||
|
||||
console.log("BACKEND: Received update request from ", connectionId); |
||||
|
||||
const newState = shapeManager.applyDiff(connection.state, diff); |
||||
connection.state = newState; |
||||
|
||||
shapeManager.connections.forEach((con) => { |
||||
// if (con.shape == connection.shape) {
|
||||
// con.state = newState;
|
||||
// con.callback(diff, con.id);
|
||||
// }
|
||||
}); |
||||
} |
||||
@ -0,0 +1,235 @@ |
||||
import { describe, test, expect } from "vitest"; |
||||
import { applyDiff, Patch } from "../index.ts"; |
||||
|
||||
/** |
||||
* Build a patch path string from segments (auto-prefix /) |
||||
*/ |
||||
function p(...segs: (string | number)[]) { |
||||
return "/" + segs.map(String).join("/"); |
||||
} |
||||
|
||||
describe("applyDiff - set operations (primitives)", () => { |
||||
test("add single primitive into new set", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", valType: "set", path: p("tags"), value: "a" }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(state.tags).toBeInstanceOf(Set); |
||||
expect([...state.tags]).toEqual(["a"]); |
||||
}); |
||||
test("add multiple primitives into new set", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", valType: "set", path: p("nums"), value: [1, 2, 3] }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect([...state.nums]).toEqual([1, 2, 3]); |
||||
}); |
||||
test("add primitives merging into existing set", () => { |
||||
const state: any = { nums: new Set([1]) }; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", valType: "set", path: p("nums"), value: [2, 3] }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect([...state.nums].sort()).toEqual([1, 2, 3]); |
||||
}); |
||||
test("remove single primitive from set", () => { |
||||
const state: any = { tags: new Set(["a", "b"]) }; |
||||
const diff: Patch[] = [ |
||||
{ op: "remove", valType: "set", path: p("tags"), value: "a" }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect([...state.tags]).toEqual(["b"]); |
||||
}); |
||||
test("remove multiple primitives from set", () => { |
||||
const state: any = { nums: new Set([1, 2, 3, 4]) }; |
||||
const diff: Patch[] = [ |
||||
{ op: "remove", valType: "set", path: p("nums"), value: [2, 4] }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect([...state.nums].sort()).toEqual([1, 3]); |
||||
}); |
||||
}); |
||||
|
||||
describe("applyDiff - set operations (object sets)", () => { |
||||
test("add object entries to new object-set", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [ |
||||
{ |
||||
op: "add", |
||||
valType: "set", |
||||
path: p("users"), |
||||
value: { u1: { id: "u1", n: 1 }, u2: { id: "u2", n: 2 } }, |
||||
}, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(state.users.u1).toEqual({ id: "u1", n: 1 }); |
||||
expect(state.users.u2).toEqual({ id: "u2", n: 2 }); |
||||
}); |
||||
test("merge object entries into existing object-set", () => { |
||||
const state: any = { users: { u1: { id: "u1", n: 1 } } }; |
||||
const diff: Patch[] = [ |
||||
{ |
||||
op: "add", |
||||
valType: "set", |
||||
path: p("users"), |
||||
value: { u2: { id: "u2", n: 2 } }, |
||||
}, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(Object.keys(state.users).sort()).toEqual(["u1", "u2"]); |
||||
}); |
||||
test("remove object entries from object-set", () => { |
||||
const state: any = { users: { u1: {}, u2: {}, u3: {} } }; |
||||
const diff: Patch[] = [ |
||||
{ |
||||
op: "remove", |
||||
valType: "set", |
||||
path: p("users"), |
||||
value: ["u1", "u3"], |
||||
}, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(Object.keys(state.users)).toEqual(["u2"]); |
||||
}); |
||||
test("adding primitives to existing object-set replaces with Set", () => { |
||||
const state: any = { mixed: { a: {}, b: {} } }; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", valType: "set", path: p("mixed"), value: [1, 2] }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(state.mixed).toBeInstanceOf(Set); |
||||
expect([...state.mixed]).toEqual([1, 2]); |
||||
}); |
||||
}); |
||||
|
||||
describe("applyDiff - object & literal operations", () => { |
||||
test("add object (create empty object)", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", path: p("address"), valType: "object" }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(state.address).toEqual({}); |
||||
}); |
||||
test("add nested object path with ensurePathExists", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", path: p("a", "b", "c"), valType: "object" }, |
||||
]; |
||||
applyDiff(state, diff, true); |
||||
expect(state.a.b.c).toEqual({}); |
||||
}); |
||||
test("add primitive value", () => { |
||||
const state: any = { address: {} }; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", path: p("address", "street"), value: "1st" }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(state.address.street).toBe("1st"); |
||||
}); |
||||
test("overwrite primitive value", () => { |
||||
const state: any = { address: { street: "old" } }; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", path: p("address", "street"), value: "new" }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(state.address.street).toBe("new"); |
||||
}); |
||||
test("remove primitive", () => { |
||||
const state: any = { address: { street: "1st", country: "Greece" } }; |
||||
const diff: Patch[] = [{ op: "remove", path: p("address", "street") }]; |
||||
applyDiff(state, diff); |
||||
expect(state.address.street).toBeUndefined(); |
||||
expect(state.address.country).toBe("Greece"); |
||||
}); |
||||
test("remove object branch", () => { |
||||
const state: any = { address: { street: "1st" }, other: 1 }; |
||||
const diff: Patch[] = [{ op: "remove", path: p("address") }]; |
||||
applyDiff(state, diff); |
||||
expect(state.address).toBeUndefined(); |
||||
expect(state.other).toBe(1); |
||||
}); |
||||
}); |
||||
|
||||
describe("applyDiff - multiple mixed patches in a single diff", () => { |
||||
test("sequence of mixed set/object/literal add & remove", () => { |
||||
const state: any = { |
||||
users: { u1: { id: "u1" } }, |
||||
tags: new Set(["old"]), |
||||
}; |
||||
const diff: Patch[] = [ |
||||
{ |
||||
op: "add", |
||||
valType: "set", |
||||
path: p("users"), |
||||
value: { u2: { id: "u2" } }, |
||||
}, |
||||
{ op: "add", path: p("profile"), valType: "object" }, |
||||
{ op: "add", path: p("profile", "name"), value: "Alice" }, |
||||
{ op: "add", valType: "set", path: p("tags"), value: ["new"] }, |
||||
{ op: "remove", valType: "set", path: p("tags"), value: "old" }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(Object.keys(state.users).sort()).toEqual(["u1", "u2"]); |
||||
expect(state.profile.name).toBe("Alice"); |
||||
expect([...state.tags]).toEqual(["new"]); |
||||
}); |
||||
|
||||
test("complex nested path creation and mutations with ensurePathExists", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", path: p("a", "b"), valType: "object" }, |
||||
{ op: "add", path: p("a", "b", "c"), value: 1 }, |
||||
{ |
||||
op: "add", |
||||
valType: "set", |
||||
path: p("a", "nums"), |
||||
value: [1, 2, 3], |
||||
}, |
||||
{ op: "remove", valType: "set", path: p("a", "nums"), value: 2 }, |
||||
{ op: "add", path: p("a", "b", "d"), value: 2 }, |
||||
{ op: "remove", path: p("a", "b", "c") }, |
||||
]; |
||||
applyDiff(state, diff, true); |
||||
expect(state.a.b.c).toBeUndefined(); |
||||
expect(state.a.b.d).toBe(2); |
||||
expect(state.a.nums).toBeInstanceOf(Set); |
||||
expect([...state.a.nums].sort()).toEqual([1, 3]); |
||||
}); |
||||
}); |
||||
|
||||
describe("applyDiff - ignored / invalid scenarios", () => { |
||||
test("skip patch with non-leading slash path", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", path: "address/street", value: "x" }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(state).toEqual({}); |
||||
}); |
||||
test("missing parent without ensurePathExists -> patch skipped and no mutation", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [{ op: "add", path: p("a", "b", "c"), value: 1 }]; |
||||
applyDiff(state, diff, false); |
||||
expect(state).toEqual({}); |
||||
}); |
||||
}); |
||||
|
||||
describe("applyDiff - ignored / invalid scenarios", () => { |
||||
test("skip patch with non-leading slash path", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [ |
||||
{ op: "add", path: "address/street", value: "x" }, |
||||
]; |
||||
applyDiff(state, diff); |
||||
expect(state).toEqual({}); |
||||
}); |
||||
test("missing parent without ensurePathExists -> patch skipped and no mutation", () => { |
||||
const state: any = {}; |
||||
const diff: Patch[] = [{ op: "add", path: p("a", "b", "c"), value: 1 }]; |
||||
applyDiff(state, diff, false); |
||||
expect(state).toEqual({}); |
||||
}); |
||||
}); |
||||
Loading…
Reference in new issue