@platforma-sdk/model 1.54.13 → 1.55.0

package/src/block_storage.test.ts

@@ -4,20 +4,15 @@ import {
   BLOCK_STORAGE_SCHEMA_VERSION,
   DATA_MODEL_DEFAULT_VERSION,
   createBlockStorage,
-  defaultBlockStorageHandlers,
-  getFromStorage,
   getPluginData,
-  getPluginNames,
   getStorageData,
-  getStorageDataVersion,
   isBlockStorage,
-  mergeBlockStorageHandlers,
+  migrateBlockStorage,
   normalizeBlockStorage,
-  removePluginData,
-  setPluginData,
   updateStorageData,
-  updateStorageDataVersion,
-  updateStorage,
+  type MutateStoragePayload,
+  type PluginName,
+  type PluginRegistry,
 } from "./block_storage";
 
 describe("BlockStorage", () => {
@@ -39,7 +34,11 @@ describe("BlockStorage", () => {
     });
 
     it("should return true for BlockStorage with plugin data", () => {
-      const storage = setPluginData(createBlockStorage({ foo: "bar" }), "test", { data: 123 });
+      const storage = updateStorageData(createBlockStorage({ foo: "bar" }), {
+        operation: "update-plugin-data",
+        pluginId: "testPlugin",
+        value: { data: 123 },
+      });
       expect(isBlockStorage(storage)).toBe(true);
     });
 
@@ -90,13 +89,46 @@ describe("BlockStorage", () => {
       expect(storage.__dataVersion).toBe("v5");
       expect(storage.__data).toEqual({ foo: "bar" });
     });
+
+    it("should create storage with empty plugin fields by default", () => {
+      const storage = createBlockStorage({});
+      expect(storage.__pluginRegistry).toEqual({});
+      expect(storage.__plugins).toEqual({});
+    });
   });
 
   describe("normalizeBlockStorage", () => {
-    it("should return BlockStorage as-is", () => {
+    it("should return BlockStorage as-is with plugin defaults added", () => {
       const storage = createBlockStorage({ data: "test" }, "v2");
       const normalized = normalizeBlockStorage(storage);
       expect(normalized).toEqual(storage);
+      expect(normalized.__pluginRegistry).toEqual({});
+      expect(normalized.__plugins).toEqual({});
+    });
+
+    it("should add plugin defaults to BlockStorage without them", () => {
+      // Simulate storage from earlier version without plugin fields
+      const oldStorage = {
+        [BLOCK_STORAGE_KEY]: "v1" as const,
+        __dataVersion: "v2",
+        __data: { data: "test" },
+      };
+      const normalized = normalizeBlockStorage(oldStorage);
+      expect(normalized.__pluginRegistry).toEqual({});
+      expect(normalized.__plugins).toEqual({});
+    });
+
+    it("should preserve existing plugin data when normalizing", () => {
+      const storageWithPlugins = {
+        [BLOCK_STORAGE_KEY]: "v1" as const,
+        __dataVersion: "v2",
+        __data: { data: "test" },
+        __pluginRegistry: { p1: "plugin1" as PluginName },
+        __plugins: { p1: { __dataVersion: "v1", __data: { foo: "bar" } } },
+      };
+      const normalized = normalizeBlockStorage(storageWithPlugins);
+      expect(normalized.__pluginRegistry).toEqual({ p1: "plugin1" as PluginName });
+      expect(normalized.__plugins).toEqual({ p1: { __dataVersion: "v1", __data: { foo: "bar" } } });
     });
 
     it("should wrap legacy data in BlockStorage structure", () => {
@@ -105,6 +137,8 @@ describe("BlockStorage", () => {
       expect(normalized[BLOCK_STORAGE_KEY]).toBe(BLOCK_STORAGE_SCHEMA_VERSION);
       expect(normalized.__dataVersion).toBe(DATA_MODEL_DEFAULT_VERSION);
       expect(normalized.__data).toEqual(legacyData);
+      expect(normalized.__pluginRegistry).toEqual({});
+      expect(normalized.__plugins).toEqual({});
     });
 
     it("should wrap primitive legacy data", () => {
@@ -129,13 +163,9 @@ describe("BlockStorage", () => {
       expect(getStorageData(storage)).toEqual({ count: 42 });
     });
 
-    it("getStorageDataVersion should return the version", () => {
-      expect(getStorageDataVersion(storage)).toBe("v3");
-    });
-
     it("updateStorageData should return new storage with updated data", () => {
       const newStorage = updateStorageData(storage, {
-        operation: "update-data",
+        operation: "update-block-data",
         value: { count: 100 },
       });
       expect(newStorage.__data).toEqual({ count: 100 });
@@ -144,123 +174,281 @@ describe("BlockStorage", () => {
       // Original should be unchanged
       expect(storage.__data).toEqual({ count: 42 });
     });
-
-    it("updateStorageDataVersion should return new storage with updated version", () => {
-      const newStorage = updateStorageDataVersion(storage, "v5");
-      expect(newStorage.__dataVersion).toBe("v5");
-      expect(newStorage.__data).toEqual({ count: 42 });
-      expect(newStorage[BLOCK_STORAGE_KEY]).toBe(BLOCK_STORAGE_SCHEMA_VERSION);
-      // Original should be unchanged
-      expect(storage.__dataVersion).toBe("v3");
-    });
   });
 
-  describe("Plugin data functions", () => {
+  describe("Plugin data functions (UI)", () => {
     const baseStorage = createBlockStorage({});
 
-    it("setPluginData should add plugin data", () => {
-      const storage = setPluginData(baseStorage, "table", { columns: ["a", "b"] });
-      expect(storage["@plugin/table"]).toEqual({ columns: ["a", "b"] });
+    it("update-plugin operation should add plugin data with default version", () => {
+      const storage = updateStorageData(baseStorage, {
+        operation: "update-plugin-data",
+        pluginId: "table1",
+        value: { columns: ["a", "b"] },
+      });
+      expect(storage.__plugins).toEqual({
+        table1: {
+          __dataVersion: DATA_MODEL_DEFAULT_VERSION,
+          __data: { columns: ["a", "b"] },
+        },
+      });
+    });
+
+    it("update-plugin operation should preserve existing version when updating", () => {
+      let storage = {
+        ...baseStorage,
+        __plugins: { table1: { __dataVersion: "v5", __data: { old: true } } },
+      };
+      storage = updateStorageData(storage, {
+        operation: "update-plugin-data",
+        pluginId: "table1",
+        value: { new: true },
+      });
+      expect(storage.__plugins?.table1).toEqual({
+        __dataVersion: "v5",
+        __data: { new: true },
+      });
     });
 
     it("getPluginData should retrieve plugin data", () => {
-      const storage = setPluginData(baseStorage, "chart", { type: "bar" });
-      expect(getPluginData(storage, "chart")).toEqual({ type: "bar" });
+      const storage = updateStorageData(baseStorage, {
+        operation: "update-plugin-data",
+        pluginId: "chart1",
+        value: { type: "bar" },
+      });
+      expect(getPluginData(storage, "chart1")).toEqual({ type: "bar" });
     });
 
     it("getPluginData should return undefined for missing plugin", () => {
       expect(getPluginData(baseStorage, "nonexistent")).toBeUndefined();
     });
 
-    it("removePluginData should remove plugin data", () => {
-      let storage = setPluginData(baseStorage, "toRemove", { data: "test" });
-      storage = setPluginData(storage, "toKeep", { other: "data" });
-      const result = removePluginData(storage, "toRemove");
-      expect(result["@plugin/toRemove"]).toBeUndefined();
-      expect(result["@plugin/toKeep"]).toEqual({ other: "data" });
+    it("should not modify original storage (immutability)", () => {
+      const storage = updateStorageData(baseStorage, {
+        operation: "update-plugin-data",
+        pluginId: "table1",
+        value: { data: "test" },
+      });
+      expect(baseStorage.__plugins).toEqual({});
+      expect(storage.__plugins?.table1).toBeDefined();
     });
+  });
 
-    it("getPluginNames should return all plugin names", () => {
-      let storage = createBlockStorage({});
-      storage = setPluginData(storage, "alpha", {});
-      storage = setPluginData(storage, "beta", {});
-      storage = setPluginData(storage, "gamma", {});
-      const names = getPluginNames(storage);
-      expect(names.sort()).toEqual(["alpha", "beta", "gamma"]);
+  describe("updateStorageData operations", () => {
+    it("update-data operation should update block data", () => {
+      const storage = createBlockStorage({ count: 1 });
+      const updated = updateStorageData(storage, {
+        operation: "update-block-data",
+        value: { count: 2 },
+      });
+      expect(updated.__data).toEqual({ count: 2 });
     });
 
-    it("getPluginNames should return empty array when no plugins", () => {
-      expect(getPluginNames(baseStorage)).toEqual([]);
+    it("update-plugin operation should update plugin data", () => {
+      const storage = createBlockStorage({});
+      const updated = updateStorageData(storage, {
+        operation: "update-plugin-data",
+        pluginId: "plugin1",
+        value: { foo: "bar" },
+      });
+      expect(updated.__plugins?.plugin1).toEqual({
+        __dataVersion: DATA_MODEL_DEFAULT_VERSION,
+        __data: { foo: "bar" },
+      });
+    });
+
+    it("should throw on unknown operation", () => {
+      const storage = createBlockStorage({});
+      expect(() => {
+        updateStorageData(storage, { operation: "invalid" } as MutateStoragePayload);
+      }).toThrow("Unknown storage operation: invalid");
     });
   });
 
-  describe("Generic storage access", () => {
-    const storage = createBlockStorage("hello", "v2");
+  describe("Atomic migration (migrateBlockStorage)", () => {
+    const createTestStorage = () => {
+      const storage = createBlockStorage({ count: 1 }, "v1");
+      return {
+        ...storage,
+        __pluginRegistry: { plugin1: "typeA" as PluginName },
+        __plugins: { plugin1: { __dataVersion: "v1", __data: { value: "old" } } },
+      };
+    };
+
+    it("should migrate block data and plugins atomically on success", () => {
+      const storage = createTestStorage();
+      const newRegistry: PluginRegistry = { plugin1: "typeA" as PluginName };
+
+      const result = migrateBlockStorage(storage, {
+        migrateBlockData: (versioned) => {
+          const d = versioned.data as { count: number };
+          return { data: { count: d.count + 1 }, version: "v2" };
+        },
+        migratePluginData: (_pluginId, _versioned) => ({
+          version: "v2",
+          data: { value: "migrated" },
+        }),
+        newPluginRegistry: newRegistry,
+        createPluginData: (_pluginId) => ({ version: "v1", data: {} }),
+      });
 
-    it("getFromStorage should get __data", () => {
-      expect(getFromStorage(storage, "__data")).toBe("hello");
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.storage.__data).toEqual({ count: 2 });
+        expect(result.storage.__dataVersion).toBe("v2");
+        expect(result.storage.__plugins?.plugin1).toEqual({
+          __dataVersion: "v2",
+          __data: { value: "migrated" },
+        });
+      }
     });
 
-    it("getFromStorage should get __dataVersion", () => {
-      expect(getFromStorage(storage, "__dataVersion")).toBe("v2");
-    });
+    it("should return failure and preserve original storage when block migration throws", () => {
+      const storage = createTestStorage();
+      const originalData = storage.__data;
+
+      const result = migrateBlockStorage(storage, {
+        migrateBlockData: () => {
+          throw new Error("Block migration failed");
+        },
+        migratePluginData: (_pluginId, _versioned) => ({
+          version: "v1",
+          data: {},
+        }),
+        newPluginRegistry: {},
+        createPluginData: (_pluginId) => ({ version: "v1", data: {} }),
+      });
 
-    it("updateStorage should update any key", () => {
-      const updated = updateStorage(storage, "__data", "world");
-      expect(updated.__data).toBe("world");
-      expect(storage.__data).toBe("hello"); // immutable
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toBe("Block migration failed");
+        expect(result.failedAt).toBe("block");
+      }
+      // Original storage untouched
+      expect(storage.__data).toEqual(originalData);
     });
-  });
 
-  describe("BlockStorageHandlers", () => {
-    describe("defaultBlockStorageHandlers", () => {
-      it("transformStateForStorage should replace data", () => {
-        const storage = createBlockStorage("old");
-        const result = defaultBlockStorageHandlers.transformStateForStorage(storage, "new");
-        expect(result.__data).toBe("new");
-        expect(result.__dataVersion).toBe(DATA_MODEL_DEFAULT_VERSION);
+    it("should return failure and preserve original storage when plugin migration throws", () => {
+      const storage = createTestStorage();
+      const newRegistry: PluginRegistry = { plugin1: "typeA" as PluginName };
+
+      const result = migrateBlockStorage(storage, {
+        migrateBlockData: (versioned) => ({
+          data: versioned.data as { count: number },
+          version: "v2",
+        }),
+        migratePluginData: (pluginId) => {
+          throw new Error(`Plugin ${pluginId} migration failed`);
+        },
+        newPluginRegistry: newRegistry,
+        createPluginData: (_pluginId) => ({ version: "v1", data: {} }),
       });
 
-      it("deriveStateForArgs should return data directly", () => {
-        const storage = createBlockStorage({ data: "test" });
-        expect(defaultBlockStorageHandlers.deriveStateForArgs(storage)).toEqual({ data: "test" });
-      });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toBe("Plugin plugin1 migration failed");
+        expect(result.failedAt).toBe("plugin1");
+      }
+    });
 
-      it("migrateStorage should update version only", () => {
-        const storage = createBlockStorage({ data: "test" });
-        const result = defaultBlockStorageHandlers.migrateStorage(storage, "v1", "v3");
-        expect(result.__dataVersion).toBe("v3");
-        expect(result.__data).toEqual({ data: "test" });
+    it("should reset plugin data when plugin type changes", () => {
+      const storage = createTestStorage();
+      const newRegistry: PluginRegistry = { plugin1: "typeB" as PluginName }; // Different type
+
+      const result = migrateBlockStorage(storage, {
+        migrateBlockData: (versioned) => ({
+          data: versioned.data as { count: number },
+          version: "v2",
+        }),
+        migratePluginData: () => {
+          throw new Error("Should not be called for type change");
+        },
+        newPluginRegistry: newRegistry,
+        createPluginData: (pluginId) => ({
+          version: "v1",
+          data: { fresh: true, type: newRegistry[pluginId] },
+        }),
       });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.storage.__plugins?.plugin1).toEqual({
+          __dataVersion: "v1",
+          __data: { fresh: true, type: "typeB" },
+        });
+      }
     });
 
-    describe("mergeBlockStorageHandlers", () => {
-      it("should return defaults when no custom handlers provided", () => {
-        const handlers = mergeBlockStorageHandlers();
-        expect(handlers.transformStateForStorage).toBe(
-          defaultBlockStorageHandlers.transformStateForStorage,
-        );
-        expect(handlers.deriveStateForArgs).toBe(defaultBlockStorageHandlers.deriveStateForArgs);
-        expect(handlers.migrateStorage).toBe(defaultBlockStorageHandlers.migrateStorage);
+    it("should create initial data for new plugins", () => {
+      const storage = createBlockStorage({ count: 1 }, "v1");
+      const newRegistry: PluginRegistry = { newPlugin: "typeNew" as PluginName };
+
+      const result = migrateBlockStorage(storage, {
+        migrateBlockData: (versioned) => ({
+          data: versioned.data as { count: number },
+          version: "v2",
+        }),
+        migratePluginData: () => {
+          throw new Error("Should not be called for new plugin");
+        },
+        newPluginRegistry: newRegistry,
+        createPluginData: (_pluginId) => ({
+          version: "v1",
+          data: { initialized: true },
+        }),
       });
 
-      it("should override with custom handlers", () => {
-        const customTransform = <T>(
-          storage: ReturnType<typeof createBlockStorage<T>>,
-          data: T,
-        ) => ({
-          ...storage,
-          __data: data,
-          __dataVersion: `${storage.__dataVersion}-next`,
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.storage.__plugins?.newPlugin).toEqual({
+          __dataVersion: "v1",
+          __data: { initialized: true },
         });
+      }
+    });
 
-        const handlers = mergeBlockStorageHandlers({
-          transformStateForStorage: customTransform,
-        });
+    it("should drop plugins not in new registry", () => {
+      const storage = createTestStorage();
+      const newRegistry: PluginRegistry = {}; // Empty - removes plugin1
+
+      const result = migrateBlockStorage(storage, {
+        migrateBlockData: (versioned) => ({
+          data: versioned.data as { count: number },
+          version: "v2",
+        }),
+        migratePluginData: () => {
+          throw new Error("Should not be called for dropped plugin");
+        },
+        newPluginRegistry: newRegistry,
+        createPluginData: () => {
+          throw new Error("Should not be called for dropped plugin");
+        },
+      });
 
-        expect(handlers.transformStateForStorage).toBe(customTransform);
-        expect(handlers.deriveStateForArgs).toBe(defaultBlockStorageHandlers.deriveStateForArgs);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.storage.__plugins).toEqual({});
+        expect(result.storage.__pluginRegistry).toEqual({});
+      }
+    });
+
+    it("should allow plugin migration to return undefined to remove plugin", () => {
+      const storage = createTestStorage();
+      const newRegistry: PluginRegistry = { plugin1: "typeA" as PluginName };
+
+      const result = migrateBlockStorage(storage, {
+        migrateBlockData: (versioned) => ({
+          data: versioned.data as { count: number },
+          version: "v2",
+        }),
+        migratePluginData: () => undefined, // Remove plugin
+        newPluginRegistry: newRegistry,
+        createPluginData: () => ({ version: "v1", data: {} }),
       });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.storage.__plugins).toEqual({});
+      }
     });
   });
 });