@livestore/common 0.0.58-dev.1 → 0.0.58-dev.11

package/src/schema/index.ts

@@ -1,6 +1,6 @@
+import type { SqliteDsl } from '@livestore/db-schema'
+import { SqliteAst } from '@livestore/db-schema'
 import { isReadonlyArray, shouldNeverHappen } from '@livestore/utils'
-import type { SqliteDsl } from 'effect-db-schema'
-import { SqliteAst } from 'effect-db-schema'
 
 import type { MigrationOptions } from '../adapter-types.js'
 import { makeDerivedMutationDefsForTable } from '../derived-mutations.js'
@@ -46,6 +46,7 @@ export type InputSchema = {
   /**
    * Can be used to isolate multiple LiveStore apps running in the same origin
    */
+  // TODO remove this in favour of storeId
   readonly key?: string
 }
 
@@ -116,7 +117,7 @@ export const makeSchema = <TInputSchema extends InputSchema>(
   } satisfies LiveStoreSchema
 }
 
-namespace FromInputSchema {
+export namespace FromInputSchema {
   export type DeriveSchema<TInputSchema extends InputSchema> = LiveStoreSchema<
     DbSchemaFromInputSchemaTables<TInputSchema['tables']>,
     MutationDefRecordFromInputSchemaMutations<TInputSchema['mutations']>

package/src/schema/mutations.ts

@@ -1,7 +1,7 @@
 import { memoizeByRef } from '@livestore/utils'
-import { cuid } from '@livestore/utils/cuid'
 import { Schema } from '@livestore/utils/effect'
 
+import { EventId } from '../adapter-types.js'
 import type { BindValues } from '../sql-queries/sql-queries.js'
 import type { LiveStoreSchema } from './index.js'
 
@@ -35,42 +35,131 @@ export type SingleOrReadonlyArray<T> = T | ReadonlyArray<T>
 export type MutationDef<TName extends string, TFrom, TTo> = {
   name: TName
   schema: Schema.Schema<TTo, TFrom>
-  sql: MutationDefSqlResult<TTo>
+  sql: MutationDefSqlResult<NoInfer<TTo>>
   options: {
+    /** Warning: This feature is not fully implemented yet */
+    historyId: string
     /**
      * When set to true, the mutation won't be synced over the network
      */
     localOnly: boolean
+    /** Warning: This feature is not fully implemented yet */
+    facts: FactsCallback<TTo> | undefined
   }
 
-  /** Helper function to construct mutation event */
-  (args: TTo): { mutation: TName; args: TTo; id: string }
+  /** Helper function to construct a partial mutation event */
+  (
+    args: TTo,
+    options?: {
+      id?: number
+    },
+  ): {
+    mutation: TName
+    args: TTo
+    // TODO remove/clean up after sync-next is fully implemented
+    id?: EventId
+  }
+}
+
+export type FactsCallback<TTo> = (
+  args: TTo,
+  currentFacts: MutationEventFacts,
+) => {
+  modify: {
+    set: Iterable<MutationEventFactInput>
+    unset: Iterable<MutationEventFactInput>
+  }
+  require: Iterable<MutationEventFactInput>
 }
 
 export namespace MutationDef {
   export type Any = MutationDef<string, any, any>
 }
 
+export type MutationEventKey = string
+export type MutationEventFact = string
+export type MutationEventFacts = ReadonlyMap<string, any>
+
+export type MutationEventFactsGroup = {
+  modifySet: MutationEventFacts
+  modifyUnset: MutationEventFacts
+
+  /**
+   * Events on independent "dependency" branches are commutative which can facilitate more prioritized syncing
+   */
+  depRequire: MutationEventFacts
+  depRead: MutationEventFacts
+}
+
+export type MutationEventFactsSnapshot = Map<string, any>
+
+export type MutationEventFactInput = string | readonly [string, any]
+
+export const defineFacts = <
+  TRecord extends Record<string, MutationEventFactInput | ((...args: any[]) => MutationEventFactInput)>,
+>(
+  record: TRecord,
+): TRecord => record
+
+export type DefineMutationOptions<TTo> = {
+  historyId?: string
+  /** Warning: This feature is not fully implemented yet */
+  facts?: (
+    args: TTo,
+    currentFacts: MutationEventFacts,
+  ) => {
+    modify?: {
+      set?: Iterable<MutationEventFactInput>
+      unset?: Iterable<MutationEventFactInput>
+    }
+    /**
+     * Two purposes: constrain history and constrain compaction
+     */
+    require?: Iterable<MutationEventFactInput>
+  }
+  /**
+   * When set to true, the mutation won't be synced over the network
+   */
+  localOnly?: boolean
+}
+
 // TODO possibly also allow for mutation event subsumption behaviour
 export const defineMutation = <TName extends string, TFrom, TTo>(
   name: TName,
   schema: Schema.Schema<TTo, TFrom>,
-  sql: MutationDefSqlResult<TTo>,
-  options?: {
-    /**
-     * When set to true, the mutation won't be synced over the network
-     */
-    localOnly?: boolean
-  },
+  sql: MutationDefSqlResult<NoInfer<TTo>>,
+  options?: DefineMutationOptions<TTo>,
 ): MutationDef<TName, TFrom, TTo> => {
-  const makeEvent = (args: TTo) => ({ mutation: name, args, id: cuid() })
+  const makePartialEvent = (
+    args: TTo,
+    options?: {
+      id?: EventId
+    },
+  ) => ({ mutation: name, args, ...options })
 
-  Object.defineProperty(makeEvent, 'name', { value: name })
-  Object.defineProperty(makeEvent, 'schema', { value: schema })
-  Object.defineProperty(makeEvent, 'sql', { value: sql })
-  Object.defineProperty(makeEvent, 'options', { value: { localOnly: options?.localOnly ?? false } })
+  Object.defineProperty(makePartialEvent, 'name', { value: name })
+  Object.defineProperty(makePartialEvent, 'schema', { value: schema })
+  Object.defineProperty(makePartialEvent, 'sql', { value: sql })
+  Object.defineProperty(makePartialEvent, 'options', {
+    value: {
+      historyId: options?.historyId ?? 'main',
+      localOnly: options?.localOnly ?? false,
+      facts: options?.facts
+        ? (args, currentFacts) => {
+            const res = options.facts!(args, currentFacts)
+            return {
+              modify: {
+                set: res.modify?.set ? new Set(res.modify.set) : new Set(),
+                unset: res.modify?.unset ? new Set(res.modify.unset) : new Set(),
+              },
+              require: res.require ? new Set(res.require) : new Set(),
+            }
+          }
+        : undefined,
+    } satisfies MutationDef.Any['options'],
+  })
 
-  return makeEvent as MutationDef<TName, TFrom, TTo>
+  return makePartialEvent as MutationDef<TName, TFrom, TTo>
 }
 
 export const makeMutationDefRecord = <TInputRecord extends Record<string, MutationDef.Any>>(
@@ -102,40 +191,80 @@ export const rawSqlMutation = defineMutation(
 export type RawSqlMutation = typeof rawSqlMutation
 export type RawSqlMutationEvent = ReturnType<typeof rawSqlMutation>
 
+export type MutationEventPartial<TMutationsDef extends MutationDef.Any> = {
+  mutation: TMutationsDef['name']
+  args: Schema.Schema.Type<TMutationsDef['schema']>
+}
+
+export type MutationEventPartialEncoded<TMutationsDef extends MutationDef.Any> = {
+  mutation: TMutationsDef['name']
+  args: Schema.Schema.Encoded<TMutationsDef['schema']>
+}
+
 export type MutationEvent<TMutationsDef extends MutationDef.Any> = {
   mutation: TMutationsDef['name']
   args: Schema.Schema.Type<TMutationsDef['schema']>
-  id: string
+  id: EventId
+  parentId: EventId
 }
 
 export type MutationEventEncoded<TMutationsDef extends MutationDef.Any> = {
   mutation: TMutationsDef['name']
   args: Schema.Schema.Encoded<TMutationsDef['schema']>
-  id: string
+  id: EventId
+  parentId: EventId
 }
 
 export namespace MutationEvent {
   export type Any = MutationEvent<MutationDef.Any>
   export type AnyEncoded = MutationEventEncoded<MutationDef.Any>
 
+  export type PartialAny = MutationEventPartial<MutationDef.Any>
+  export type PartialAnyEncoded = MutationEventPartialEncoded<MutationDef.Any>
+
+  export type PartialForSchema<TSchema extends LiveStoreSchema> = {
+    [K in keyof TSchema['_MutationDefMapType']]: MutationEventPartial<TSchema['_MutationDefMapType'][K]>
+  }[keyof TSchema['_MutationDefMapType']]
+
   export type ForSchema<TSchema extends LiveStoreSchema> = {
     [K in keyof TSchema['_MutationDefMapType']]: MutationEvent<TSchema['_MutationDefMapType'][K]>
   }[keyof TSchema['_MutationDefMapType']]
 }
 
+export const isPartialMutationEvent = (
+  mutationEvent: MutationEvent.Any | MutationEvent.PartialAny,
+): mutationEvent is MutationEvent.PartialAny => 'id' in mutationEvent === false && 'parentId' in mutationEvent === false
+
 export type MutationEventSchema<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
   {
     [K in keyof TMutationsDefRecord]: {
       mutation: K
       args: Schema.Schema.Type<TMutationsDefRecord[K]['schema']>
-      id: string
+      id: EventId
+      parentId: EventId
+    }
+  }[keyof TMutationsDefRecord],
+  {
+    [K in keyof TMutationsDefRecord]: {
+      mutation: K
+      args: Schema.Schema.Encoded<TMutationsDefRecord[K]['schema']>
+      id: EventId
+      parentId: EventId
+    }
+  }[keyof TMutationsDefRecord]
+>
+
+export type MutationEventPartialSchema<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
+  {
+    [K in keyof TMutationsDefRecord]: {
+      mutation: K
+      args: Schema.Schema.Type<TMutationsDefRecord[K]['schema']>
     }
   }[keyof TMutationsDefRecord],
   {
     [K in keyof TMutationsDefRecord]: {
       mutation: K
       args: Schema.Schema.Encoded<TMutationsDefRecord[K]['schema']>
-      id: string
     }
   }[keyof TMutationsDefRecord]
 >
@@ -148,21 +277,37 @@ export const makeMutationEventSchema = <TSchema extends LiveStoreSchema>(
       Schema.Struct({
         mutation: Schema.Literal(def.name),
         args: def.schema,
-        id: Schema.String,
+        id: EventId,
+        parentId: EventId,
       }),
     ),
   ).annotations({ title: 'MutationEventSchema' }) as any
 
+export const makeMutationEventPartialSchema = <TSchema extends LiveStoreSchema>(
+  schema: TSchema,
+): MutationEventPartialSchema<TSchema['_MutationDefMapType']> =>
+  Schema.Union(
+    ...[...schema.mutations.values()].map((def) =>
+      Schema.Struct({
+        mutation: Schema.Literal(def.name),
+        args: def.schema,
+      }),
+    ),
+  ).annotations({ title: 'MutationEventSchemaPartial' }) as any
+
 export const makeMutationEventSchemaMemo = memoizeByRef(makeMutationEventSchema)
 
-export const mutationEventSchemaDecodedAny = Schema.Struct({
+export const mutationEventSchemaAny = Schema.Struct({
   mutation: Schema.String,
   args: Schema.Any,
-  id: Schema.String,
-}).annotations({ title: 'MutationEventSchema.DecodedAny' })
+  id: EventId,
+  parentId: EventId,
+}).annotations({ title: 'MutationEventSchema.Any' })
 
-export const mutationEventSchemaEncodedAny = Schema.Struct({
-  mutation: Schema.String,
-  args: Schema.Any,
-  id: Schema.String,
-}).annotations({ title: 'MutationEventSchema.EncodedAny' })
+export const mutationEventSchemaDecodedAny = Schema.typeSchema(mutationEventSchemaAny).annotations({
+  title: 'MutationEventSchema.DecodedAny',
+})
+
+export const mutationEventSchemaEncodedAny = Schema.encodedSchema(mutationEventSchemaAny).annotations({
+  title: 'MutationEventSchema.EncodedAny',
+})

package/src/schema/schema-helpers.ts

@@ -1,6 +1,6 @@
+import { SqliteDsl } from '@livestore/db-schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import { pipe, ReadonlyRecord, Schema } from '@livestore/utils/effect'
-import { SqliteDsl } from 'effect-db-schema'
 
 import type { TableDef } from './table-def.js'
 

package/src/schema/system-tables.ts

@@ -1,5 +1,5 @@
+import { type SqliteAst as __SqliteAst, SqliteDsl } from '@livestore/db-schema'
 import { Schema } from '@livestore/utils/effect'
-import { type SqliteAst as __SqliteAst, SqliteDsl } from 'effect-db-schema'
 
 import type { FromTable } from './table-def.js'
 import { table } from './table-def.js'
@@ -36,7 +36,25 @@ export const schemaMutationsMetaTable = table(
 
 export type SchemaMutationsMetaRow = FromTable.RowDecoded<typeof schemaMutationsMetaTable>
 
-export const systemTables = [schemaMetaTable, schemaMutationsMetaTable]
+/**
+ * Table which stores SQLite changeset blobs which is used for rolling back
+ * read-model state during rebasing.
+ */
+export const SESSION_CHANGESET_META_TABLE = '__livestore_session_changeset'
+
+export const sessionChangesetMetaTable = table(
+  SESSION_CHANGESET_META_TABLE,
+  {
+    idGlobal: SqliteDsl.integer({ primaryKey: true }),
+    idLocal: SqliteDsl.integer({ primaryKey: true }),
+    changeset: SqliteDsl.blob({}),
+  },
+  { disableAutomaticIdColumn: true },
+)
+
+export type SessionChangesetMetaRow = FromTable.RowDecoded<typeof sessionChangesetMetaTable>
+
+export const systemTables = [schemaMetaTable, schemaMutationsMetaTable, sessionChangesetMetaTable]
 
 /// Mutation log DB
 
@@ -48,16 +66,19 @@ export const MUTATION_LOG_META_TABLE = 'mutation_log'
 export const mutationLogMetaTable = table(
   MUTATION_LOG_META_TABLE,
   {
-    // TODO add parent ids (see https://vlcn.io/blog/crdt-substrate)
-    id: SqliteDsl.text({ primaryKey: true }),
-    mutation: SqliteDsl.text({ nullable: false }),
-    argsJson: SqliteDsl.text({ nullable: false, schema: Schema.parseJson(Schema.Any) }),
-    schemaHash: SqliteDsl.integer({ nullable: false }),
+    idGlobal: SqliteDsl.integer({ primaryKey: true }),
+    idLocal: SqliteDsl.integer({ primaryKey: true }),
+    parentIdGlobal: SqliteDsl.integer({}),
+    parentIdLocal: SqliteDsl.integer({}),
+    mutation: SqliteDsl.text({}),
+    argsJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Any) }),
+    schemaHash: SqliteDsl.integer({}),
     /** ISO date format */
-    createdAt: SqliteDsl.text({ nullable: false }),
+    createdAt: SqliteDsl.text({}),
     syncStatus: SqliteDsl.text({ schema: SyncStatus }),
+    syncMetadataJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Option(Schema.JsonValue)) }),
   },
-  { disableAutomaticIdColumn: true },
+  { disableAutomaticIdColumn: true, indexes: [] },
 )
 
 export type MutationLogMetaRow = FromTable.RowDecoded<typeof mutationLogMetaTable>

package/src/schema/table-def.ts

@@ -1,14 +1,14 @@
+import type { Nullable, PrettifyFlat } from '@livestore/db-schema'
+import { SqliteDsl } from '@livestore/db-schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import { ReadonlyRecord, Schema } from '@livestore/utils/effect'
-import type { Nullable, PrettifyFlat } from 'effect-db-schema'
-import { SqliteDsl } from 'effect-db-schema'
 
 import type { DerivedMutationHelperFns } from '../derived-mutations.js'
 import { makeDerivedMutationDefsForTable } from '../derived-mutations.js'
 
 export const { blob, boolean, column, datetime, integer, isColumnDefinition, json, real, text } = SqliteDsl
 
-export { type SqliteDsl } from 'effect-db-schema'
+export { type SqliteDsl } from '@livestore/db-schema'
 
 export type StateType = 'singleton' | 'dynamic'
 

package/src/schema-management/migrations.ts

@@ -1,6 +1,6 @@
+import { SqliteAst, SqliteDsl } from '@livestore/db-schema'
 import { memoizeByStringifyArgs } from '@livestore/utils'
 import { Effect, Schema as EffectSchema } from '@livestore/utils/effect'
-import { SqliteAst, SqliteDsl } from 'effect-db-schema'
 
 import type { SynchronousDatabase } from '../adapter-types.js'
 import type { LiveStoreSchema } from '../schema/index.js'
@@ -155,7 +155,7 @@ export const migrateTable = ({
 
 const createIndexFromDefinition = (tableName: string, index: SqliteAst.Index) => {
   const uniqueStr = index.unique ? 'UNIQUE' : ''
-  return sql`create ${uniqueStr} index ${index.name} on ${tableName} (${index.columns.join(', ')})`
+  return sql`create ${uniqueStr} index if not exists ${index.name} on ${tableName} (${index.columns.join(', ')})`
 }
 
 export const makeColumnSpec = (tableAst: SqliteAst.Table) => {

package/src/sql-queries/sql-queries.ts

@@ -1,6 +1,6 @@
+import type { SqliteDsl } from '@livestore/db-schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import { pipe, ReadonlyArray, Schema, TreeFormatter } from '@livestore/utils/effect'
-import type { SqliteDsl } from 'effect-db-schema'
 
 import { sql } from '../util.js'
 import { objectEntries } from './misc.js'
@@ -58,15 +58,26 @@ export const insertRow = <TColumns extends SqliteDsl.Columns>({
   values: ClientTypes.DecodedValuesForColumns<TColumns>
   options?: { orReplace: boolean }
 }): [string, BindValues] => {
-  const keysStr = Object.keys(values).join(', ')
-  const valuesStr = Object.keys(values)
-    .map((_) => `$${_}`)
+  const stmt = insertRowPrepared({ tableName, columns, options })
+
+  return [stmt, makeBindValues({ columns, values })]
+}
+
+export const insertRowPrepared = <TColumns extends SqliteDsl.Columns>({
+  tableName,
+  columns,
+  options = { orReplace: false },
+}: {
+  tableName: string
+  columns: TColumns
+  options?: { orReplace: boolean }
+}): string => {
+  const keysStr = Object.keys(columns).join(', ')
+  const valuesStr = Object.keys(columns)
+    .map((key) => `$${key}`)
     .join(', ')
 
-  return [
-    sql`INSERT ${options.orReplace ? 'OR REPLACE ' : ''}INTO ${tableName} (${keysStr}) VALUES (${valuesStr})`,
-    makeBindValues({ columns, values }),
-  ]
+  return sql`INSERT ${options.orReplace ? 'OR REPLACE ' : ''}INTO ${tableName} (${keysStr}) VALUES (${valuesStr})`
 }
 
 export const insertRows = <TColumns extends SqliteDsl.Columns>({
@@ -243,14 +254,14 @@ export const createTable = ({
   return sql`CREATE TABLE ${tableName} (${columnDefStrs.join(', ')});`
 }
 
-export const makeBindValues = <TColumns extends SqliteDsl.Columns, TKeys extends string>({
+export const makeBindValues = <TColumns extends SqliteDsl.Columns, TKeys extends keyof TColumns>({
   columns,
   values,
   variablePrefix = '',
   skipNil,
 }: {
   columns: TColumns
-  values: Record<TKeys, any>
+  values: Partial<Record<TKeys, any>>
   variablePrefix?: string
   /** So far only used to prepare `where` statements */
   skipNil?: boolean

package/src/sql-queries/sql-query-builder.ts

@@ -1,4 +1,4 @@
-import type { SqliteDsl } from 'effect-db-schema'
+import type { SqliteDsl } from '@livestore/db-schema'
 
 import type { BindValues } from './sql-queries.js'
 import * as SqlQueries from './sql-queries.js'

package/src/sql-queries/types.ts

@@ -1,5 +1,5 @@
+import type { Prettify, SqliteDsl } from '@livestore/db-schema'
 import type { Schema } from '@livestore/utils/effect'
-import type { Prettify, SqliteDsl } from 'effect-db-schema'
 
 export type DecodedValuesForTableAll<TSchema extends SqliteDsl.DbSchema, TTableName extends keyof TSchema> = {
   [K in keyof GetColumns<TSchema, TTableName>]: Schema.Schema.Type<GetColumn<TSchema, TTableName, K>['schema']>
@@ -89,7 +89,7 @@ export type WhereValuesForColumns<TColumns extends SqliteDsl.Columns> = PartialO
 }>
 
 export type GetNullableColumnNames<TColumns extends SqliteDsl.Columns> = keyof {
-  [K in keyof TColumns as TColumns[K] extends SqliteDsl.ColumnDefinition<any, true> ? K : never]: {}
+  [K in keyof TColumns as TColumns[K] extends SqliteDsl.ColumnDefinition<any, true> ? K : never]: unknown
 }
 
 export type PartialOrNull<T> = { [P in keyof T]?: T[P] | null }

package/src/sync/next/ambient.d.ts

@@ -0,0 +1,3 @@
+declare module 'graphology' {
+  export * from 'graphology-types'
+}