@platforma-sdk/model 1.53.10 → 1.53.13

package/src/block_api_v2.ts

@@ -6,8 +6,8 @@ import type {
   ValueWithUTagAndAuthor,
   AuthorMarker,
   ResultOrError,
-} from '@milaboratories/pl-model-common';
-import type { Operation } from 'fast-json-patch';
+} from "@milaboratories/pl-model-common";
+import type { Operation } from "fast-json-patch";
 
 /** Defines methods to read and write current block data. */
 export interface BlockApiV2<
@@ -55,7 +55,11 @@ export interface BlockApiV2<
    * function under the hood may delay actual persistence of the supplied
    * values.
    * */
-  setBlockArgsAndUiState(args: Args, state: UiState, author?: AuthorMarker): Promise<ResultOrError<void>>;
+  setBlockArgsAndUiState(
+    args: Args,
+    state: UiState,
+    author?: AuthorMarker,
+  ): Promise<ResultOrError<void>>;
 
   /**
    * Sets block navigation state.

package/src/block_api_v3.ts

@@ -6,9 +6,9 @@ import type {
   AuthorMarker,
   ResultOrError,
   BlockStateV3,
-} from '@milaboratories/pl-model-common';
-import type { Operation } from 'fast-json-patch';
-import type { MutateStoragePayload } from './block_storage';
+} from "@milaboratories/pl-model-common";
+import type { Operation } from "fast-json-patch";
+import type { MutateStoragePayload } from "./block_storage";
 
 /** Defines methods to read and write current block data. */
 export interface BlockApiV3<

package/src/block_migrations.test.ts

@@ -1,53 +1,52 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it } from "vitest";
 import {
-  DataModel,
   DataModelBuilder,
   defaultRecover,
   defineDataVersions,
   makeDataVersioned,
-} from './block_migrations';
+} from "./block_migrations";
 
-describe('defineDataVersions', () => {
-  it('throws on duplicate version values', () => {
+describe("defineDataVersions", () => {
+  it("throws on duplicate version values", () => {
     expect(() =>
       defineDataVersions({
-        V1: 'v1',
-        V2: 'v1', // duplicate!
+        V1: "v1",
+        V2: "v1", // duplicate!
       }),
-    ).toThrow('Duplicate version values: v1');
+    ).toThrow("Duplicate version values: v1");
   });
 
-  it('throws on empty version values', () => {
+  it("throws on empty version values", () => {
     expect(() =>
       defineDataVersions({
-        V1: 'v1',
-        V2: '', // empty!
+        V1: "v1",
+        V2: "", // empty!
       }),
-    ).toThrow('Version values must be non-empty strings (empty: V2)');
+    ).toThrow("Version values must be non-empty strings (empty: V2)");
   });
 
-  it('allows unique version values', () => {
+  it("allows unique version values", () => {
     const versions = defineDataVersions({
-      V1: 'v1',
-      V2: 'v2',
+      V1: "v1",
+      V2: "v2",
     });
-    expect(versions.V1).toBe('v1');
-    expect(versions.V2).toBe('v2');
+    expect(versions.V1).toBe("v1");
+    expect(versions.V2).toBe("v2");
   });
 });
 
-describe('makeDataVersioned', () => {
-  it('creates correct DataVersioned shape', () => {
-    const versioned = makeDataVersioned('v1', { count: 42 });
-    expect(versioned).toStrictEqual({ version: 'v1', data: { count: 42 } });
+describe("makeDataVersioned", () => {
+  it("creates correct DataVersioned shape", () => {
+    const versioned = makeDataVersioned("v1", { count: 42 });
+    expect(versioned).toStrictEqual({ version: "v1", data: { count: 42 } });
   });
 });
 
-describe('DataModel migrations', () => {
-  it('resets to initial data on unknown version', () => {
+describe("DataModel migrations", () => {
+  it("resets to initial data on unknown version", () => {
     const Version = defineDataVersions({
-      V1: 'v1',
-      V2: 'v2',
+      V1: "v1",
+      V2: "v2",
     });
 
     type VersionedData = {
@@ -57,19 +56,19 @@ describe('DataModel migrations', () => {
 
     const dataModel = new DataModelBuilder<VersionedData>()
       .from(Version.V1)
-      .migrate(Version.V2, (v1) => ({ ...v1, label: '' }))
-      .init(() => ({ count: 0, label: '' }));
+      .migrate(Version.V2, (v1) => ({ ...v1, label: "" }))
+      .init(() => ({ count: 0, label: "" }));
 
-    const result = dataModel.migrate(makeDataVersioned('legacy', { count: 42 }));
-    expect(result.version).toBe('v2');
-    expect(result.data).toStrictEqual({ count: 0, label: '' });
+    const result = dataModel.migrate(makeDataVersioned("legacy", { count: 42 }));
+    expect(result.version).toBe("v2");
+    expect(result.data).toStrictEqual({ count: 0, label: "" });
     expect(result.warning).toBe(`Unknown version 'legacy'`);
   });
 
-  it('uses recover() for unknown versions', () => {
+  it("uses recover() for unknown versions", () => {
     const Version = defineDataVersions({
-      V1: 'v1',
-      V2: 'v2',
+      V1: "v1",
+      V2: "v2",
     });
 
     type VersionedData = {
@@ -79,25 +78,25 @@ describe('DataModel migrations', () => {
 
     const dataModel = new DataModelBuilder<VersionedData>()
       .from(Version.V1)
-      .migrate(Version.V2, (v1) => ({ ...v1, label: '' }))
+      .migrate(Version.V2, (v1) => ({ ...v1, label: "" }))
       .recover((version, data) => {
-        if (version === 'legacy' && typeof data === 'object' && data !== null && 'count' in data) {
-          return { count: (data as { count: number }).count, label: 'recovered' };
+        if (version === "legacy" && typeof data === "object" && data !== null && "count" in data) {
+          return { count: (data as { count: number }).count, label: "recovered" };
         }
         return defaultRecover(version, data);
       })
-      .init(() => ({ count: 0, label: '' }));
+      .init(() => ({ count: 0, label: "" }));
 
-    const result = dataModel.migrate(makeDataVersioned('legacy', { count: 7 }));
-    expect(result.version).toBe('v2');
-    expect(result.data).toStrictEqual({ count: 7, label: 'recovered' });
+    const result = dataModel.migrate(makeDataVersioned("legacy", { count: 7 }));
+    expect(result.version).toBe("v2");
+    expect(result.data).toStrictEqual({ count: 7, label: "recovered" });
     expect(result.warning).toBeUndefined();
   });
 
-  it('allows recover() to delegate to defaultRecover', () => {
+  it("allows recover() to delegate to defaultRecover", () => {
     const Version = defineDataVersions({
-      V1: 'v1',
-      V2: 'v2',
+      V1: "v1",
+      V2: "v2",
     });
 
     type VersionedData = {
@@ -107,20 +106,20 @@ describe('DataModel migrations', () => {
 
     const dataModel = new DataModelBuilder<VersionedData>()
       .from(Version.V1)
-      .migrate(Version.V2, (v1) => ({ ...v1, label: '' }))
+      .migrate(Version.V2, (v1) => ({ ...v1, label: "" }))
       .recover((version, data) => defaultRecover(version, data))
-      .init(() => ({ count: 0, label: '' }));
+      .init(() => ({ count: 0, label: "" }));
 
-    const result = dataModel.migrate(makeDataVersioned('legacy', { count: 7 }));
-    expect(result.version).toBe('v2');
-    expect(result.data).toStrictEqual({ count: 0, label: '' });
+    const result = dataModel.migrate(makeDataVersioned("legacy", { count: 7 }));
+    expect(result.version).toBe("v2");
+    expect(result.data).toStrictEqual({ count: 0, label: "" });
     expect(result.warning).toBe(`Unknown version 'legacy'`);
   });
 
-  it('returns initial data on migration failure', () => {
+  it("returns initial data on migration failure", () => {
     const Version = defineDataVersions({
-      V1: 'v1',
-      V2: 'v2',
+      V1: "v1",
+      V2: "v2",
     });
 
     type VersionedData = {
@@ -132,23 +131,23 @@ describe('DataModel migrations', () => {
       .from(Version.V1)
       .migrate(Version.V2, (v1) => {
         if (v1.numbers.includes(666)) {
-          throw new Error('Forbidden number');
+          throw new Error("Forbidden number");
         }
-        return { ...v1, label: 'ok' };
+        return { ...v1, label: "ok" };
       })
-      .init(() => ({ numbers: [], label: '' }));
+      .init(() => ({ numbers: [], label: "" }));
 
-    const result = dataModel.migrate(makeDataVersioned('v1', { numbers: [666] }));
-    expect(result.version).toBe('v2');
-    expect(result.data).toStrictEqual({ numbers: [], label: '' });
+    const result = dataModel.migrate(makeDataVersioned("v1", { numbers: [666] }));
+    expect(result.version).toBe("v2");
+    expect(result.data).toStrictEqual({ numbers: [], label: "" });
     expect(result.warning).toBe(`Migration v1→v2 failed: Forbidden number`);
   });
 });
 
 function _compileTimeTypeChecks() {
   const Version = defineDataVersions({
-    V1: 'v1',
-    V2: 'v2',
+    V1: "v1",
+    V2: "v2",
   });
 
   type VersionedData = {
@@ -159,24 +158,24 @@ function _compileTimeTypeChecks() {
   // Valid: complete migration chain
   new DataModelBuilder<VersionedData>()
     .from(Version.V1)
-    .migrate(Version.V2, (v1) => ({ ...v1, label: '' }))
-    .init(() => ({ count: 0, label: '' }));
+    .migrate(Version.V2, (v1) => ({ ...v1, label: "" }))
+    .init(() => ({ count: 0, label: "" }));
 
   // Valid: with recover()
   new DataModelBuilder<VersionedData>()
     .from(Version.V1)
-    .migrate(Version.V2, (v1) => ({ ...v1, label: '' }))
+    .migrate(Version.V2, (v1) => ({ ...v1, label: "" }))
     .recover((version, data) => defaultRecover(version, data))
-    .init(() => ({ count: 0, label: '' }));
+    .init(() => ({ count: 0, label: "" }));
 
   new DataModelBuilder<VersionedData>()
     // @ts-expect-error invalid initial version key
-    .from('v3');
+    .from("v3");
 
   new DataModelBuilder<VersionedData>()
     .from(Version.V1)
     // @ts-expect-error invalid migration target key
-    .migrate('v3', (v1) => ({ ...v1, label: '' }));
+    .migrate("v3", (v1) => ({ ...v1, label: "" }));
 
   new DataModelBuilder<VersionedData>()
     .from(Version.V1)
@@ -193,7 +192,7 @@ function _compileTimeTypeChecks() {
 
   new DataModelBuilder<VersionedData>()
     .from(Version.V1)
-    .migrate(Version.V2, (v1) => ({ ...v1, label: '' }))
+    .migrate(Version.V2, (v1) => ({ ...v1, label: "" }))
     .recover((version, data) => defaultRecover(version, data))
     // @ts-expect-error recover() returns builder without recover() method - cannot call twice (only init() available)
     .recover((version, data) => defaultRecover(version, data));
@@ -202,5 +201,5 @@ function _compileTimeTypeChecks() {
     .from(Version.V1)
     .recover((version, data) => defaultRecover(version, data))
     // @ts-expect-error recover() returns builder without migrate() method (only init() available)
-    .migrate(Version.V2, (v1) => ({ ...v1, label: '' }));
+    .migrate(Version.V2, (v1) => ({ ...v1, label: "" }));
 }

package/src/block_migrations.ts

@@ -1,5 +1,5 @@
-import { tryRegisterCallback } from './internal';
-import { createBlockStorage } from './block_storage';
+import { tryRegisterCallback } from "./internal";
+import { createBlockStorage } from "./block_storage";
 
 export type DataVersionKey = string;
 export type DataVersionMap = Record<string, unknown>;
@@ -29,14 +29,14 @@ export type DataRecoverFn<T> = (version: DataVersionKey, data: unknown) => T;
 export function defineDataVersions<const T extends Record<string, string>>(versions: T): T {
   const values = Object.values(versions) as (string & keyof T)[];
   const keys = Object.keys(versions) as (keyof T)[];
-  const emptyKeys = keys.filter((key) => versions[key] === '');
+  const emptyKeys = keys.filter((key) => versions[key] === "");
   if (emptyKeys.length > 0) {
-    throw new Error(`Version values must be non-empty strings (empty: ${emptyKeys.join(', ')})`);
+    throw new Error(`Version values must be non-empty strings (empty: ${emptyKeys.join(", ")})`);
   }
   const unique = new Set(values);
   if (unique.size !== values.length) {
     const duplicates = values.filter((v, i) => values.indexOf(v) !== i);
-    throw new Error(`Duplicate version values: ${[...new Set(duplicates)].join(', ')}`);
+    throw new Error(`Duplicate version values: ${[...new Set(duplicates)].join(", ")}`);
   }
   return versions;
 }
@@ -59,14 +59,14 @@ export type DataMigrationResult<T> = DataVersioned<T> & {
 
 /** Thrown by recover() to signal unrecoverable data. */
 export class DataUnrecoverableError extends Error {
-  name = 'DataUnrecoverableError';
+  name = "DataUnrecoverableError";
   constructor(dataVersion: DataVersionKey) {
     super(`Unknown version '${dataVersion}'`);
   }
 }
 
 export function isDataUnrecoverableError(error: unknown): error is DataUnrecoverableError {
-  return error instanceof Error && error.name === 'DataUnrecoverableError';
+  return error instanceof Error && error.name === "DataUnrecoverableError";
 }
 
 type MigrationStep = {
@@ -92,7 +92,7 @@ export const defaultRecover: DataRecoverFn<never> = (version, _data) => {
 };
 
 /** Symbol for internal builder creation method */
-const FROM_BUILDER = Symbol('fromBuilder');
+const FROM_BUILDER = Symbol("fromBuilder");
 
 /** Internal state passed from builder to DataModel */
 type BuilderState<S> = {
@@ -338,10 +338,10 @@ export class DataModelBuilder<VersionedData extends DataVersionMap> {
   from<InitialVersion extends keyof VersionedData & string>(
     initialVersion: InitialVersion,
   ): DataModelMigrationChain<
-      VersionedData,
-      InitialVersion,
-      Exclude<keyof VersionedData & string, InitialVersion>
-    > {
+    VersionedData,
+    InitialVersion,
+    Exclude<keyof VersionedData & string, InitialVersion>
+  > {
     return new DataModelMigrationChain<
       VersionedData,
       InitialVersion,
@@ -409,7 +409,7 @@ export class DataModel<State> {
     recoverFn?: DataRecoverFn<State>;
   }) {
     if (versionChain.length === 0) {
-      throw new Error('DataModel requires at least one version key');
+      throw new Error("DataModel requires at least one version key");
     }
     this.versionChain = versionChain;
     this.steps = steps;
@@ -517,11 +517,11 @@ export class DataModel<State> {
    * @internal
    */
   registerCallbacks(): void {
-    tryRegisterCallback('__pl_data_initial', () => this.initialDataFn());
-    tryRegisterCallback('__pl_data_upgrade', (versioned: DataVersioned<unknown>) =>
+    tryRegisterCallback("__pl_data_initial", () => this.initialDataFn());
+    tryRegisterCallback("__pl_data_upgrade", (versioned: DataVersioned<unknown>) =>
       this.migrate(versioned),
     );
-    tryRegisterCallback('__pl_storage_initial', () => {
+    tryRegisterCallback("__pl_storage_initial", () => {
       const { version, data } = this.getDefaultData();
       const storage = createBlockStorage(data, version);
       return JSON.stringify(storage);