document-model 2.20.0 → 2.21.0

package/dist/test/document/object.test.js

@@ -0,0 +1,12 @@
+import { expect, it } from "vitest";
+import { DocumentModelClass } from "../../src/document-model/gen/object.js";
+it("should return a read only object on toDocument", () => {
+    const model = new DocumentModelClass();
+    expect(model.state.global.id).toBe("");
+    const document = model.toDocument();
+    expect(() => {
+        // @ts-expect-error Cannot assign to 'id' because it is a read-only property.
+        document.state.id = "test";
+    }).toThrow("Cannot add property id, object is not extensible");
+    expect(model.state.global.id).toBe("");
+});

package/dist/test/document/operation-id.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation-id.test.d.ts","sourceRoot":"","sources":["../../../test/document/operation-id.test.ts"],"names":[],"mappings":""}

package/dist/test/document/operation-id.test.js

@@ -0,0 +1,158 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { baseCreateDocument, baseCreateExtendedState, replayOperations, } from "#document/utils/base.js";
+import { garbageCollectDocumentOperations } from "#document/utils/document-helpers.js";
+import { baseCountReducer, countReducer, increment, } from "../helpers.js";
+describe("Document Operation ID", () => {
+    let document;
+    let initialState;
+    beforeEach(() => {
+        initialState = baseCreateExtendedState({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        document = baseCreateDocument(initialState);
+    });
+    it("should add an id to new operations", () => {
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        expect(document.operations.global.length).toBe(3);
+        for (const operation of document.operations.global) {
+            expect(operation.id).toBeDefined();
+        }
+    });
+    it("should not use the same id for different operations", () => {
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        const ids = document.operations.global.map((operation) => operation.id);
+        expect(new Set(ids).size).toBe(10);
+    });
+    it("should not assign an id to existing operations", () => {
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = {
+            ...document,
+            operations: {
+                ...document.operations,
+                global: document.operations.global.map((op) => ({
+                    ...op,
+                    id: undefined,
+                })),
+            },
+        };
+        document = countReducer(document, increment());
+        expect(document.operations.global).toHaveLength(4);
+        for (const operation of document.operations.global) {
+            if (operation.index === 3) {
+                expect(operation.id).toBeDefined();
+            }
+            else {
+                expect(operation.id).toBeUndefined();
+            }
+        }
+    });
+    it("should not add id field if existing operation does not include it", () => {
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = {
+            ...document,
+            operations: {
+                ...document.operations,
+                global: document.operations.global.map((op) => {
+                    const { id, ...operation } = op;
+                    return operation;
+                }),
+            },
+        };
+        document = countReducer(document, increment());
+        expect(document.operations.global).toHaveLength(4);
+        for (const operation of document.operations.global) {
+            if (operation.index === 3) {
+                expect(operation.id).toBeDefined();
+            }
+            else {
+                expect(operation.id).toBeUndefined();
+            }
+        }
+    });
+    it("should not change operations id when replay deocument", () => {
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        const clearedOperations = garbageCollectDocumentOperations(document.operations);
+        const replayedDoc = replayOperations(initialState, clearedOperations, baseCountReducer);
+        expect(replayedDoc.operations.global).toHaveLength(3);
+        expect(document.operations.global).toHaveLength(3);
+        for (let i = 0; i < document.operations.global.length; i++) {
+            expect(replayedDoc.operations.global[i].id).toBe(document.operations.global[i].id);
+        }
+    });
+    it("should not assign an id to existing operations when replay document", () => {
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = {
+            ...document,
+            operations: {
+                ...document.operations,
+                global: document.operations.global.map((op) => ({
+                    ...op,
+                    id: undefined,
+                })),
+            },
+        };
+        document = countReducer(document, increment());
+        const clearedOperations = garbageCollectDocumentOperations(document.operations);
+        const replayedDoc = replayOperations(initialState, clearedOperations, baseCountReducer);
+        expect(replayedDoc.operations.global).toHaveLength(4);
+        expect(document.operations.global).toHaveLength(4);
+        for (let i = 0; i < document.operations.global.length; i++) {
+            if (i === 3) {
+                expect(replayedDoc.operations.global[i].id).toBeDefined();
+            }
+            else {
+                expect(replayedDoc.operations.global[i].id).toBeUndefined();
+            }
+            expect(replayedDoc.operations.global[i].id).toBe(document.operations.global[i].id);
+        }
+    });
+    it("should not add id if existing operation does not include id field when replay document", () => {
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = {
+            ...document,
+            operations: {
+                ...document.operations,
+                global: document.operations.global.map((op) => {
+                    const { id, ...operation } = op;
+                    return operation;
+                }),
+            },
+        };
+        document = countReducer(document, increment());
+        const clearedOperations = garbageCollectDocumentOperations(document.operations);
+        const replayedDoc = replayOperations(initialState, clearedOperations, baseCountReducer);
+        expect(replayedDoc.operations.global).toHaveLength(4);
+        expect(document.operations.global).toHaveLength(4);
+        for (let i = 0; i < document.operations.global.length; i++) {
+            if (i === 3) {
+                expect(replayedDoc.operations.global[i].id).toBeDefined();
+            }
+            else {
+                expect(replayedDoc.operations.global[i].id).toBeUndefined();
+            }
+            expect(replayedDoc.operations.global[i].id).toBe(document.operations.global[i].id);
+        }
+    });
+});

package/dist/test/document/prune.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prune.test.d.ts","sourceRoot":"","sources":["../../../test/document/prune.test.ts"],"names":[],"mappings":""}

package/dist/test/document/prune.test.js

@@ -0,0 +1,176 @@
+import { describe, expect, it } from "vitest";
+import { loadState, prune, redo, setName, undo, } from "../../src/document/actions/creators.js";
+import { baseCreateDocument } from "../../src/document/utils/base.js";
+import { countReducer, increment, mapOperations, } from "../helpers.js";
+describe("PRUNE operation", () => {
+    it.skip("should prune first 4 operations", async () => {
+        const document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: {
+                global: { count: 0 },
+                local: { name: "" },
+            },
+        });
+        let newDocument = countReducer(document, increment());
+        newDocument = countReducer(newDocument, setName("Document"));
+        newDocument = countReducer(newDocument, increment());
+        newDocument = countReducer(newDocument, increment());
+        newDocument = countReducer(newDocument, increment());
+        newDocument = countReducer(newDocument, prune(0, 4));
+        expect(newDocument.name).toBe("Document");
+        expect(newDocument.state.global.count).toBe(4);
+        expect(newDocument.revision.global).toBe(2);
+        expect(mapOperations(newDocument.operations.global)).toStrictEqual([
+            {
+                ...loadState({
+                    name: "Document",
+                    state: { global: { count: 3 }, local: {} },
+                }, 4),
+                index: 0,
+                skip: 0,
+            },
+            { ...increment(), index: 1, skip: 0 },
+        ]);
+        expect(newDocument.documentType).toBe("powerhouse/counter");
+        expect(newDocument.initialState.state.global).toStrictEqual({
+            count: 0,
+        });
+        expect(newDocument.initialState.state).toStrictEqual(document.state);
+    });
+    it.skip("should prune last 3 operations", async () => {
+        const document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        let newDocument = countReducer(document, increment());
+        newDocument = countReducer(newDocument, setName("Document"));
+        newDocument = countReducer(newDocument, increment());
+        newDocument = countReducer(newDocument, increment());
+        newDocument = countReducer(newDocument, increment());
+        newDocument = countReducer(newDocument, prune(2));
+        expect(newDocument.name).toBe("Document");
+        expect(newDocument.state.global.count).toBe(4);
+        expect(newDocument.revision.global).toBe(3);
+        expect(mapOperations(newDocument.operations.global)).toStrictEqual([
+            { ...increment(), index: 0, skip: 0 },
+            { ...setName("Document"), index: 1, skip: 0 },
+            {
+                ...loadState({
+                    name: "Document",
+                    state: { global: { count: 4 }, local: {} },
+                }, 3),
+                index: 2,
+                skip: 0,
+            },
+        ]);
+        expect(newDocument.documentType).toBe("powerhouse/counter");
+        expect(newDocument.initialState.state.global).toStrictEqual({
+            count: 0,
+        });
+        expect(newDocument.initialState.state).toStrictEqual(document.state);
+    });
+    it.skip("should prune 2 operations", async () => {
+        const document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        let newDocument = countReducer(document, increment());
+        newDocument = countReducer(newDocument, setName("Document"));
+        newDocument = countReducer(newDocument, increment());
+        newDocument = countReducer(newDocument, increment());
+        newDocument = countReducer(newDocument, increment());
+        newDocument = countReducer(newDocument, prune(2, 4));
+        expect(newDocument.name).toBe("Document");
+        expect(newDocument.state.global.count).toBe(4);
+        expect(newDocument.revision.global).toBe(4);
+        expect(mapOperations(newDocument.operations.global)).toStrictEqual([
+            { ...increment(), index: 0, skip: 0 },
+            { ...setName("Document"), index: 1, skip: 0 },
+            {
+                ...loadState({
+                    name: "Document",
+                    state: { global: { count: 3 }, local: {} },
+                }, 2),
+                index: 2,
+                skip: 0,
+            },
+            { ...increment(), index: 3, skip: 0 },
+        ]);
+        expect(newDocument.documentType).toBe("powerhouse/counter");
+        expect(newDocument.initialState.state.global).toStrictEqual({
+            count: 0,
+        });
+        expect(newDocument.initialState.state).toStrictEqual(document.state);
+    });
+    it.skip("should undo pruned state", async () => {
+        const document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        let newDocument = countReducer(document, increment());
+        newDocument = countReducer(newDocument, setName("Document"));
+        newDocument = countReducer(newDocument, increment());
+        newDocument = countReducer(newDocument, increment());
+        newDocument = countReducer(newDocument, increment());
+        newDocument = countReducer(newDocument, prune(1, 5));
+        newDocument = countReducer(newDocument, undo(1));
+        expect(newDocument.name).toBe("");
+        expect(newDocument.state.global.count).toBe(1);
+        expect(newDocument.revision.global).toBe(3);
+        expect(mapOperations(newDocument.operations.global)).toMatchObject([
+            { ...increment(), index: 0, skip: 0 },
+            { type: "NOOP", input: {}, index: 1, skip: 0, scope: "global" },
+            { type: "NOOP", input: {}, index: 2, skip: 1, scope: "global" },
+        ]);
+        expect(newDocument.clipboard.length).toBe(1);
+        expect(newDocument.clipboard[0]).toMatchObject({
+            ...loadState({
+                name: "Document",
+                state: { global: { count: 4 }, local: {} },
+            }, 4),
+            index: 1,
+            skip: 0,
+        });
+        expect(newDocument.documentType).toBe("powerhouse/counter");
+        expect(newDocument.initialState.state.global).toStrictEqual({
+            count: 0,
+        });
+        expect(newDocument.initialState.state).toStrictEqual(document.state);
+    });
+    it.skip("should redo pruned state", async () => {
+        const document = baseCreateDocument({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        let newDocument = countReducer(document, increment());
+        newDocument = countReducer(newDocument, setName("Document"));
+        newDocument = countReducer(newDocument, increment());
+        newDocument = countReducer(newDocument, increment());
+        newDocument = countReducer(newDocument, increment());
+        newDocument = countReducer(newDocument, prune(1, 5));
+        newDocument = countReducer(newDocument, undo(1));
+        newDocument = countReducer(newDocument, redo(1));
+        expect(newDocument.name).toBe("Document");
+        expect(newDocument.state.global.count).toBe(4);
+        expect(newDocument.revision.global).toBe(4);
+        expect(mapOperations(newDocument.operations.global)).toMatchObject([
+            { ...increment(), index: 0, skip: 0 },
+            { type: "NOOP", input: {}, index: 1, skip: 0, scope: "global" },
+            { type: "NOOP", input: {}, index: 2, skip: 1, scope: "global" },
+            {
+                ...loadState({
+                    name: "Document",
+                    state: { global: { count: 4 }, local: { name: "" } },
+                }, 4),
+                index: 3,
+                skip: 0,
+            },
+        ]);
+        expect(newDocument.clipboard.length).toBe(0);
+        expect(newDocument.documentType).toBe("powerhouse/counter");
+        expect(newDocument.initialState.state.global).toStrictEqual({
+            count: 0,
+        });
+        expect(newDocument.initialState.state).toStrictEqual(document.state);
+    });
+});

package/dist/test/document/reducer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reducer.test.d.ts","sourceRoot":"","sources":["../../../test/document/reducer.test.ts"],"names":[],"mappings":""}

package/dist/test/document/reducer.test.js

@@ -0,0 +1,268 @@
+import { beforeAll, describe, expect, it, vi } from "vitest";
+import { setName } from "../../src/document/actions/creators.js";
+import { SET_NAME } from "../../src/document/actions/types.js";
+import { baseCreateDocument, baseCreateExtendedState, createAction, createReducer, hashKey, } from "../../src/document/utils/base.js";
+import { countReducer, error, increment, wrappedEmptyReducer, } from "../helpers.js";
+describe("Base reducer", () => {
+    beforeAll(() => {
+        vi.useFakeTimers().setSystemTime(new Date("2020-01-01"));
+    });
+    it("should update revision", async () => {
+        const document = baseCreateDocument();
+        const newDocument = wrappedEmptyReducer(document, {
+            type: "TEST",
+            input: {},
+            scope: "global",
+        });
+        expect(newDocument.revision.global).toBe(1);
+    });
+    it("should update lastModified", async () => {
+        vi.useFakeTimers();
+        const document = baseCreateDocument();
+        await new Promise((r) => {
+            setTimeout(r, 100);
+            vi.runOnlyPendingTimers();
+        });
+        const newDocument = wrappedEmptyReducer(document, {
+            type: "TEST",
+            input: {},
+            scope: "global",
+        });
+        expect(newDocument.lastModified > document.lastModified).toBe(true);
+        vi.useRealTimers();
+    });
+    it("should update global operations list", async () => {
+        vi.useFakeTimers({ now: new Date("2023-01-01") });
+        const document = baseCreateDocument();
+        const newDocument = wrappedEmptyReducer(document, {
+            type: "TEST",
+            input: {},
+            scope: "global",
+        });
+        expect(newDocument.operations.global).toMatchObject([
+            {
+                type: "TEST",
+                timestamp: new Date().toISOString(),
+                index: 0,
+                skip: 0,
+                input: {},
+                hash: "vyGp6PvFo4RvsFtPoIWeCReyIC8=",
+                scope: "global",
+                error: undefined,
+            },
+        ]);
+        expect(newDocument.operations.local).toStrictEqual([]);
+    });
+    it("should throw error when creating action with non-string type", () => {
+        expect(() => createAction(1)).toThrow();
+    });
+    it("should throw error when creating action with empty type", () => {
+        expect(() => createAction("")).toThrow();
+    });
+    it("should create SET_NAME action", () => {
+        const setNameAction = setName("Document");
+        expect(setNameAction).toStrictEqual({
+            type: SET_NAME,
+            input: "Document",
+            scope: "global",
+        });
+    });
+    it("should throw error creating invalid SET_NAME action", () => {
+        expect(() => setName(1)).toThrow();
+    });
+    it("should set document name", async () => {
+        const document = baseCreateDocument();
+        const newDocument = wrappedEmptyReducer(document, setName("Document"));
+        expect(newDocument.name).toBe("Document");
+    });
+    it("should throw error on invalid base action", async () => {
+        const document = baseCreateDocument();
+        expect(() => wrappedEmptyReducer(document, {
+            type: "SET_NAME",
+            input: 0,
+            scope: "global",
+        })).toThrow();
+    });
+    it("should dispatch trigger action", async () => {
+        expect.assertions(4);
+        const document = baseCreateDocument();
+        const id = hashKey();
+        const reducer = createReducer((_state, action, dispatch) => {
+            if (action.type === "CREATE_DOCUMENT") {
+                // @ts-expect-error TODO add synchronization units to fix type error
+                dispatch?.({
+                    type: "CREATE_CHILD_DOCUMENT",
+                    input: {
+                        id,
+                        documentType: "test",
+                        document: baseCreateDocument({
+                            state: { global: { value: "test" }, local: {} },
+                        }),
+                    },
+                });
+            }
+            return _state;
+        });
+        const triggerAction = {
+            type: "CREATE_DOCUMENT",
+            input: "",
+            scope: "global",
+        };
+        reducer(document, triggerAction, (action) => {
+            expect(action.type).toBe("CREATE_CHILD_DOCUMENT");
+            const input = action.input;
+            expect(input.id).toBe(id);
+            expect(input.documentType).toBe("test");
+            expect(input.document?.initialState.state.global).toStrictEqual({
+                value: "test",
+            });
+        });
+    });
+    it("should throw an error when there is a missing index operation", () => {
+        let document = baseCreateDocument();
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_0",
+            input: {},
+            scope: "global",
+        });
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_1",
+            input: {},
+            scope: "global",
+        });
+        expect(() => {
+            wrappedEmptyReducer(document, {
+                type: "TEST_2",
+                input: {},
+                scope: "global",
+                index: 3,
+            });
+        }).toThrow("Missing operations: expected 2 with skip 0 or equivalent, got index 3 with skip 0");
+    });
+    it("should throw an error when there is a missing index operation + skip", () => {
+        let document = baseCreateDocument();
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_0",
+            input: {},
+            scope: "global",
+        });
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_1",
+            input: {},
+            scope: "global",
+        });
+        expect(() => {
+            wrappedEmptyReducer(document, {
+                type: "TEST_2",
+                input: {},
+                scope: "global",
+                index: 4,
+            }, undefined, { skip: 1 });
+        }).toThrow("Missing operations: expected 2 with skip 0 or equivalent, got index 4 with skip 1");
+    });
+    it("should not throw an error when there is a valid index operation + skip", () => {
+        let document = baseCreateDocument();
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_0",
+            input: {},
+            scope: "global",
+        });
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_1",
+            input: {},
+            scope: "global",
+        });
+        document = wrappedEmptyReducer(document, {
+            type: "TEST_2",
+            input: {},
+            scope: "global",
+            index: 3,
+        }, undefined, { skip: 1 });
+        expect(document.operations.global).toMatchObject([
+            {
+                type: "TEST_0",
+                index: 0,
+            },
+            {
+                type: "TEST_1",
+                index: 1,
+            },
+            {
+                type: "TEST_2",
+                index: 3,
+                skip: 1,
+            },
+        ]);
+    });
+    it("should not throw errors from reducer", () => {
+        const initialState = baseCreateExtendedState({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        let document = baseCreateDocument(initialState);
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, error());
+        document = countReducer(document, increment());
+        expect(document.state.global.count).toBe(3);
+    });
+    it("should not throw errors from reducer when there is an error after an operation with skip value", () => {
+        const initialState = baseCreateExtendedState({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        let document = baseCreateDocument(initialState);
+        document = countReducer(document, increment());
+        document = countReducer(document, increment(), undefined, { skip: 1 });
+        document = countReducer(document, error());
+        document = countReducer(document, increment());
+        expect(document.state.global.count).toBe(2);
+    });
+    it("should include error message into error operation prop", () => {
+        const initialState = baseCreateExtendedState({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        let document = baseCreateDocument(initialState);
+        document = countReducer(document, increment());
+        document = countReducer(document, increment(), undefined, { skip: 1 });
+        document = countReducer(document, error());
+        document = countReducer(document, increment());
+        expect(document.operations.global.length).toBe(3);
+        expect(document.state.global.count).toBe(2);
+        expect(document.operations.global).toMatchObject([
+            {
+                type: "INCREMENT",
+                index: 1,
+                skip: 1,
+                error: undefined,
+            },
+            {
+                type: "ERROR",
+                index: 2,
+                skip: 0,
+                error: "Error action",
+            },
+            {
+                type: "INCREMENT",
+                index: 3,
+                skip: 0,
+                error: undefined,
+            },
+        ]);
+    });
+    it("should not include error message in successful operations", () => {
+        const initialState = baseCreateExtendedState({
+            documentType: "powerhouse/counter",
+            state: { global: { count: 0 }, local: { name: "" } },
+        });
+        let document = baseCreateDocument(initialState);
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        document = countReducer(document, increment());
+        expect(document.operations.global.length).toBe(3);
+        for (const operation of document.operations.global) {
+            expect(operation.error).toBeUndefined();
+        }
+    });
+});

package/dist/test/document/skip-operations.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skip-operations.test.d.ts","sourceRoot":"","sources":["../../../test/document/skip-operations.test.ts"],"names":[],"mappings":""}