document-model 2.20.0 → 2.21.0

package/dist/test/document-model/validation.test.js

@@ -0,0 +1,257 @@
+import { validateInitialState, validateModule, validateModuleOperation, validateModules, validateStateSchemaName, } from "#document-model/custom/utils.js";
+import { setStateSchema } from "#document-model/gen/creators.js";
+import { reducer } from "#document-model/gen/reducer.js";
+import { createDocument } from "#document-model/gen/utils.js";
+describe("DocumentModel Validation Error", () => {
+    const documentName = "testDocument";
+    let doc = createDocument();
+    beforeEach(() => {
+        doc = createDocument({
+            id: "test-id",
+            name: documentName,
+            description: "test description",
+            extension: "phdm",
+            authorName: "test author",
+            authorWebsite: "www.test.com",
+        });
+    });
+    describe("initial state", () => {
+        it("should report errors if initialState is invalid", () => {
+            const errors = [];
+            errors.push(...validateInitialState(""));
+            errors.push(...validateInitialState("{}}"));
+            errors.push(...validateInitialState('{ "id": }'));
+            expect(errors.length).toBe(3);
+        });
+        it("should report errors when initialState is empty and validateInitialState is called with allowEmptyState = false", () => {
+            const errors = validateInitialState("{}", false);
+            expect(errors.length).toBe(1);
+        });
+        it("should not report errors for empty initialState when allowEmptyState = true", () => {
+            const errors = [
+                ...validateInitialState("{}", true),
+                ...validateInitialState("", true),
+            ];
+            expect(errors.length).toBe(0);
+        });
+        it("should not return errors if initialState is valid", () => {
+            const errors = [
+                ...validateInitialState('{ "id": 1 }', true),
+                ...validateInitialState('{ "id": 1 }', false),
+            ];
+            expect(errors.length).toBe(0);
+        });
+    });
+    describe("document schema", () => {
+        it("should report error for empty schema", () => {
+            const errors = validateStateSchemaName(doc.state.global.specifications[0].state.global.schema, documentName, "", false);
+            expect(errors.length).toBe(1);
+            expect(errors[0].message).toBe("State schema is required");
+        });
+        it("should not trigger empty schema error if allowEmptySchema = true", () => {
+            const errors = validateStateSchemaName(doc.state.global.specifications[0].state.global.schema, documentName, "", true);
+            expect(errors.length).toBe(0);
+        });
+        it("should not return errors when Global State Name is the same as the document name", () => {
+            const newDoc = reducer(doc, setStateSchema({
+                scope: "global",
+                schema: "type TestDocumentState {}",
+            }));
+            const errors = validateStateSchemaName(newDoc.state.global.specifications[0].state.global.schema, documentName);
+            expect(errors.length).toBe(0);
+        });
+        it("should not return errors when Local State Name is the same as the document name", () => {
+            const newDoc = reducer(doc, setStateSchema({
+                scope: "local",
+                schema: "type TestDocumentLocalState {}",
+            }));
+            const errors = validateStateSchemaName(newDoc.state.global.specifications[0].state.local.schema, documentName, "local");
+            expect(errors.length).toBe(0);
+        });
+        it("should return errors when global state name type is not the same as the document name", () => {
+            let errors = [];
+            const newDoc = reducer(doc, setStateSchema({
+                scope: "global",
+                schema: "type CustomNameState {}",
+            }));
+            errors = [
+                ...errors,
+                ...validateStateSchemaName(newDoc.state.global.specifications[0].state.global.schema, documentName),
+            ];
+            const newDoc2 = reducer(doc, setStateSchema({
+                scope: "global",
+                schema: "type testdocumentState {}",
+            }));
+            errors = [
+                ...errors,
+                ...validateStateSchemaName(newDoc2.state.global.specifications[0].state.global.schema, documentName),
+            ];
+            expect(errors.length).toBe(2);
+        });
+        it("should return errors when local state name type is not the same as the document name", () => {
+            let errors = [];
+            const newDoc = reducer(doc, setStateSchema({
+                scope: "local",
+                schema: "type CustomNameLocalState {}",
+            }));
+            errors = [
+                ...errors,
+                ...validateStateSchemaName(newDoc.state.global.specifications[0].state.local.schema, documentName),
+            ];
+            const newDoc2 = reducer(newDoc, setStateSchema({
+                scope: "local",
+                schema: "type testdocumentLocalState {}",
+            }));
+            errors = [
+                ...errors,
+                ...validateStateSchemaName(doc.state.global.specifications[0].state.local.schema, documentName, "local"),
+            ];
+            const newDoc3 = reducer(newDoc2, setStateSchema({
+                scope: "local",
+                schema: "type TestDocumentState {}",
+            }));
+            errors = [
+                ...errors,
+                ...validateStateSchemaName(newDoc3.state.global.specifications[0].state.local.schema, documentName, "local"),
+            ];
+            expect(errors.length).toBe(3);
+        });
+    });
+    describe("module", () => {
+        it("should report error when module has no name defined", () => {
+            const mod = {
+                name: "",
+                description: "test description",
+                id: "test-id",
+                operations: [
+                    {
+                        description: "",
+                        id: "",
+                        errors: [],
+                        examples: [],
+                        name: "test-operation",
+                        reducer: "",
+                        schema: "input TestOperationInput {}",
+                        scope: "global",
+                        template: "",
+                    },
+                ],
+            };
+            const errors = validateModule(mod);
+            expect(errors.length).toBe(1);
+            expect(errors[0].message).toBe("Module name is required");
+        });
+        it("should report error when module has no operations defined", () => {
+            const mod = {
+                name: "test-module",
+                description: "test description",
+                id: "test-id",
+                operations: [],
+            };
+            const errors = validateModule(mod);
+            expect(errors.length).toBe(1);
+            expect(errors[0].message).toBe("Module operations are required");
+        });
+        it("should not report errors when module is valid", () => {
+            const mod = {
+                name: "test-module",
+                description: "test description",
+                id: "test-id",
+                operations: [
+                    {
+                        description: "",
+                        id: "",
+                        errors: [],
+                        examples: [],
+                        name: "test-operation",
+                        reducer: "",
+                        schema: "input TestOperationInput {}",
+                        scope: "global",
+                        template: "",
+                    },
+                ],
+            };
+            const errors = validateModule(mod);
+            expect(errors.length).toBe(0);
+        });
+    });
+    describe("operation", () => {
+        it("should report an error when operation name is not defined", () => {
+            const operation = {
+                description: "",
+                id: "",
+                errors: [],
+                examples: [],
+                name: "",
+                reducer: "",
+                schema: "input TestOperationInput {}",
+                scope: "global",
+                template: "",
+            };
+            const errors = validateModuleOperation(operation);
+            expect(errors.length).toBe(1);
+            expect(errors[0].message).toBe("Operation name is required");
+        });
+        it("should report an error when operation schema is not defined", () => {
+            const operation = {
+                description: "",
+                id: "",
+                errors: [],
+                examples: [],
+                name: "test-operation",
+                reducer: "",
+                schema: "",
+                scope: "global",
+                template: "",
+            };
+            const errors = validateModuleOperation(operation);
+            expect(errors.length).toBe(1);
+            expect(errors[0].message).toBe("Operation schema is required");
+        });
+        it("should not report errors when operation is valid", () => {
+            const operation = {
+                description: "",
+                id: "",
+                errors: [],
+                examples: [],
+                name: "test-operation",
+                reducer: "",
+                schema: "input TestOperationInput {}",
+                scope: "global",
+                template: "",
+            };
+            const errors = validateModuleOperation(operation);
+            expect(errors.length).toBe(0);
+        });
+    });
+    describe("modules", () => {
+        it("should report errors when there's no mdoules defined ", () => {
+            const errors = validateModules([]);
+            expect(errors.length).toBe(1);
+            expect(errors[0].message).toBe("Modules are required");
+        });
+        it("should not report errors when modules are defined", () => {
+            const errors = validateModules([
+                {
+                    name: "test-module",
+                    description: "test description",
+                    id: "test-id",
+                    operations: [
+                        {
+                            description: "",
+                            id: "",
+                            errors: [],
+                            examples: [],
+                            name: "test-operation",
+                            reducer: "",
+                            schema: "input TestOperationInput {}",
+                            scope: "global",
+                            template: "",
+                        },
+                    ],
+                },
+            ]);
+            expect(errors.length).toBe(0);
+        });
+    });
+});

package/dist/test/document-model/zip.test.d.ts.map

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

package/dist/test/document-model/zip.test.js

@@ -0,0 +1,80 @@
+import fs from "fs";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { setModelDescription, setModelId, setModelName, } from "../../src/document-model/gen/creators.js";
+import { reducer } from "../../src/document-model/gen/reducer.js";
+import { createDocument, loadFromFile, saveToFile, } from "../../src/document-model/gen/utils.js";
+import { undo } from "../../src/document/actions/creators.js";
+describe("DocumentModel", () => {
+    const tempDir = "./test/document/temp/document-model/zip";
+    let timestamp = "";
+    beforeAll(() => {
+        if (!fs.existsSync(tempDir))
+            fs.mkdirSync(tempDir, {
+                recursive: true,
+            });
+    });
+    afterAll(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("should save to zip", async () => {
+        let documentModel = createDocument();
+        documentModel = reducer(documentModel, setModelId({ id: "powerhouse/test" }));
+        await saveToFile(documentModel, tempDir, "test");
+        expect(fs.existsSync(`${tempDir}/test.phdm.zip`)).toBe(true);
+        // keeps operation timestamp to check when loading
+        timestamp = documentModel.operations.global[0].timestamp;
+    });
+    it("should load from zip", async () => {
+        const documentModel = await loadFromFile(`${tempDir}/test.phdm.zip`);
+        expect(documentModel.state.global.id).toBe("powerhouse/test");
+        expect(documentModel.operations.global).toMatchObject([
+            {
+                hash: "xmstBdekoMQJQXwUZaOcv/Q/d9Q=",
+                index: 0,
+                skip: 0,
+                input: { id: "powerhouse/test" },
+                scope: "global",
+                type: "SET_MODEL_ID",
+                timestamp,
+                error: undefined,
+            },
+        ]);
+    });
+    it("should not include resultingState param in operations when exporting to zip", async () => {
+        let documentModel = createDocument();
+        documentModel = reducer(documentModel, setModelId({ id: "powerhouse/test" }), undefined, { reuseOperationResultingState: true });
+        documentModel = reducer(documentModel, setModelDescription({ description: "desc-test" }), undefined, { reuseOperationResultingState: true });
+        documentModel = reducer(documentModel, setModelName({ name: "name-test" }), undefined, { reuseOperationResultingState: true });
+        expect(documentModel.operations.global).toHaveLength(3);
+        for (const operation of documentModel.operations.global) {
+            expect(operation.resultingState).toBeDefined();
+        }
+        await saveToFile(documentModel, tempDir, "test-document-resulting-state");
+        const loadedDocumentModel = await loadFromFile(`${tempDir}/test-document-resulting-state.phdm.zip`);
+        expect(loadedDocumentModel.operations.global).toHaveLength(3);
+        for (const operation of loadedDocumentModel.operations.global) {
+            expect(operation.resultingState).toBeUndefined();
+        }
+    });
+    it("should keep undo state when loading from zip", async () => {
+        let documentModel = createDocument();
+        documentModel = reducer(documentModel, setModelId({ id: "powerhouse/test" }));
+        documentModel = reducer(documentModel, undo());
+        expect(documentModel.state.global.id).toBe("");
+        await saveToFile(documentModel, tempDir, "test2");
+        const loadedDocumentModel = await loadFromFile(`${tempDir}/test2.phdm.zip`);
+        expect(loadedDocumentModel.state.global.id).toBe("");
+        expect(loadedDocumentModel.operations.global).toMatchObject([
+            {
+                index: 1,
+                skip: 1,
+                input: {},
+                scope: "global",
+                type: "NOOP",
+            },
+        ]);
+        const expectedLoadedDocumentModel = { ...documentModel };
+        expectedLoadedDocumentModel.clipboard = [];
+        expect(loadedDocumentModel).toStrictEqual(expectedLoadedDocumentModel);
+    });
+});

package/dist/test/helpers.d.ts

@@ -0,0 +1,32 @@
+import { SignalDispatch } from "../src/document/signal.js";
+import { Action, BaseAction, Operation, OperationScope, PHDocument, ReducerOptions, StateReducer } from "../src/document/types.js";
+export declare const emptyReducer: <TDocument extends PHDocument = PHDocument>(document: PHDocument) => TDocument;
+export declare const wrappedEmptyReducer: <TDocument extends PHDocument = PHDocument>(document: TDocument, action: Action | Operation, dispatch?: SignalDispatch, options?: ReducerOptions) => TDocument;
+export type IncrementAction = BaseAction<"INCREMENT", undefined>;
+export type DecrementAction = BaseAction<"DECREMENT", undefined>;
+export type ErrorAction = BaseAction<"ERROR", undefined>;
+export type SetLocalNameAction = BaseAction<"SET_LOCAL_NAME", string>;
+export type CountAction = IncrementAction | DecrementAction | SetLocalNameAction | ErrorAction;
+export type CountDocument = PHDocument<CountState, CountLocalState, CountAction>;
+export type CountState = {
+    count: number;
+};
+export type CountLocalState = {
+    name: string;
+};
+export declare const increment: () => IncrementAction;
+export declare const decrement: () => DecrementAction;
+export declare const error: () => ErrorAction;
+export declare const setLocalName: (name: string) => SetLocalNameAction;
+export declare const baseCountReducer: StateReducer<CountDocument>;
+export declare const mutableCountReducer: StateReducer<CountDocument>;
+export declare const countReducer: import("../src/document/types.js").Reducer<CountDocument>;
+export declare const mapOperations: (operations: Operation[]) => {
+    input: unknown;
+    type: string;
+    index: number;
+    scope: OperationScope;
+    skip: number;
+}[];
+export declare const createFakeOperation: (index?: number, skip?: number, scope?: OperationScope) => Operation;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/test/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../test/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EACL,MAAM,EACN,UAAU,EACV,SAAS,EACT,cAAc,EACd,UAAU,EACV,cAAc,EACd,YAAY,EACb,MAAM,0BAA0B,CAAC;AAIlC,eAAO,MAAM,YAAY,GAAI,SAAS,SAAS,UAAU,yBAC7C,UAAU,KACL,SAAS,CAAC;AAE3B,eAAO,MAAM,mBAAmB,GAAI,SAAS,SAAS,UAAU,yBACpD,SAAS,UACX,MAAM,GAAG,SAAS,aACf,cAAc,YACf,cAAc,KACvB,SAEF,CAAC;AAGF,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;AACjE,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;AACjE,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;AACzD,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC;AACtE,MAAM,MAAM,WAAW,GACnB,eAAe,GACf,eAAe,GACf,kBAAkB,GAClB,WAAW,CAAC;AAEhB,MAAM,MAAM,aAAa,GAAG,UAAU,CACpC,UAAU,EACV,eAAe,EACf,WAAW,CACZ,CAAC;AACF,MAAM,MAAM,UAAU,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3C,MAAM,MAAM,eAAe,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/C,eAAO,MAAM,SAAS,uBAAmD,CAAC;AAE1E,eAAO,MAAM,SAAS,uBAAmD,CAAC;AAE1E,eAAO,MAAM,KAAK,mBAA2C,CAAC;AAE9D,eAAO,MAAM,YAAY,SAAU,MAAM,uBAOtC,CAAC;AAEJ,eAAO,MAAM,gBAAgB,EAAE,YAAY,CAAC,aAAa,CAmBxD,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,aAAa,CAyB3D,CAAC;AAEF,eAAO,MAAM,YAAY,2DAAiD,CAAC;AAE3E,eAAO,MAAM,aAAa,eAAgB,SAAS,EAAE;;;;;;GAQpD,CAAC;AAEF,eAAO,MAAM,mBAAmB,0CAGvB,cAAc,KAUf,SAAS,CAAC"}

package/dist/test/helpers.js

@@ -0,0 +1,69 @@
+import { createAction, createReducer } from "../src/document/utils/base.js";
+// Empty reducer that supports base actions
+export const emptyReducer = (document) => document;
+export const wrappedEmptyReducer = (document, action, dispatch, options) => {
+    return emptyReducer(document);
+};
+export const increment = () => createAction("INCREMENT");
+export const decrement = () => createAction("DECREMENT");
+export const error = () => createAction("ERROR");
+export const setLocalName = (name) => createAction("SET_LOCAL_NAME", name, undefined, undefined, "local");
+export const baseCountReducer = (state, action) => {
+    switch (action.type) {
+        case "INCREMENT":
+            state.global.count += 1;
+            break;
+        case "DECREMENT":
+            state.global.count -= 1;
+            break;
+        case "SET_LOCAL_NAME":
+            state.local.name = action.input;
+            break;
+        case "ERROR":
+            throw new Error("Error action");
+        default:
+            return state;
+    }
+};
+export const mutableCountReducer = (state, action) => {
+    switch (action.type) {
+        case "INCREMENT":
+            return {
+                ...state,
+                global: { ...state.global, count: state.global.count + 1 },
+            };
+        case "DECREMENT":
+            return {
+                ...state,
+                global: { ...state.global, count: state.global.count - 1 },
+            };
+        case "SET_LOCAL_NAME":
+            return {
+                ...state,
+                local: { ...state.local, name: action.input },
+            };
+        case "ERROR":
+            throw new Error("Error action");
+        default:
+            return state;
+    }
+};
+export const countReducer = createReducer(baseCountReducer);
+export const mapOperations = (operations) => {
+    return operations.map(({ input, type, index, scope, skip }) => ({
+        input,
+        type,
+        index,
+        scope,
+        skip,
+    }));
+};
+export const createFakeOperation = (index = 0, skip = 0, scope = "global") => ({
+    type: "FAKE_OP",
+    input: `TEST_${index}`,
+    scope,
+    skip,
+    index,
+    timestamp: new Date().toISOString(),
+    hash: `${index}`,
+});