@livestore/common 0.3.0-dev.9 → 0.3.1-dev.0

package/src/schema/schema.ts

@@ -1,123 +1,127 @@
-import type { SqliteDsl } from '@livestore/db-schema'
-import { SqliteAst } from '@livestore/db-schema'
 import { isReadonlyArray, shouldNeverHappen } from '@livestore/utils'
 
 import type { MigrationOptions } from '../adapter-types.js'
-import { makeDerivedMutationDefsForTable } from '../derived-mutations.js'
-import {
-  type MutationDef,
-  type MutationDefMap,
-  type MutationDefRecord,
-  type RawSqlMutation,
-  rawSqlMutation,
-} from './mutations.js'
-import { systemTables } from './system-tables.js'
-import type { TableDef, TableDefBase } from './table-def.js'
-import { tableHasDerivedMutations } from './table-def.js'
+import type { EventDef, EventDefRecord, Materializer, RawSqlEvent } from './EventDef.js'
+import { rawSqlEvent } from './EventDef.js'
+import { tableIsClientDocumentTable } from './state/sqlite/client-document-def.js'
+import type { SqliteDsl } from './state/sqlite/db-schema/mod.js'
+import { stateSystemTables } from './state/sqlite/system-tables.js'
+import type { TableDef } from './state/sqlite/table-def.js'
 
 export const LiveStoreSchemaSymbol = Symbol.for('livestore.LiveStoreSchema')
 export type LiveStoreSchemaSymbol = typeof LiveStoreSchemaSymbol
 
-export type LiveStoreSchema<
+export interface LiveStoreSchema<
   TDbSchema extends SqliteDsl.DbSchema = SqliteDsl.DbSchema,
-  TMutationsDefRecord extends MutationDefRecord = MutationDefRecord,
-> = {
-  readonly _Type: LiveStoreSchemaSymbol
+  TEventsDefRecord extends EventDefRecord = EventDefRecord,
+> {
+  readonly LiveStoreSchemaSymbol: LiveStoreSchemaSymbol
   /** Only used on type-level */
   readonly _DbSchemaType: TDbSchema
   /** Only used on type-level */
-  readonly _MutationDefMapType: TMutationsDefRecord
+  readonly _EventDefMapType: TEventsDefRecord
 
-  readonly tables: Map<string, TableDef>
-  readonly mutations: MutationDefMap
-  /** Compound hash of all table defs etc */
-  readonly hash: number
+  readonly state: InternalState
+  readonly eventsDefsMap: Map<string, EventDef.AnyWithoutFn>
+  readonly devtools: {
+    /** @default 'default' */
+    readonly alias: string
+  }
+}
 
-  migrationOptions: MigrationOptions
+// TODO abstract this further away from sqlite/tables
+export interface InternalState {
+  readonly sqlite: {
+    readonly tables: Map<string, TableDef.Any>
+    readonly migrations: MigrationOptions
+    /** Compound hash of all table defs etc */
+    readonly hash: number
+  }
+  readonly materializers: Map<string, Materializer>
 }
 
-export type InputSchema = {
-  readonly tables: Record<string, TableDefBase> | ReadonlyArray<TableDefBase>
-  readonly mutations?: ReadonlyArray<MutationDef.Any> | Record<string, MutationDef.Any>
-  /**
-   * Can be used to isolate multiple LiveStore apps running in the same origin
-   */
-  // TODO remove this in favour of storeId
-  readonly key?: string
+export interface InputSchema {
+  readonly events: ReadonlyArray<EventDef.AnyWithoutFn> | Record<string, EventDef.AnyWithoutFn>
+  readonly state: InternalState
+  readonly devtools?: {
+    /**
+     * This alias value is used to disambiguate between multiple schemas in the devtools.
+     * Only needed when an app uses multiple schemas.
+     *
+     * @default 'default'
+     */
+    readonly alias?: string
+  }
 }
 
 export const makeSchema = <TInputSchema extends InputSchema>(
-  /** Note when using the object-notation for tables/mutations, the object keys are ignored and not used as table/mutation names */
-  inputSchema: TInputSchema & {
-    /** "hard-reset" is currently the default strategy */
-    migrations?: MigrationOptions<FromInputSchema.DeriveSchema<TInputSchema>>
-  },
+  /** Note when using the object-notation for tables/events, the object keys are ignored and not used as table/mutation names */
+  inputSchema: TInputSchema,
 ): FromInputSchema.DeriveSchema<TInputSchema> => {
-  const inputTables: ReadonlyArray<TableDef> = Array.isArray(inputSchema.tables)
-    ? inputSchema.tables
-    : Object.values(inputSchema.tables)
+  const state = inputSchema.state
+  const tables = inputSchema.state.sqlite.tables
 
-  const tables = new Map<string, TableDef>()
-
-  for (const tableDef of inputTables) {
-    // TODO validate tables (e.g. index names are unique)
-    if (tables.has(tableDef.sqliteDef.ast.name)) {
-      shouldNeverHappen(`Duplicate table name: ${tableDef.sqliteDef.ast.name}. Please use unique names for tables.`)
-    }
-    tables.set(tableDef.sqliteDef.ast.name, tableDef)
-  }
-
-  for (const tableDef of systemTables) {
-    // @ts-expect-error TODO fix type level issue
+  for (const tableDef of stateSystemTables) {
     tables.set(tableDef.sqliteDef.name, tableDef)
   }
 
-  const mutations: MutationDefMap = new Map()
+  const eventsDefsMap = new Map<string, EventDef.AnyWithoutFn>()
 
-  if (isReadonlyArray(inputSchema.mutations)) {
-    for (const mutation of inputSchema.mutations) {
-      mutations.set(mutation.name, mutation)
+  if (isReadonlyArray(inputSchema.events)) {
+    for (const eventDef of inputSchema.events) {
+      eventsDefsMap.set(eventDef.name, eventDef)
     }
   } else {
-    for (const mutation of Object.values(inputSchema.mutations ?? {})) {
-      if (mutations.has(mutation.name)) {
-        shouldNeverHappen(`Duplicate mutation name: ${mutation.name}. Please use unique names for mutations.`)
+    for (const eventDef of Object.values(inputSchema.events ?? {})) {
+      if (eventsDefsMap.has(eventDef.name)) {
+        shouldNeverHappen(`Duplicate event name: ${eventDef.name}. Please use unique names for events.`)
       }
-      mutations.set(mutation.name, mutation)
+      eventsDefsMap.set(eventDef.name, eventDef)
     }
   }
 
-  mutations.set(rawSqlMutation.name, rawSqlMutation)
+  eventsDefsMap.set(rawSqlEvent.name, rawSqlEvent)
 
   for (const tableDef of tables.values()) {
-    if (tableHasDerivedMutations(tableDef)) {
-      const derivedMutationDefs = makeDerivedMutationDefsForTable(tableDef)
-      mutations.set(derivedMutationDefs.insert.name, derivedMutationDefs.insert)
-      mutations.set(derivedMutationDefs.update.name, derivedMutationDefs.update)
-      mutations.set(derivedMutationDefs.delete.name, derivedMutationDefs.delete)
+    if (tableIsClientDocumentTable(tableDef) && eventsDefsMap.has(tableDef.set.name) === false) {
+      eventsDefsMap.set(tableDef.set.name, tableDef.set)
     }
   }
 
-  const hash = SqliteAst.hash({
-    _tag: 'dbSchema',
-    tables: [...tables.values()].map((_) => _.sqliteDef.ast),
-  })
-
   return {
-    _Type: LiveStoreSchemaSymbol,
+    LiveStoreSchemaSymbol,
     _DbSchemaType: Symbol.for('livestore.DbSchemaType') as any,
-    _MutationDefMapType: Symbol.for('livestore.MutationDefMapType') as any,
-    tables,
-    mutations,
-    migrationOptions: inputSchema.migrations ?? { strategy: 'hard-reset' },
-    hash,
+    _EventDefMapType: Symbol.for('livestore.EventDefMapType') as any,
+    state,
+    eventsDefsMap,
+    devtools: {
+      alias: inputSchema.devtools?.alias ?? 'default',
+    },
   } satisfies LiveStoreSchema
 }
 
+export const getEventDef = <TSchema extends LiveStoreSchema>(
+  schema: TSchema,
+  eventName: string,
+): {
+  eventDef: EventDef.AnyWithoutFn
+  materializer: Materializer
+} => {
+  const eventDef = schema.eventsDefsMap.get(eventName)
+  if (eventDef === undefined) {
+    return shouldNeverHappen(`No mutation definition found for \`${eventName}\`.`)
+  }
+  const materializer = schema.state.materializers.get(eventName)
+  if (materializer === undefined) {
+    return shouldNeverHappen(`No materializer found for \`${eventName}\`.`)
+  }
+  return { eventDef, materializer }
+}
+
 export namespace FromInputSchema {
   export type DeriveSchema<TInputSchema extends InputSchema> = LiveStoreSchema<
-    DbSchemaFromInputSchemaTables<TInputSchema['tables']>,
-    MutationDefRecordFromInputSchemaMutations<TInputSchema['mutations']>
+    DbSchemaFromInputSchemaTables<TInputSchema['state']['sqlite']['tables']>,
+    EventDefRecordFromInputSchemaEvents<TInputSchema['events']>
   >
 
   /**
@@ -125,17 +129,17 @@ export namespace FromInputSchema {
    * - array: we use the table name of each array item (= table definition) as the object key
    * - object: we discard the keys of the input object and use the table name of each object value (= table definition) as the new object key
    */
-  type DbSchemaFromInputSchemaTables<TTables extends InputSchema['tables']> =
+  type DbSchemaFromInputSchemaTables<TTables extends InputSchema['state']['sqlite']['tables']> =
     TTables extends ReadonlyArray<TableDef>
       ? { [K in TTables[number] as K['sqliteDef']['name']]: K['sqliteDef'] }
       : TTables extends Record<string, TableDef>
         ? { [K in keyof TTables as TTables[K]['sqliteDef']['name']]: TTables[K]['sqliteDef'] }
         : never
 
-  type MutationDefRecordFromInputSchemaMutations<TMutations extends InputSchema['mutations']> =
-    TMutations extends ReadonlyArray<MutationDef.Any>
-      ? { [K in TMutations[number] as K['name']]: K } & { 'livestore.RawSql': RawSqlMutation }
-      : TMutations extends { [name: string]: MutationDef.Any }
-        ? { [K in keyof TMutations as TMutations[K]['name']]: TMutations[K] } & { 'livestore.RawSql': RawSqlMutation }
+  type EventDefRecordFromInputSchemaEvents<TEvents extends InputSchema['events']> =
+    TEvents extends ReadonlyArray<EventDef.Any>
+      ? { [K in TEvents[number] as K['name']]: K } & { 'livestore.RawSql': RawSqlEvent }
+      : TEvents extends { [name: string]: EventDef.Any }
+        ? { [K in keyof TEvents as TEvents[K]['name']]: TEvents[K] } & { 'livestore.RawSql': RawSqlEvent }
         : never
 }

package/src/schema/state/mod.ts

@@ -0,0 +1,2 @@
+export * as SQLite from './sqlite/mod.js'
+export { QueryBuilderAstSymbol, QueryBuilderTypeId } from './sqlite/query-builder/mod.js'

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

@@ -0,0 +1,238 @@
+import { Schema } from '@livestore/utils/effect'
+import { describe, expect, test } from 'vitest'
+
+import { tables } from '../../../__tests__/fixture.js'
+import type * as LiveStoreEvent from '../../LiveStoreEvent.js'
+import { clientDocument, ClientDocumentTableDefSymbol } from './client-document-def.js'
+
+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, {
+        currentFacts: new Map(),
+        query: {} as any, // unused
+        eventDef: Doc[ClientDocumentTableDefSymbol].derived.setEventDef,
+      })
+    }
+
+    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 }
+}