document-model 2.19.0 → 2.21.0

package/dist/test/document-helpers/nextSkipNumber.test.d.ts.map

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

package/dist/test/document-helpers/nextSkipNumber.test.js

@@ -0,0 +1,134 @@
+import { describe, expect, it } from "vitest";
+import { nextSkipNumber } from "../../src/document/utils/document-helpers.js";
+import { buildOperations } from "./utils.js";
+describe("nextSkipNumber", () => {
+    const scenarios = [
+        { title: "case 1", operations: [], expected: -1 },
+        { title: "case 2", operations: [{ index: 0, skip: 0 }], expected: -1 },
+        {
+            title: "case 3",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 0 },
+            ],
+            expected: 1,
+        },
+        {
+            title: "case 4",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 1 },
+            ],
+            expected: -1,
+        },
+        { title: "case 5", operations: [{ index: 1, skip: 1 }], expected: -1 },
+        {
+            title: "case 6",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 0 },
+                { index: 2, skip: 0 },
+            ],
+            expected: 1,
+        },
+        {
+            title: "case 7",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 0 },
+                { index: 2, skip: 0 },
+                { index: 2, skip: 1 },
+            ],
+            expected: 2,
+        },
+        {
+            title: "case 8",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 0 },
+                { index: 2, skip: 0 },
+                { index: 2, skip: 1 },
+                { index: 2, skip: 2 },
+            ],
+            expected: -1,
+        },
+        {
+            title: "case 9",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 1 },
+                { index: 2, skip: 0 },
+            ],
+            expected: 2,
+        },
+        {
+            title: "case 10",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 1 },
+                { index: 2, skip: 2 },
+            ],
+            expected: -1,
+        },
+        {
+            title: "case 11",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 1 },
+                { index: 2, skip: 0 },
+                { index: 3, skip: 0 },
+            ],
+            expected: 1,
+        },
+        {
+            title: "case 12",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 1 },
+                { index: 2, skip: 0 },
+                { index: 3, skip: 1 },
+            ],
+            expected: 3,
+        },
+        {
+            title: "case 13",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 1 },
+                { index: 2, skip: 0 },
+                { index: 3, skip: 3 },
+            ],
+            expected: -1,
+        },
+        {
+            title: "case 14",
+            operations: [
+                { index: 50, skip: 50 },
+                { index: 100, skip: 49 },
+                { index: 150, skip: 49 },
+                { index: 151, skip: 0 },
+                { index: 152, skip: 0 },
+                { index: 153, skip: 0 },
+                { index: 154, skip: 3 },
+            ],
+            expected: 53,
+        },
+        {
+            title: "case 15",
+            operations: [
+                { index: 0, skip: 0 },
+                { index: 1, skip: 0 },
+                { index: 2, skip: 0 },
+                { index: 3, skip: 0 },
+                { index: 4, skip: 0 },
+                { index: 6, skip: 1 },
+            ],
+            expected: 2,
+        },
+    ];
+    it.each(scenarios)("should calculate next skip number: $title", (testInput) => {
+        const operations = buildOperations(testInput.operations);
+        const result = nextSkipNumber(operations);
+        expect(result).toBe(testInput.expected);
+    });
+});

package/dist/test/document-helpers/prepareOperations.test.d.ts.map

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

package/dist/test/document-helpers/prepareOperations.test.js

@@ -0,0 +1,303 @@
+import { describe, expect, it } from "vitest";
+import { prepareOperations } from "../../src/document/utils/document-helpers.js";
+import { buildOperations } from "./utils.js";
+describe("prepareOperations", () => {
+    it("should return all the operations when they are valid", () => {
+        const operationsHistory = buildOperations([
+            { index: 0, skip: 0 },
+            { index: 1, skip: 0 },
+            { index: 2, skip: 0 },
+        ]);
+        const newOperations = buildOperations([
+            { index: 3, skip: 0 },
+            { index: 4, skip: 0 },
+        ]);
+        const result = prepareOperations(operationsHistory, newOperations);
+        expect(result.duplicatedOperations.length).toBe(0);
+        expect(result.invalidOperations.length).toBe(0);
+        expect(result.integrityIssues.length).toBe(0);
+        expect(result.validOperations.length).toBe(2);
+        expect(result.validOperations).toMatchObject([
+            { index: 3, skip: 0 },
+            { index: 4, skip: 0 },
+        ]);
+    });
+    it("should return duplicated operations when there is no missing index errors", () => {
+        const operationsHistory = buildOperations([
+            { index: 0, skip: 0 },
+            { index: 1, skip: 0 },
+            { index: 2, skip: 0 },
+        ]);
+        const newOperations = buildOperations([
+            { index: 2, skip: 0 },
+            { index: 3, skip: 0 },
+            { index: 3, skip: 1 },
+            { index: 4, skip: 0 },
+        ]);
+        const result = prepareOperations(operationsHistory, newOperations);
+        expect(result.invalidOperations.length).toBe(0);
+        expect(result.integrityIssues.length).toBe(2);
+        expect(result.duplicatedOperations).toMatchObject([
+            { index: 2, skip: 0 },
+            { index: 3, skip: 1 },
+        ]);
+        expect(result.validOperations).toMatchObject([
+            { index: 3, skip: 0 },
+            { index: 4, skip: 0 },
+        ]);
+    });
+    it("should return missing index operations as invalid", () => {
+        const operationsHistory = buildOperations([
+            { index: 1, skip: 1 },
+            { index: 3, skip: 1 },
+        ]);
+        const newOperations = buildOperations([
+            { index: 4, skip: 0 },
+            { index: 6, skip: 0 },
+        ]);
+        const result = prepareOperations(operationsHistory, newOperations);
+        expect(result.duplicatedOperations.length).toBe(0);
+        expect(result.integrityIssues.length).toBe(1);
+        expect(result.validOperations.length).toBe(1);
+        expect(result.invalidOperations).toMatchObject([{ index: 6, skip: 0 }]);
+    });
+    it("should return operations that follows a missing index as invalid", () => {
+        const operationsHistory = buildOperations([
+            { index: 1, skip: 1 },
+            { index: 3, skip: 1 },
+        ]);
+        const newOperations = buildOperations([
+            { index: 4, skip: 0 },
+            { index: 5, skip: 0 },
+            { index: 7, skip: 0 },
+            { index: 8, skip: 0 },
+            { index: 9, skip: 0 },
+        ]);
+        const result = prepareOperations(operationsHistory, newOperations);
+        expect(result.duplicatedOperations.length).toBe(0);
+        expect(result.integrityIssues.length).toBe(1);
+        expect(result.validOperations.length).toBe(2);
+        expect(result.invalidOperations).toMatchObject([
+            { index: 7, skip: 0 },
+            { index: 8, skip: 0 },
+            { index: 9, skip: 0 },
+        ]);
+    });
+    // This one is failing because there's no garbage collection for the new operations before checking for missing indexes
+    // it.only('should return operations that follows a missing index as invalid', () => {
+    //     const operationsHistory = buildOperations([
+    //         { index: 1, skip: 1 },
+    //         { index: 3, skip: 1 }
+    //     ]);
+    //     const newOperations = buildOperations([
+    //         { index: 4, skip: 0 },
+    //         { index: 5, skip: 0 },
+    //         { index: 7, skip: 0 }, // This one should be removed by the garbage collection
+    //         { index: 7, skip: 1 },
+    //         { index: 8, skip: 0 },
+    //         { index: 9, skip: 0 }
+    //     ]);
+    //     const result = prepareOperations(operationsHistory, newOperations);
+    //     console.log(result);
+    //     expect(result.duplicatedOperations.length).toBe(0);
+    //     expect(result.integrityIssues.length).toBe(2);
+    //     expect(result.validOperations.length).toBe(2);
+    //     expect(result.invalidOperations).toMatchObject([{ index: 6, skip: 0 }]);
+    // });
+    it("should return duplicated operations that follows a missing index as invalid", () => {
+        const operationsHistory = buildOperations([
+            { index: 1, skip: 1 },
+            { index: 3, skip: 1 },
+        ]);
+        const newOperations = buildOperations([
+            { index: 4, skip: 0 },
+            { index: 5, skip: 0 },
+            { index: 5, skip: 0 },
+            { index: 7, skip: 0 },
+            { index: 7, skip: 0 },
+            { index: 8, skip: 0 },
+            { index: 9, skip: 0 },
+        ]);
+        const result = prepareOperations(operationsHistory, newOperations);
+        expect(result.invalidOperations).toMatchObject([
+            { index: 7, skip: 0 },
+            { index: 7, skip: 0 },
+            { index: 8, skip: 0 },
+            { index: 9, skip: 0 },
+        ]);
+        expect(result.integrityIssues.length).toBe(3);
+        expect(result.duplicatedOperations).toMatchObject([
+            { index: 5, skip: 0 },
+            { index: 5, skip: 0 },
+        ]);
+        expect(result.validOperations).toMatchObject([{ index: 4, skip: 0 }]);
+    });
+    it("should not return duplicated operations when all of them follows a missing index operation", () => {
+        const operationsHistory = buildOperations([
+            { index: 1, skip: 1 },
+            { index: 2, skip: 0 },
+            { index: 3, skip: 0 },
+        ]);
+        const newOperations = buildOperations([
+            { index: 4, skip: 0 },
+            { index: 5, skip: 0 },
+            { index: 7, skip: 0 },
+            { index: 7, skip: 0 },
+            { index: 8, skip: 0 },
+            { index: 8, skip: 0 },
+        ]);
+        const result = prepareOperations(operationsHistory, newOperations);
+        expect(result.invalidOperations).toMatchObject([
+            { index: 7, skip: 0 },
+            { index: 7, skip: 0 },
+            { index: 8, skip: 0 },
+            { index: 8, skip: 0 },
+        ]);
+        expect(result.integrityIssues.length).toBe(3);
+        expect(result.duplicatedOperations.length).toBe(0);
+        expect(result.validOperations).toMatchObject([
+            { index: 4, skip: 0 },
+            { index: 5, skip: 0 },
+        ]);
+    });
+    it("should not return valid operations when all of them follows a missing index operation", () => {
+        const operationsHistory = buildOperations([
+            { index: 1, skip: 1 },
+            { index: 2, skip: 0 },
+            { index: 3, skip: 0 },
+        ]);
+        const newOperations = buildOperations([
+            { index: 5, skip: 0 },
+            { index: 6, skip: 0 },
+            { index: 7, skip: 0 },
+            { index: 8, skip: 0 },
+        ]);
+        const result = prepareOperations(operationsHistory, newOperations);
+        expect(result.integrityIssues.length).toBe(1);
+        expect(result.duplicatedOperations.length).toBe(0);
+        expect(result.validOperations.length).toBe(0);
+        expect(result.invalidOperations).toMatchObject([
+            { index: 5, skip: 0 },
+            { index: 6, skip: 0 },
+            { index: 7, skip: 0 },
+            { index: 8, skip: 0 },
+        ]);
+    });
+    it("should mark operations as invalid when they have an index bigger than the first missing index", () => {
+        const operationsHistory = buildOperations([
+            { index: 1, skip: 1 },
+            { index: 2, skip: 0 },
+            { index: 3, skip: 0 },
+        ]);
+        const newOperations = buildOperations([
+            { index: 4, skip: 0 },
+            { index: 6, skip: 0 },
+            { index: 7, skip: 0 },
+            { index: 9, skip: 0 },
+            { index: 10, skip: 0 },
+        ]);
+        const result = prepareOperations(operationsHistory, newOperations);
+        expect(result.integrityIssues.length).toBe(2);
+        expect(result.duplicatedOperations.length).toBe(0);
+        expect(result.validOperations).toMatchObject([{ index: 4, skip: 0 }]);
+        expect(result.invalidOperations).toMatchObject([
+            { index: 6, skip: 0 },
+            { index: 7, skip: 0 },
+            { index: 9, skip: 0 },
+            { index: 10, skip: 0 },
+        ]);
+    });
+    it("should mark operations as invalid when they have an index bigger than the first missing index and are duplicated", () => {
+        const operationsHistory = buildOperations([
+            { index: 1, skip: 1 },
+            { index: 2, skip: 0 },
+            { index: 3, skip: 0 },
+        ]);
+        const newOperations = buildOperations([
+            { index: 4, skip: 0 },
+            { index: 6, skip: 0 },
+            { index: 6, skip: 0 },
+            { index: 7, skip: 0 },
+            { index: 9, skip: 0 },
+            { index: 10, skip: 0 },
+        ]);
+        const result = prepareOperations(operationsHistory, newOperations);
+        expect(result.integrityIssues.length).toBe(3);
+        expect(result.duplicatedOperations.length).toBe(0);
+        expect(result.validOperations).toMatchObject([{ index: 4, skip: 0 }]);
+        expect(result.invalidOperations).toMatchObject([
+            { index: 6, skip: 0 },
+            { index: 6, skip: 0 },
+            { index: 7, skip: 0 },
+            { index: 9, skip: 0 },
+            { index: 10, skip: 0 },
+        ]);
+    });
+    it("should not return duplicated operations when all of them are invalid (missing index)", () => {
+        const operationsHistory = buildOperations([
+            { index: 1, skip: 1 },
+            { index: 2, skip: 0 },
+            { index: 3, skip: 0 },
+        ]);
+        const newOperations = buildOperations([
+            { index: 5, skip: 0 },
+            { index: 5, skip: 0 },
+            { index: 6, skip: 0 },
+            { index: 6, skip: 0 },
+        ]);
+        const result = prepareOperations(operationsHistory, newOperations);
+        expect(result.integrityIssues.length).toBe(3);
+        expect(result.duplicatedOperations.length).toBe(0);
+        expect(result.validOperations.length).toBe(0);
+        expect(result.invalidOperations).toMatchObject([
+            { index: 5, skip: 0 },
+            { index: 5, skip: 0 },
+            { index: 6, skip: 0 },
+            { index: 6, skip: 0 },
+        ]);
+    });
+    it("should sort operations history", () => {
+        const operationsHistory = buildOperations([
+            { index: 2, skip: 0 },
+            { index: 0, skip: 0 },
+            { index: 1, skip: 0 },
+        ]);
+        const newOperations = buildOperations([
+            { index: 3, skip: 0 },
+            { index: 4, skip: 0 },
+        ]);
+        const result = prepareOperations(operationsHistory, newOperations);
+        expect(result.duplicatedOperations.length).toBe(0);
+        expect(result.invalidOperations.length).toBe(0);
+        expect(result.integrityIssues.length).toBe(0);
+        expect(result.validOperations.length).toBe(2);
+        expect(result.validOperations).toMatchObject([
+            { index: 3, skip: 0 },
+            { index: 4, skip: 0 },
+        ]);
+    });
+    it("should sort new operations", () => {
+        const operationsHistory = buildOperations([
+            { index: 0, skip: 0 },
+            { index: 1, skip: 0 },
+            { index: 2, skip: 0 },
+        ]);
+        const newOperations = buildOperations([
+            { index: 6, skip: 0 },
+            { index: 4, skip: 0 },
+            { index: 5, skip: 0 },
+            { index: 3, skip: 0 },
+        ]);
+        const result = prepareOperations(operationsHistory, newOperations);
+        expect(result.duplicatedOperations.length).toBe(0);
+        expect(result.invalidOperations.length).toBe(0);
+        expect(result.integrityIssues.length).toBe(0);
+        expect(result.validOperations.length).toBe(4);
+        expect(result.validOperations).toMatchObject([
+            { index: 3, skip: 0 },
+            { index: 4, skip: 0 },
+            { index: 5, skip: 0 },
+            { index: 6, skip: 0 },
+        ]);
+    });
+});

package/dist/test/document-helpers/removeExistingOperations.test.d.ts.map

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

package/dist/test/document-helpers/removeExistingOperations.test.js

@@ -0,0 +1,149 @@
+import { describe, expect, it } from "vitest";
+import { removeExistingOperations } from "../../src/document/utils/document-helpers.js";
+import { buildOperations } from "./utils.js";
+describe("removeExistingOperations", () => {
+    const scenarios = [
+        {
+            title: "case 1: all new operations should be applied",
+            operationsHistory: [
+                { index: 0, skip: 0, type: "OP_0", hash: "hash_0" },
+                { index: 1, skip: 0, type: "OP_1", hash: "hash_1" },
+                { index: 2, skip: 0, type: "OP_2", hash: "hash_2" },
+            ],
+            newOperations: [
+                { index: 4, skip: 0, type: "OP_4", hash: "hash_4" },
+                { index: 5, skip: 0, type: "OP_5", hash: "hash_5" },
+                { index: 6, skip: 0, type: "OP_6", hash: "hash_6" },
+            ],
+            expected: [
+                { index: 4, skip: 0, type: "OP_4", hash: "hash_4" },
+                { index: 5, skip: 0, type: "OP_5", hash: "hash_5" },
+                { index: 6, skip: 0, type: "OP_6", hash: "hash_6" },
+            ],
+        },
+        {
+            title: "case 2: return no operations, all of them already exist in the history",
+            operationsHistory: [
+                { index: 0, skip: 0, type: "OP_0", hash: "hash_0" },
+                { index: 1, skip: 0, type: "OP_1", hash: "hash_1" },
+                { index: 2, skip: 0, type: "OP_2", hash: "hash_2" },
+            ],
+            newOperations: [
+                { index: 0, skip: 0, type: "OP_0", hash: "hash_0" },
+                { index: 1, skip: 0, type: "OP_1", hash: "hash_1" },
+                { index: 2, skip: 0, type: "OP_2", hash: "hash_2" },
+            ],
+            expected: [],
+        },
+        {
+            title: "case 3: return only operation that does not exist in the history",
+            operationsHistory: [
+                { index: 0, skip: 0, type: "OP_0", hash: "hash_0" },
+                { index: 1, skip: 0, type: "OP_1", hash: "hash_1" },
+                { index: 2, skip: 0, type: "OP_2", hash: "hash_2" },
+                { index: 3, skip: 0, type: "OP_3", hash: "hash_3" },
+                { index: 4, skip: 0, type: "OP_4", hash: "hash_4" },
+                { index: 5, skip: 0, type: "OP_5", hash: "hash_5" },
+            ],
+            newOperations: [
+                { index: 4, skip: 0, type: "OP_4", hash: "hash_4" },
+                { index: 5, skip: 0, type: "OP_5", hash: "hash_5" },
+                { index: 6, skip: 0, type: "OP_6", hash: "hash_6" },
+                { index: 7, skip: 0, type: "OP_7", hash: "hash_7" },
+            ],
+            expected: [
+                { index: 6, skip: 0, type: "OP_6", hash: "hash_6" },
+                { index: 7, skip: 0, type: "OP_7", hash: "hash_7" },
+            ],
+        },
+        {
+            title: "case 4: return only operation that does not exist in the history",
+            operationsHistory: [
+                { index: 0, skip: 0, type: "OP_0", hash: "hash_0" },
+                { index: 2, skip: 0, type: "OP_2", hash: "hash_2" },
+                { index: 4, skip: 0, type: "OP_4", hash: "hash_4" },
+            ],
+            newOperations: [
+                { index: 0, skip: 0, type: "OP_0", hash: "hash_0" },
+                { index: 1, skip: 0, type: "OP_1", hash: "hash_1" },
+                { index: 2, skip: 0, type: "OP_2", hash: "hash_2" },
+                { index: 3, skip: 0, type: "OP_3", hash: "hash_3" },
+                { index: 4, skip: 0, type: "OP_4", hash: "hash_4" },
+                { index: 5, skip: 0, type: "OP_5", hash: "hash_5" },
+            ],
+            expected: [
+                { index: 1, skip: 0, type: "OP_1", hash: "hash_1" },
+                { index: 3, skip: 0, type: "OP_3", hash: "hash_3" },
+                { index: 5, skip: 0, type: "OP_5", hash: "hash_5" },
+            ],
+        },
+    ];
+    it.each(scenarios)("$title", (testInput) => {
+        const newOperations = buildOperations(testInput.newOperations);
+        const operationsHistory = buildOperations(testInput.operationsHistory);
+        const result = removeExistingOperations(newOperations, operationsHistory);
+        expect(result).toMatchObject(testInput.expected);
+    });
+    it("should not consider operations skipped", () => {
+        const existingOperations = [
+            {
+                type: "NOOP",
+                input: {},
+                scope: "global",
+                index: 0,
+                timestamp: "2024-04-22T18:33:20.624Z",
+                hash: "pLimr2HqW//d6upWCv4tGfI0W4c=",
+                skip: 0,
+            },
+            {
+                type: "ADD_FOLDER",
+                input: { id: "1", name: "test1" },
+                scope: "global",
+                index: 1,
+                timestamp: "2024-04-22T18:33:20.631Z",
+                hash: "P6p5OmHl7FpHRN9ftOS0k+eaU4E=",
+                skip: 1,
+            },
+            {
+                type: "ADD_FOLDER",
+                input: { id: "2", name: "test2" },
+                scope: "global",
+                index: 2,
+                timestamp: "2024-04-22T18:33:20.631Z",
+                hash: "5XOFEY2NKrHVyOA3c3oXDibrjwM=",
+                skip: 0,
+            },
+        ];
+        const operationsHistory = [
+            {
+                type: "ADD_FOLDER",
+                input: { id: "1", name: "test1" },
+                scope: "global",
+                index: 0,
+                timestamp: "2024-04-22T18:33:20.628Z",
+                hash: "P6p5OmHl7FpHRN9ftOS0k+eaU4E=",
+                skip: 0,
+            },
+            {
+                type: "ADD_FOLDER",
+                input: { id: "1", name: "test1" },
+                scope: "global",
+                index: 1,
+                timestamp: "2024-04-22T18:33:20.630Z",
+                hash: "P6p5OmHl7FpHRN9ftOS0k+eaU4E=",
+                skip: 1,
+            },
+            {
+                type: "ADD_FOLDER",
+                input: { id: "2", name: "test2" },
+                scope: "global",
+                index: 2,
+                timestamp: "2024-04-22T18:33:20.630Z",
+                hash: "5XOFEY2NKrHVyOA3c3oXDibrjwM=",
+                skip: 0,
+            },
+        ];
+        const result = removeExistingOperations(existingOperations, operationsHistory);
+        expect(result).toMatchObject([]);
+    });
+});

package/dist/test/document-helpers/reshuffleByTimestamp.test.d.ts.map

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