@livestore/common 0.0.0-snapshot-2ef046b02334f52613d31dbe06af53487685edc0 → 0.0.0-snapshot-8115ad48d5a57244358c943ecc92bb0a30274b87

package/src/schema/{MutationEvent.ts → LiveStoreEvent.ts}

@@ -1,133 +1,132 @@
 import { memoizeByRef } from '@livestore/utils'
 import { Option, Schema } from '@livestore/utils/effect'
 
+import type { EventDef, EventDefRecord } from './EventDef.js'
 import * as EventId from './EventId.js'
-import type { MutationDef, MutationDefRecord } from './mutations.js'
 import type { LiveStoreSchema } from './schema.js'
 
-export type MutationEventPartial<TMutationsDef extends MutationDef.Any> = {
-  mutation: TMutationsDef['name']
-  args: Schema.Schema.Type<TMutationsDef['schema']>
+export type EventDefPartial<TEventDef extends EventDef.Any> = {
+  name: TEventDef['name']
+  args: Schema.Schema.Type<TEventDef['schema']>
 }
 
-export type PartialEncoded<TMutationsDef extends MutationDef.Any> = {
-  mutation: TMutationsDef['name']
-  args: Schema.Schema.Encoded<TMutationsDef['schema']>
+export type PartialEncoded<TEventDef extends EventDef.Any> = {
+  name: TEventDef['name']
+  args: Schema.Schema.Encoded<TEventDef['schema']>
 }
 
-export type MutationEvent<TMutationsDef extends MutationDef.Any> = {
-  mutation: TMutationsDef['name']
-  args: Schema.Schema.Type<TMutationsDef['schema']>
+export type ForEventDef<TEventDef extends EventDef.Any> = {
+  name: TEventDef['name']
+  args: Schema.Schema.Type<TEventDef['schema']>
   id: EventId.EventId
   parentId: EventId.EventId
   clientId: string
   sessionId: string
 }
 
-export type MutationEventEncoded<TMutationsDef extends MutationDef.Any> = {
-  mutation: TMutationsDef['name']
-  args: Schema.Schema.Encoded<TMutationsDef['schema']>
+export type EventDefEncoded<TEventDef extends EventDef.Any> = {
+  name: TEventDef['name']
+  args: Schema.Schema.Encoded<TEventDef['schema']>
   id: EventId.EventId
   parentId: EventId.EventId
   clientId: string
   sessionId: string
 }
 
-export type AnyDecoded = MutationEvent<MutationDef.Any>
+export type AnyDecoded = ForEventDef<EventDef.Any>
 export const AnyDecoded = Schema.Struct({
-  mutation: Schema.String,
+  name: Schema.String,
   args: Schema.Any,
   id: EventId.EventId,
   parentId: EventId.EventId,
   clientId: Schema.String,
   sessionId: Schema.String,
-}).annotations({ title: 'MutationEvent.AnyDecoded' })
+}).annotations({ title: 'LiveStoreEvent.AnyDecoded' })
 
-export type AnyEncoded = MutationEventEncoded<MutationDef.Any>
+export type AnyEncoded = EventDefEncoded<EventDef.Any>
 export const AnyEncoded = Schema.Struct({
-  mutation: Schema.String,
+  name: Schema.String,
   args: Schema.Any,
   id: EventId.EventId,
   parentId: EventId.EventId,
   clientId: Schema.String,
   sessionId: Schema.String,
-}).annotations({ title: 'MutationEvent.AnyEncoded' })
+}).annotations({ title: 'LiveStoreEvent.AnyEncoded' })
 
 export const AnyEncodedGlobal = Schema.Struct({
-  mutation: Schema.String,
+  name: Schema.String,
   args: Schema.Any,
   id: EventId.GlobalEventId,
   parentId: EventId.GlobalEventId,
   clientId: Schema.String,
   sessionId: Schema.String,
-}).annotations({ title: 'MutationEvent.AnyEncodedGlobal' })
+}).annotations({ title: 'LiveStoreEvent.AnyEncodedGlobal' })
 export type AnyEncodedGlobal = typeof AnyEncodedGlobal.Type
 
-export type PartialAnyDecoded = MutationEventPartial<MutationDef.Any>
-export type PartialAnyEncoded = PartialEncoded<MutationDef.Any>
+export type PartialAnyDecoded = EventDefPartial<EventDef.Any>
+export type PartialAnyEncoded = PartialEncoded<EventDef.Any>
 
 export const PartialAnyEncoded = Schema.Struct({
-  mutation: Schema.String,
+  name: Schema.String,
   args: Schema.Any,
 })
 
 export type PartialForSchema<TSchema extends LiveStoreSchema> = {
-  [K in keyof TSchema['_MutationDefMapType']]: MutationEventPartial<TSchema['_MutationDefMapType'][K]>
-}[keyof TSchema['_MutationDefMapType']]
+  [K in keyof TSchema['_EventDefMapType']]: EventDefPartial<TSchema['_EventDefMapType'][K]>
+}[keyof TSchema['_EventDefMapType']]
 
 export type ForSchema<TSchema extends LiveStoreSchema> = {
-  [K in keyof TSchema['_MutationDefMapType']]: MutationEvent<TSchema['_MutationDefMapType'][K]>
-}[keyof TSchema['_MutationDefMapType']]
+  [K in keyof TSchema['_EventDefMapType']]: ForEventDef<TSchema['_EventDefMapType'][K]>
+}[keyof TSchema['_EventDefMapType']]
 
-export const isPartialMutationEvent = (
-  mutationEvent: AnyDecoded | PartialAnyDecoded,
-): mutationEvent is PartialAnyDecoded => 'id' in mutationEvent === false && 'parentId' in mutationEvent === false
+export const isPartialEventDef = (event: AnyDecoded | PartialAnyDecoded): event is PartialAnyDecoded =>
+  'id' in event === false && 'parentId' in event === false
 
-export type ForMutationDefRecord<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
+export type ForEventDefRecord<TEventDefRecord extends EventDefRecord> = Schema.Schema<
   {
-    [K in keyof TMutationsDefRecord]: {
-      mutation: K
-      args: Schema.Schema.Type<TMutationsDefRecord[K]['schema']>
+    [K in keyof TEventDefRecord]: {
+      name: K
+      args: Schema.Schema.Type<TEventDefRecord[K]['schema']>
       id: EventId.EventId
       parentId: EventId.EventId
       clientId: string
       sessionId: string
     }
-  }[keyof TMutationsDefRecord],
+  }[keyof TEventDefRecord],
   {
-    [K in keyof TMutationsDefRecord]: {
-      mutation: K
-      args: Schema.Schema.Encoded<TMutationsDefRecord[K]['schema']>
+    [K in keyof TEventDefRecord]: {
+      name: K
+      args: Schema.Schema.Encoded<TEventDefRecord[K]['schema']>
       id: EventId.EventId
       parentId: EventId.EventId
       clientId: string
       sessionId: string
     }
-  }[keyof TMutationsDefRecord]
+  }[keyof TEventDefRecord]
 >
 
-export type MutationEventPartialSchema<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
+export type EventDefPartialSchema<TEventDefRecord extends EventDefRecord> = Schema.Schema<
   {
-    [K in keyof TMutationsDefRecord]: {
-      mutation: K
-      args: Schema.Schema.Type<TMutationsDefRecord[K]['schema']>
+    [K in keyof TEventDefRecord]: {
+      name: K
+      args: Schema.Schema.Type<TEventDefRecord[K]['schema']>
     }
-  }[keyof TMutationsDefRecord],
+  }[keyof TEventDefRecord],
   {
-    [K in keyof TMutationsDefRecord]: {
-      mutation: K
-      args: Schema.Schema.Encoded<TMutationsDefRecord[K]['schema']>
+    [K in keyof TEventDefRecord]: {
+      name: K
+      args: Schema.Schema.Encoded<TEventDefRecord[K]['schema']>
     }
-  }[keyof TMutationsDefRecord]
+  }[keyof TEventDefRecord]
 >
 
-export const makeMutationEventSchema = <TSchema extends LiveStoreSchema>(
+export const makeEventDefSchema = <TSchema extends LiveStoreSchema>(
   schema: TSchema,
-): ForMutationDefRecord<TSchema['_MutationDefMapType']> =>
+): ForEventDefRecord<TSchema['_EventDefMapType']> =>
   Schema.Union(
-    ...[...schema.mutations.map.values()].map((def) =>
+    ...[...schema.eventsDefsMap.values()].map((def) =>
       Schema.Struct({
-        mutation: Schema.Literal(def.name),
+        name: Schema.Literal(def.name),
         args: def.schema,
         id: EventId.EventId,
         parentId: EventId.EventId,
@@ -135,25 +134,25 @@ export const makeMutationEventSchema = <TSchema extends LiveStoreSchema>(
         sessionId: Schema.String,
       }),
     ),
-  ).annotations({ title: 'MutationEvent' }) as any
+  ).annotations({ title: 'EventDef' }) as any
 
-export const makeMutationEventPartialSchema = <TSchema extends LiveStoreSchema>(
+export const makeEventDefPartialSchema = <TSchema extends LiveStoreSchema>(
   schema: TSchema,
-): MutationEventPartialSchema<TSchema['_MutationDefMapType']> =>
+): EventDefPartialSchema<TSchema['_EventDefMapType']> =>
   Schema.Union(
-    ...[...schema.mutations.map.values()].map((def) =>
+    ...[...schema.eventsDefsMap.values()].map((def) =>
       Schema.Struct({
-        mutation: Schema.Literal(def.name),
+        name: Schema.Literal(def.name),
         args: def.schema,
       }),
     ),
-  ).annotations({ title: 'MutationEventPartial' }) as any
+  ).annotations({ title: 'EventDefPartial' }) as any
 
-export const makeMutationEventSchemaMemo = memoizeByRef(makeMutationEventSchema)
+export const makeEventDefSchemaMemo = memoizeByRef(makeEventDefSchema)
 
 /** Equivalent to AnyEncoded but with a meta field and some convenience methods */
-export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEvent.EncodedWithMeta')({
-  mutation: Schema.String,
+export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('LiveStoreEvent.EncodedWithMeta')({
+  name: Schema.String,
   args: Schema.Any,
   // TODO rename to `.num` / `.parentNum`
   id: EventId.EventId,
@@ -185,8 +184,8 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
     // - More readable way to print the id + parentId
     // - not including `meta`, `clientId`, `sessionId`
     return {
-      id: `${EventId.toString(this.id)} → ${EventId.toString(this.parentId)}`,
-      mutation: this.mutation,
+      id: `${EventId.toString(this.id)} → ${EventId.toString(this.parentId)} (${this.clientId}, ${this.sessionId})`,
+      name: this.name,
       args: this.args,
     }
   }
@@ -214,11 +213,11 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
       ...EventId.nextPair(parentId, isClient),
     })
 
-  static fromGlobal = (mutationEvent: AnyEncodedGlobal, syncMetadata: Option.Option<Schema.JsonValue>) =>
+  static fromGlobal = (event: AnyEncodedGlobal, syncMetadata: Option.Option<Schema.JsonValue>) =>
     new EncodedWithMeta({
-      ...mutationEvent,
-      id: { global: mutationEvent.id, client: EventId.clientDefault },
-      parentId: { global: mutationEvent.parentId, client: EventId.clientDefault },
+      ...event,
+      id: { global: event.id, client: EventId.clientDefault },
+      parentId: { global: event.parentId, client: EventId.clientDefault },
       meta: { sessionChangeset: { _tag: 'unset' as const }, syncMetadata },
     })
 
@@ -233,7 +232,7 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
 export const isEqualEncoded = (a: AnyEncoded, b: AnyEncoded) =>
   a.id.global === b.id.global &&
   a.id.client === b.id.client &&
-  a.mutation === b.mutation &&
+  a.name === b.name &&
   a.clientId === b.clientId &&
   a.sessionId === b.sessionId &&
   // TODO use schema equality here

package/src/schema/client-document-def.test.ts

@@ -0,0 +1,239 @@
+import { Schema } from '@livestore/utils/effect'
+import { describe, expect, test } from 'vitest'
+
+import { tables } from '../__tests__/fixture.js'
+import { clientDocument, ClientDocumentTableDefSymbol } from './client-document-def.js'
+import type * as LiveStoreEvent from './LiveStoreEvent.js'
+
+const materializerContext = {
+  currentFacts: new Map(),
+  clientOnly: false,
+}
+
+describe('client document table', () => {
+  test('set event', () => {
+    expect(patchId(tables.UiState.set({ showSidebar: false }, 'session-1'))).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "id": "session-1",
+          "value": {
+            "showSidebar": false,
+          },
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "name": "UiStateSet",
+      }
+    `)
+
+    expect(patchId(tables.appConfig.set({ fontSize: 12, theme: 'dark' }))).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "id": "static",
+          "value": {
+            "fontSize": 12,
+            "theme": "dark",
+          },
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "name": "AppConfigSet",
+      }
+    `)
+  })
+
+  describe('materializer', () => {
+    const forSchema = <T>(schema: Schema.Schema<T, any>, value: T, id?: string, options?: { partialSet?: boolean }) => {
+      const Doc = clientDocument({
+        name: 'test',
+        schema,
+        default: { value },
+        ...options,
+      })
+
+      const materializer = Doc[ClientDocumentTableDefSymbol].derived.setMaterializer
+
+      return materializer(Doc.set(value, id as any).args, materializerContext)
+    }
+
+    test('string value', () => {
+      expect(forSchema(Schema.String, 'hello', 'id1')).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "id1",
+            ""hello"",
+            ""hello"",
+          ],
+          "sql": "INSERT INTO 'test' (id, value) VALUES (?, ?) ON CONFLICT (id) DO UPDATE SET value = ?",
+          "writeTables": Set {
+            "test",
+          },
+        }
+      `)
+    })
+
+    test('struct value (partial set=true)', () => {
+      expect(forSchema(Schema.Struct({ a: Schema.String }), { a: 'hello' }, 'id1', { partialSet: true }))
+        .toMatchInlineSnapshot(`
+          {
+            "bindValues": [
+              "id1",
+              "{"a":"hello"}",
+              "$.a",
+              ""hello"",
+            ],
+            "sql": "
+                INSERT INTO 'test' (id, value)
+                VALUES (?, ?)
+                ON CONFLICT (id) DO UPDATE SET value = json_set(value, ?, json(?))
+              ",
+            "writeTables": Set {
+              "test",
+            },
+          }
+        `)
+    })
+
+    test('struct value (partial set=false)', () => {
+      expect(forSchema(Schema.Struct({ a: Schema.String }), { a: 'hello' }, 'id1', { partialSet: false }))
+        .toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "id1",
+            "{"a":"hello"}",
+            "{"a":"hello"}",
+          ],
+          "sql": "INSERT INTO 'test' (id, value) VALUES (?, ?) ON CONFLICT (id) DO UPDATE SET value = ?",
+          "writeTables": Set {
+            "test",
+          },
+        }
+      `)
+    })
+
+    test('struct value (partial set=true) advanced', () => {
+      expect(
+        forSchema(
+          Schema.Struct({ a: Schema.String, b: Schema.String, c: Schema.Number }),
+          { a: 'hello', c: 123 } as any,
+          'id1',
+          { partialSet: true },
+        ),
+      ).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "id1",
+            "{"a":"hello","c":123}",
+            "$.a",
+            ""hello"",
+            "$.c",
+            "123",
+          ],
+          "sql": "
+              INSERT INTO 'test' (id, value)
+              VALUES (?, ?)
+              ON CONFLICT (id) DO UPDATE SET value = json_set(json_set(value, ?, json(?)), ?, json(?))
+            ",
+          "writeTables": Set {
+            "test",
+          },
+        }
+      `)
+    })
+
+    test('struct value (partial set=true), explicit undefined, filter out undefined values', () => {
+      expect(
+        forSchema(
+          Schema.Struct({ a: Schema.String.pipe(Schema.optional), b: Schema.String }),
+          { a: undefined, b: 'hello' },
+          'id1',
+          {
+            partialSet: true,
+          },
+        ),
+      ).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "id1",
+            "{"b":"hello"}",
+            "$.b",
+            ""hello"",
+          ],
+          "sql": "
+              INSERT INTO 'test' (id, value)
+              VALUES (?, ?)
+              ON CONFLICT (id) DO UPDATE SET value = json_set(value, ?, json(?))
+            ",
+          "writeTables": Set {
+            "test",
+          },
+        }
+      `)
+    })
+
+    test('struct value (partial set=true), explicit undefined, nothing to update', () => {
+      expect(
+        forSchema(Schema.Struct({ a: Schema.String.pipe(Schema.optional) }), { a: undefined }, 'id1', {
+          partialSet: true,
+        }),
+      ).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "id1",
+            "{}",
+          ],
+          "sql": "
+              INSERT INTO 'test' (id, value)
+              VALUES (?, ?)
+              ON CONFLICT (id) DO NOTHING
+            ",
+          "writeTables": Set {
+            "test",
+          },
+        }
+      `)
+    })
+
+    test('struct union value', () => {
+      expect(
+        forSchema(
+          Schema.Union(Schema.Struct({ a: Schema.String }), Schema.Struct({ b: Schema.String })),
+          { a: 'hello' },
+          'id1',
+        ),
+      ).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "id1",
+            "{"a":"hello"}",
+            "{"a":"hello"}",
+          ],
+          "sql": "INSERT INTO 'test' (id, value) VALUES (?, ?) ON CONFLICT (id) DO UPDATE SET value = ?",
+          "writeTables": Set {
+            "test",
+          },
+        }
+      `)
+    })
+
+    test('array value', () => {
+      expect(forSchema(Schema.Array(Schema.String), ['hello', 'world'], 'id1')).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "id1",
+            "["hello","world"]",
+            "["hello","world"]",
+          ],
+          "sql": "INSERT INTO 'test' (id, value) VALUES (?, ?) ON CONFLICT (id) DO UPDATE SET value = ?",
+          "writeTables": Set {
+            "test",
+          },
+        }
+      `)
+    })
+  })
+})
+
+const patchId = (muationEvent: LiveStoreEvent.PartialAnyDecoded) => {
+  // TODO use new id paradigm
+  const id = `00000000-0000-0000-0000-000000000000`
+  return { ...muationEvent, id }
+}