schema definition

Author: SandroMaglione

packages/schema/src/main.ts

@@ -1,28 +1,30 @@
 import { Schema } from "effect";
 import { LoroDoc, LoroList, LoroMap } from "loro-crdt";
-import { ActivitySchema, AnyLoroDocSchema } from "./schema";
+import { AnyLoroDocSchema, CurrentSchema, Table } from "./schema";
 import type { Version } from "./versioning";
 
-export const VERSION = 3 satisfies Version;
+export const VERSION = 1 satisfies Version;
 
 export const Metadata = Schema.Struct({ version: Schema.Number });
-export const Activity = ActivitySchema[VERSION];
 
 export type LoroSchema = {
   metadata: LoroMap<typeof Metadata.Encoded>;
-  activity: LoroList<LoroMap<typeof Activity.Encoded>>;
+  food: LoroList<LoroMap<typeof CurrentSchema.fields.food.value.Encoded>>;
+  meal: LoroList<LoroMap<typeof CurrentSchema.fields.meal.value.Encoded>>;
 };
 
 export class SnapshotSchema extends Schema.Class<SnapshotSchema>(
   "SnapshotSchema"
 )({
   metadata: Metadata,
-  activity: Schema.Array(Activity),
+  ...CurrentSchema.fields,
 }) {
   static readonly EmptyDoc = () => {
     const doc = new LoroDoc<LoroSchema>();
     doc.getMap("metadata").set("version", VERSION);
-    doc.getList("activity");
+    Table.literals.map((key) => {
+      doc.getList(key);
+    });
     return doc;
   };
 }

packages/schema/src/migrations.ts

@@ -1,49 +1,11 @@
 import { ParseResult, Schema } from "effect";
-import { LoroDoc, LoroMap } from "loro-crdt";
-import { VERSION } from "./main";
-import { AnyLoroDocSchema, type ActivityV1, type ActivityV2 } from "./schema";
+import { LoroDoc } from "loro-crdt";
+import { SnapshotSchema } from "./main";
+import { AnyLoroDocSchema } from "./schema";
 import { Version } from "./versioning";
 
 const migrations = {
-  1: (doc) => {
-    doc.getMap("metadata").set("version", VERSION);
-    doc.getList("activity");
-    return doc;
-  },
-
-  2: (doc) => {
-    doc.getMap("metadata").set("version", 2);
-
-    const activity = doc.getList("activity");
-    for (let i = 0; i < activity.length; i++) {
-      const item = activity.get(i) as LoroMap<typeof ActivityV1.Encoded>;
-      const map = new LoroMap();
-      const [firstName, lastName] = item.get("name").split(" ");
-      map.set("id", item.get("id"));
-      map.set("firstName", firstName);
-      map.set("lastName", lastName);
-      activity.insertContainer(i, map);
-    }
-
-    return doc;
-  },
-
-  3: (doc) => {
-    doc.getMap("metadata").set("version", 3);
-
-    const activity = doc.getList("activity");
-    for (let i = 0; i < activity.length; i++) {
-      const item = activity.get(i) as LoroMap<typeof ActivityV2.Encoded>;
-      const map = new LoroMap();
-      map.set("id", item.get("id"));
-      map.set("firstName", item.get("firstName"));
-      map.set("lastName", item.get("lastName"));
-      map.set("age", undefined);
-      activity.insertContainer(i, map);
-    }
-
-    return doc;
-  },
+  1: (_) => SnapshotSchema.EmptyDoc(),
 } satisfies Record<Version, (doc: LoroDoc) => LoroDoc>;
 
 export const LoroDocMigration = AnyLoroDocSchema.pipe(

packages/schema/src/schema.ts

@@ -1,29 +1,28 @@
 import { Schema } from "effect";
 import { LoroDoc } from "loro-crdt";
+import { VERSION } from "./main";
 import { type Version } from "./versioning";
 
 export const AnyLoroDocSchema = Schema.instanceOf(LoroDoc);
 
-export class ActivityV1 extends Schema.Class<ActivityV1>("ActivityV1")({
+export class FoodV1 extends Schema.Class<FoodV1>("FoodV1")({
   id: Schema.UUID,
   name: Schema.String,
+  calories: Schema.Number.pipe(Schema.positive()),
 }) {}
 
-export class ActivityV2 extends Schema.Class<ActivityV2>("ActivityV2")({
+export class MealV1 extends Schema.Class<MealV1>("MealV1")({
   id: Schema.UUID,
-  firstName: Schema.String,
-  lastName: Schema.String,
+  foodId: FoodV1.fields.id,
+  quantity: Schema.Number.pipe(Schema.positive()),
 }) {}
 
-export class ActivityV3 extends Schema.Class<ActivityV3>("ActivityV3")({
-  id: Schema.UUID,
-  firstName: Schema.String,
-  lastName: Schema.String,
-  age: Schema.UndefinedOr(Schema.Number),
-}) {}
-
-export const ActivitySchema = {
-  1: ActivityV1,
-  2: ActivityV2,
-  3: ActivityV3,
+export const Table = Schema.Literal("food", "meal");
+const VersioningSchema = {
+  1: Schema.Struct({
+    [Table.literals[0]]: Schema.Array(FoodV1),
+    [Table.literals[1]]: Schema.Array(MealV1),
+  }),
 } as const satisfies Record<Version, Schema.Schema.AnyNoContext>;
+
+export const CurrentSchema = VersioningSchema[VERSION];

packages/schema/src/versioning.ts

@@ -1,2 +1,2 @@
-export const Version = [1, 2, 3] as const;
+export const Version = [1] as const;
 export type Version = (typeof Version)[number];