@livestore/common 0.4.0-dev.10 → 0.4.0-dev.12

package/src/schema/EventSequenceNumber.test.ts

@@ -23,7 +23,7 @@ Vitest.describe('EventSequenceNumber', () => {
     expect(EventSequenceNumber.nextPair({ seqNum: e_0_0, isClient: false, rebaseGeneration: 1 }).seqNum).toStrictEqual({
       global: 1,
       client: 0,
-      rebaseGeneration: 0,
+      rebaseGeneration: 1,
     })
     expect(EventSequenceNumber.nextPair({ seqNum: e_0_0, isClient: true, rebaseGeneration: 1 }).seqNum).toStrictEqual({
       global: 0,
@@ -35,7 +35,7 @@ Vitest.describe('EventSequenceNumber', () => {
     expect(EventSequenceNumber.nextPair({ seqNum: e_0_0_g1, isClient: false }).seqNum).toStrictEqual({
       global: 1,
       client: 0,
-      rebaseGeneration: 0,
+      rebaseGeneration: 2,
     })
   })
 

package/src/schema/EventSequenceNumber.ts

@@ -23,7 +23,7 @@ export type EventSequenceNumber = {
   client: ClientEventSequenceNumber
   /**
    * Generation integer that is incremented whenever the client rebased.
-   * Starts from and resets to 0 for each global sequence number.
+   * Remains constant for all subsequent events until another rebase occurs.
    */
   rebaseGeneration: number
 }
@@ -167,6 +167,9 @@ export const make = (seqNum: EventSequenceNumberInput): EventSequenceNumber => {
       })
 }
 
+/**
+ * Computes the next event sequence/parent pair.
+ */
 export const nextPair = ({
   seqNum,
   isClient,
@@ -191,7 +194,7 @@ export const nextPair = ({
     seqNum: {
       global: (seqNum.global + 1) as any as GlobalEventSequenceNumber,
       client: clientDefault,
-      rebaseGeneration: rebaseGenerationDefault,
+      rebaseGeneration: rebaseGeneration ?? seqNum.rebaseGeneration,
     },
     // NOTE we always point to `client: 0` for non-clientOnly events
     parentSeqNum: { global: seqNum.global, client: clientDefault, rebaseGeneration: seqNum.rebaseGeneration },

package/src/schema/state/sqlite/column-def.ts

@@ -206,10 +206,18 @@ const getColumnForSchema = (schema: Schema.Schema.AnyNoContext, nullable = false
 const stripNullable = (ast: SchemaAST.AST): SchemaAST.AST => {
   if (!SchemaAST.isUnion(ast)) return ast
 
-  // Find non-null/undefined type
-  const core = ast.types.find(
+  // Filter out null/undefined members while preserving any annotations on the union
+  const coreTypes = ast.types.filter(
     (type) => !(SchemaAST.isLiteral(type) && type.literal === null) && !SchemaAST.isUndefinedKeyword(type),
   )
 
-  return core || ast
+  if (coreTypes.length === 0 || coreTypes.length === ast.types.length) {
+    return ast
+  }
+
+  if (coreTypes.length === 1) {
+    return coreTypes[0]!
+  }
+
+  return SchemaAST.Union.make(coreTypes, ast.annotations)
 }

package/src/schema/state/sqlite/table-def.test.ts

@@ -300,4 +300,52 @@ describe('table function overloads', () => {
     expect(userTable.sqliteDef.columns.metadata.columnType).toBe('text')
     expect(userTable.sqliteDef.columns.metadata.nullable).toBe(true)
   })
+
+  it('supports discriminated unions with parsed JSON payloads', () => {
+    const CircleDataSchema = Schema.Struct({
+      radius: Schema.Number,
+    })
+    const CircleSchema = Schema.Struct({
+      kind: Schema.Literal('circle'),
+      data: Schema.parseJson(CircleDataSchema),
+    })
+
+    const SquareDataSchema = Schema.Struct({
+      sideLength: Schema.Number,
+    })
+    const SquareSchema = Schema.Struct({
+      kind: Schema.Literal('square'),
+      data: Schema.parseJson(SquareDataSchema),
+    })
+
+    const ShapeSchema = Schema.Union(CircleSchema, SquareSchema)
+
+    const shapes = State.SQLite.table({
+      name: 'shapes',
+      schema: ShapeSchema,
+    })
+
+    expect(shapes.sqliteDef.columns.kind.columnType).toBe('text')
+
+    const kindSchema = shapes.sqliteDef.columns.kind.schema.toString()
+    expect(kindSchema).toContain('"circle" | "square"')
+
+    expect(() =>
+      shapes
+        .insert({
+          kind: 'square',
+          data: { sideLength: 10 },
+        })
+        .asSql(),
+    ).not.toThrow()
+
+    expect(() =>
+      shapes
+        .insert({
+          kind: 'circle',
+          data: { radius: 5 },
+        })
+        .asSql(),
+    ).not.toThrow()
+  })
 })

package/src/sync/ClientSessionSyncProcessor.ts

@@ -115,6 +115,7 @@ export const makeClientSessionSyncProcessor = ({
       const nextNumPair = EventSequenceNumber.nextPair({
         seqNum: baseEventSequenceNumber,
         isClient: eventDef.options.clientOnly,
+        rebaseGeneration: baseEventSequenceNumber.rebaseGeneration,
       })
       baseEventSequenceNumber = nextNumPair.seqNum
       return new LiveStoreEvent.EncodedWithMeta(

package/src/sync/syncstate.test.ts

@@ -5,15 +5,16 @@ import * as LiveStoreEvent from '../schema/LiveStoreEvent.ts'
 import * as SyncState from './syncstate.ts'
 
 class TestEvent extends LiveStoreEvent.EncodedWithMeta {
-  public readonly payload: string
-  public readonly isClient: boolean
-  constructor(
+  public payload = 'uninitialized'
+  public isClient = false
+
+  static new = (
     seqNum: EventSequenceNumber.EventSequenceNumberInput,
     parentSeqNum: EventSequenceNumber.EventSequenceNumberInput,
     payload: string,
     isClient: boolean,
-  ) {
-    super({
+  ) => {
+    const event = new TestEvent({
       seqNum: EventSequenceNumber.make(seqNum),
       parentSeqNum: EventSequenceNumber.make(parentSeqNum),
       name: 'a',
@@ -21,8 +22,9 @@ class TestEvent extends LiveStoreEvent.EncodedWithMeta {
       clientId: 'static-local-id',
       sessionId: 'static-session-id',
     })
-    this.payload = payload
-    this.isClient = isClient
+    event.payload = payload
+    event.isClient = isClient
+    return event
   }
 
   rebase_ = (parentSeqNum: EventSequenceNumber.EventSequenceNumber, rebaseGeneration: number) => {
@@ -34,13 +36,13 @@ class TestEvent extends LiveStoreEvent.EncodedWithMeta {
   // toString = () => this.toJSON()
 }
 
-const e0_1 = new TestEvent({ global: 0, client: 1 }, EventSequenceNumber.ROOT, 'a', true)
-const e1_0 = new TestEvent({ global: 1, client: 0 }, EventSequenceNumber.ROOT, 'a', false)
-const e1_1 = new TestEvent({ global: 1, client: 1 }, e1_0.seqNum, 'a', true)
-const e1_2 = new TestEvent({ global: 1, client: 2 }, e1_1.seqNum, 'a', true)
-const e1_3 = new TestEvent({ global: 1, client: 3 }, e1_2.seqNum, 'a', true)
-const e2_0 = new TestEvent({ global: 2, client: 0 }, e1_0.seqNum, 'a', false)
-const e2_1 = new TestEvent({ global: 2, client: 1 }, e2_0.seqNum, 'a', true)
+const e0_1 = TestEvent.new({ global: 0, client: 1 }, EventSequenceNumber.ROOT, 'a', true)
+const e1_0 = TestEvent.new({ global: 1, client: 0 }, EventSequenceNumber.ROOT, 'a', false)
+const e1_1 = TestEvent.new({ global: 1, client: 1 }, e1_0.seqNum, 'a', true)
+const e1_2 = TestEvent.new({ global: 1, client: 2 }, e1_1.seqNum, 'a', true)
+const e1_3 = TestEvent.new({ global: 1, client: 3 }, e1_2.seqNum, 'a', true)
+const e2_0 = TestEvent.new({ global: 2, client: 0 }, e1_0.seqNum, 'a', false)
+const e2_1 = TestEvent.new({ global: 2, client: 1 }, e2_0.seqNum, 'a', true)
 
 const isEqualEvent = LiveStoreEvent.isEqualEncoded
 
@@ -340,7 +342,7 @@ describe('syncstate', () => {
       })
 
       it('should rebase different event with same id', () => {
-        const e2_0_b = new TestEvent({ global: 1, client: 0 }, e1_0.seqNum, '1_0_b', false)
+        const e2_0_b = TestEvent.new({ global: 1, client: 0 }, e1_0.seqNum, '1_0_b', false)
         const syncState = new SyncState.SyncState({
           pending: [e2_0_b],
           upstreamHead: EventSequenceNumber.ROOT,

package/src/version.ts

@@ -2,7 +2,7 @@
 // import packageJson from '../package.json' with { type: 'json' }
 // export const liveStoreVersion = packageJson.version
 
-export const liveStoreVersion = '0.4.0-dev.10' as const
+export const liveStoreVersion = '0.4.0-dev.12' as const
 
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.