@livestore/common 0.3.0-dev.3 → 0.3.0-dev.5

package/src/leader-thread/types.ts

@@ -22,7 +22,7 @@ import type {
   UnexpectedError,
 } from '../index.js'
 import type { EventId, LiveStoreSchema, MutationEvent } from '../schema/mod.js'
-import type { PayloadUpstream, SyncState } from '../sync/syncstate.js'
+import type * as SyncState from '../sync/syncstate.js'
 import type { ShutdownChannel } from './shutdown-channel.js'
 
 export type ShutdownState = 'running' | 'shutting-down'
@@ -67,7 +67,6 @@ export type DevtoolsOptions =
       makeContext: Effect.Effect<
         {
           devtoolsWebChannel: WebChannel.WebChannel<Devtools.MessageToAppLeader, Devtools.MessageFromAppLeader>
-          shutdownChannel: ShutdownChannel
           persistenceInfo: PersistenceInfoPair
         },
         UnexpectedError,
@@ -80,18 +79,21 @@ export class LeaderThreadCtx extends Context.Tag('LeaderThreadCtx')<
   {
     schema: LiveStoreSchema
     storeId: string
-    originId: string
+    clientId: string
     makeSyncDb: MakeSynchronousDatabase
     db: LeaderDatabase
     dbLog: LeaderDatabase
     bootStatusQueue: Queue.Queue<BootStatus>
     // TODO we should find a more elegant way to handle cases which need this ref for their implementation
     shutdownStateSubRef: SubscriptionRef.SubscriptionRef<ShutdownState>
+    shutdownChannel: ShutdownChannel
     mutationEventSchema: MutationEvent.ForMutationDefRecord<any>
     // devtools: DevtoolsContext
     syncBackend: SyncBackend | undefined
     syncProcessor: SyncProcessor
     connectedClientSessionPullQueues: PullQueueSet
+    /** e.g. used for `store.__dev` APIs */
+    extraIncomingMessagesQueue: Queue.Queue<Devtools.MessageToAppLeader>
   }
 >() {}
 
@@ -101,10 +103,7 @@ export type InitialBlockingSyncContext = {
 }
 
 export type PullQueueItem = {
-  // mutationEvents: ReadonlyArray<MutationEvent.AnyEncoded>
-  // backendHead: number
-  payload: PayloadUpstream
-  // TODO move `remaining` into `PayloadUpstream`
+  payload: SyncState.PayloadUpstream
   remaining: number
 }
 
@@ -118,7 +117,7 @@ export interface SyncProcessor {
   boot: (args: {
     dbReady: Deferred.Deferred<void>
   }) => Effect.Effect<void, UnexpectedError, LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient>
-  syncState: Effect.Effect<SyncState, UnexpectedError>
+  syncState: Effect.Effect<SyncState.SyncState, UnexpectedError>
 }
 
 export interface PullQueueSet {

package/src/mutation.ts

@@ -11,7 +11,7 @@ export const getExecArgsFromMutation = ({
   mutationEventDecoded,
 }: {
   mutationDef: MutationDef.Any
-  mutationEventDecoded: MutationEvent.Any | MutationEvent.PartialAny
+  mutationEventDecoded: MutationEvent.AnyDecoded | MutationEvent.PartialAny
 }): ReadonlyArray<{
   statementSql: string
   bindValues: PreparedBindValues

package/src/rehydrate-from-mutationlog.ts

@@ -58,7 +58,7 @@ This likely means the schema has changed in an incompatible way.
           parentId: { global: row.parentIdGlobal, local: row.parentIdLocal },
           mutation: row.mutation,
           args: argsDecoded,
-        } satisfies MutationEvent.Any
+        } satisfies MutationEvent.AnyDecoded
 
         const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
 

package/src/schema/EventId.ts

@@ -1,4 +1,14 @@
-import { Schema } from '@livestore/utils/effect'
+import { Brand, Schema } from '@livestore/utils/effect'
+
+export type LocalEventId = Brand.Branded<number, 'LocalEventId'>
+export const localEventId = Brand.nominal<LocalEventId>()
+export const LocalEventId = Schema.fromBrand(localEventId)(Schema.Int)
+
+export type GlobalEventId = Brand.Branded<number, 'GlobalEventId'>
+export const globalEventId = Brand.nominal<GlobalEventId>()
+export const GlobalEventId = Schema.fromBrand(globalEventId)(Schema.Int)
+
+export const localDefault = 0 as any as LocalEventId
 
 /**
  * LiveStore event id value consisting of a globally unique event sequence number
@@ -6,11 +16,11 @@ import { Schema } from '@livestore/utils/effect'
  *
  * The local sequence number is only used for localOnly mutations and starts from 0 for each global sequence number.
  */
-export type EventId = { global: number; local: number }
+export type EventId = { global: GlobalEventId; local: LocalEventId }
 
 export const EventId = Schema.Struct({
-  global: Schema.Number,
-  local: Schema.Number,
+  global: GlobalEventId,
+  local: LocalEventId,
 }).annotations({ title: 'LiveStore.EventId' })
 
 /**
@@ -27,20 +37,24 @@ export const isEqual = (a: EventId, b: EventId) => a.global === b.global && a.lo
 
 export type EventIdPair = { id: EventId; parentId: EventId }
 
-export const ROOT = { global: -1, local: 0 } satisfies EventId
+export const ROOT = { global: -1 as any as GlobalEventId, local: localDefault } satisfies EventId
 
 export const isGreaterThan = (a: EventId, b: EventId) => {
   return a.global > b.global || (a.global === b.global && a.local > b.local)
 }
 
-export const nextPair = (id: EventId, isLocal: boolean) => {
+export const make = (id: EventId | typeof EventId.Encoded): EventId => {
+  return Schema.is(EventId)(id) ? id : Schema.decodeSync(EventId)(id)
+}
+
+export const nextPair = (id: EventId, isLocal: boolean): EventIdPair => {
   if (isLocal) {
-    return { id: { global: id.global, local: id.local + 1 }, parentId: id }
+    return { id: { global: id.global, local: (id.local + 1) as any as LocalEventId }, parentId: id }
   }
 
   return {
-    id: { global: id.global + 1, local: 0 },
+    id: { global: (id.global + 1) as any as GlobalEventId, local: localDefault },
     // NOTE we always point to `local: 0` for non-localOnly mutations
-    parentId: { global: id.global, local: 0 },
+    parentId: { global: id.global, local: localDefault },
   }
 }

package/src/schema/MutationEvent.ts

@@ -30,8 +30,29 @@ export type MutationEventEncoded<TMutationsDef extends MutationDef.Any> = {
   parentId: EventId.EventId
 }
 
-export type Any = MutationEvent<MutationDef.Any>
+export type AnyDecoded = MutationEvent<MutationDef.Any>
+export const AnyDecoded = Schema.Struct({
+  mutation: Schema.String,
+  args: Schema.Any,
+  id: EventId.EventId,
+  parentId: EventId.EventId,
+}).annotations({ title: 'MutationEvent.AnyDecoded' })
+
 export type AnyEncoded = MutationEventEncoded<MutationDef.Any>
+export const AnyEncoded = Schema.Struct({
+  mutation: Schema.String,
+  args: Schema.Any,
+  id: EventId.EventId,
+  parentId: EventId.EventId,
+}).annotations({ title: 'MutationEvent.AnyEncoded' })
+
+export const AnyEncodedGlobal = Schema.Struct({
+  mutation: Schema.String,
+  args: Schema.Any,
+  id: EventId.GlobalEventId,
+  parentId: EventId.GlobalEventId,
+}).annotations({ title: 'MutationEvent.AnyEncodedGlobal' })
+export type AnyEncodedGlobal = typeof AnyEncodedGlobal.Type
 
 export type PartialAny = MutationEventPartial<MutationDef.Any>
 export type PartialAnyEncoded = MutationEventPartialEncoded<MutationDef.Any>
@@ -44,7 +65,7 @@ export type ForSchema<TSchema extends LiveStoreSchema> = {
   [K in keyof TSchema['_MutationDefMapType']]: MutationEvent<TSchema['_MutationDefMapType'][K]>
 }[keyof TSchema['_MutationDefMapType']]
 
-export const isPartialMutationEvent = (mutationEvent: Any | PartialAny): mutationEvent is PartialAny =>
+export const isPartialMutationEvent = (mutationEvent: AnyDecoded | PartialAny): mutationEvent is PartialAny =>
   'id' in mutationEvent === false && 'parentId' in mutationEvent === false
 
 export type ForMutationDefRecord<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
@@ -109,22 +130,7 @@ export const makeMutationEventPartialSchema = <TSchema extends LiveStoreSchema>(
 
 export const makeMutationEventSchemaMemo = memoizeByRef(makeMutationEventSchema)
 
-export const Any = Schema.Struct({
-  mutation: Schema.String,
-  args: Schema.Any,
-  id: EventId.EventId,
-  parentId: EventId.EventId,
-}).annotations({ title: 'MutationEvent.Any' })
-
-export const DecodedAny = Schema.typeSchema(Any).annotations({
-  title: 'MutationEvent.DecodedAny',
-})
-
-export const EncodedAny = Schema.encodedSchema(Any).annotations({
-  title: 'MutationEvent.EncodedAny',
-})
-
-/** Equivalent to EncodedAny but with a meta field and some convenience methods */
+/** Equivalent to AnyEncoded but with a meta field and some convenience methods */
 export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEvent.EncodedWithMeta')({
   mutation: Schema.String,
   args: Schema.Any,
@@ -151,6 +157,19 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
       ...this,
       ...EventId.nextPair(this.id, isLocal),
     })
+
+  static fromGlobal = (mutationEvent: AnyEncodedGlobal) =>
+    new EncodedWithMeta({
+      ...mutationEvent,
+      id: { global: mutationEvent.id, local: EventId.localDefault },
+      parentId: { global: mutationEvent.parentId, local: EventId.localDefault },
+    })
+
+  toGlobal = (): AnyEncodedGlobal => ({
+    ...this,
+    id: this.id.global,
+    parentId: this.parentId.global,
+  })
 }
 
 export const isEqualEncoded = (a: AnyEncoded, b: AnyEncoded) =>

package/src/schema/system-tables.ts

@@ -1,6 +1,7 @@
 import { type SqliteAst as __SqliteAst, SqliteDsl } from '@livestore/db-schema'
 import { Schema } from '@livestore/utils/effect'
 
+import * as EventId from './EventId.js'
 import type { FromTable } from './table-def.js'
 import { table } from './table-def.js'
 
@@ -46,8 +47,8 @@ export const sessionChangesetMetaTable = table(
   SESSION_CHANGESET_META_TABLE,
   {
     // TODO bring back primary key
-    idGlobal: SqliteDsl.integer({}),
-    idLocal: SqliteDsl.integer({}),
+    idGlobal: SqliteDsl.integer({ schema: EventId.GlobalEventId }),
+    idLocal: SqliteDsl.integer({ schema: EventId.LocalEventId }),
     // idGlobal: SqliteDsl.integer({ primaryKey: true }),
     // idLocal: SqliteDsl.integer({ primaryKey: true }),
     changeset: SqliteDsl.blob({}),
@@ -70,16 +71,22 @@ export const MUTATION_LOG_META_TABLE = 'mutation_log'
 export const mutationLogMetaTable = table(
   MUTATION_LOG_META_TABLE,
   {
-    idGlobal: SqliteDsl.integer({ primaryKey: true }),
-    idLocal: SqliteDsl.integer({ primaryKey: true }),
-    parentIdGlobal: SqliteDsl.integer({}),
-    parentIdLocal: SqliteDsl.integer({}),
+    idGlobal: SqliteDsl.integer({ primaryKey: true, schema: EventId.GlobalEventId }),
+    idLocal: SqliteDsl.integer({ primaryKey: true, schema: EventId.LocalEventId }),
+    parentIdGlobal: SqliteDsl.integer({ schema: EventId.GlobalEventId }),
+    parentIdLocal: SqliteDsl.integer({ schema: EventId.LocalEventId }),
     mutation: SqliteDsl.text({}),
     argsJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Any) }),
     schemaHash: SqliteDsl.integer({}),
     syncMetadataJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Option(Schema.JsonValue)) }),
   },
-  { disableAutomaticIdColumn: true, indexes: [] },
+  {
+    disableAutomaticIdColumn: true,
+    indexes: [
+      { columns: ['idGlobal'], name: 'idx_idGlobal' },
+      { columns: ['idGlobal', 'idLocal'], name: 'idx_idGlobal_idLocal' },
+    ],
+  },
 )
 
 export type MutationLogMetaRow = FromTable.RowDecoded<typeof mutationLogMetaTable>

package/src/schema-management/migrations.ts

@@ -129,10 +129,10 @@ export const migrateTable = ({
 
     if (behaviour === 'drop-and-recreate') {
       // TODO need to possibly handle cascading deletes due to foreign keys
-      dbExecute(db, sql`drop table if exists ${tableName}`)
-      dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
+      dbExecute(db, sql`drop table if exists '${tableName}'`)
+      dbExecute(db, sql`create table if not exists '${tableName}' (${columnSpec}) strict`)
     } else if (behaviour === 'create-if-not-exists') {
-      dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
+      dbExecute(db, sql`create table if not exists '${tableName}' (${columnSpec}) strict`)
     }
 
     for (const index of tableAst.indexes) {
@@ -162,11 +162,11 @@ export const migrateTable = ({
 
 const createIndexFromDefinition = (tableName: string, index: SqliteAst.Index) => {
   const uniqueStr = index.unique ? 'UNIQUE' : ''
-  return sql`create ${uniqueStr} index if not exists ${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) => {
-  const primaryKeys = tableAst.columns.filter((_) => _.primaryKey).map((_) => _.name)
+  const primaryKeys = tableAst.columns.filter((_) => _.primaryKey).map((_) => `'${_.name}'`)
   const columnDefStrs = tableAst.columns.map(toSqliteColumnSpec)
   if (primaryKeys.length > 0) {
     columnDefStrs.push(`PRIMARY KEY (${primaryKeys.join(', ')})`)
@@ -191,5 +191,5 @@ const toSqliteColumnSpec = (column: SqliteAst.Column) => {
     return `default ${encodedDefaultValue}`
   })()
 
-  return `${column.name} ${columnTypeStr} ${nullableStr} ${defaultValueStr}`
+  return `'${column.name}' ${columnTypeStr} ${nullableStr} ${defaultValueStr}`
 }

package/src/sync/client-session-sync-processor.ts

@@ -3,7 +3,7 @@ import type { Scope } from '@livestore/utils/effect'
 import { Effect, Schema, Stream } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
-import type { Coordinator, UnexpectedError } from '../adapter-types.js'
+import type { ClientSessionLeaderThreadProxy, UnexpectedError } from '../adapter-types.js'
 import * as EventId from '../schema/EventId.js'
 import { type LiveStoreSchema } from '../schema/mod.js'
 import * as MutationEvent from '../schema/MutationEvent.js'
@@ -32,7 +32,7 @@ export const makeClientSessionSyncProcessor = ({
   schema: LiveStoreSchema
   initialLeaderHead: EventId.EventId
   pushToLeader: (batch: ReadonlyArray<MutationEvent.AnyEncoded>) => void
-  pullFromLeader: Coordinator['mutations']['pull']
+  pullFromLeader: ClientSessionLeaderThreadProxy['mutations']['pull']
   applyMutation: (
     mutationEventDecoded: MutationEvent.PartialAny,
     options: { otelContext: otel.Context; withChangeset: boolean },

package/src/sync/next/history-dag-common.ts

@@ -20,7 +20,7 @@ export const emptyHistoryDag = (): HistoryDag =>
   })
 
 // TODO consider making `ROOT_ID` parent to itself
-export const rootParentId = { global: EventId.ROOT.global - 1, local: 0 } satisfies EventId.EventId
+export const rootParentId = EventId.make({ global: EventId.ROOT.global - 1, local: EventId.localDefault })
 
 export type HistoryDagNode = {
   id: EventId.EventId

package/src/sync/next/rebase-events.ts

@@ -1,4 +1,4 @@
-import type * as EventId from '../../schema/EventId.js'
+import * as EventId from '../../schema/EventId.js'
 import type * as MutationEvent from '../../schema/MutationEvent.js'
 import type { MutationDef, MutationEventFactsSnapshot } from '../../schema/mutations.js'
 import {
@@ -48,7 +48,7 @@ export const rebaseEvents = ({
   newRemoteEvents: HistoryDagNode[]
   rebaseFn: RebaseFn
   currentFactsSnapshot: MutationEventFactsSnapshot
-}): MutationEvent.Any[] => {
+}): ReadonlyArray<MutationEvent.AnyDecoded> => {
   const initialSnapshot = new Map(currentFactsSnapshot)
   applyFactGroups(
     newRemoteEvents.map((event) => event.factsGroup),
@@ -89,10 +89,10 @@ export const rebaseEvents = ({
   return rebasedLocalEvents.map(
     (event, index) =>
       ({
-        id: { global: headGlobalId + index + 1, local: 0 } satisfies EventId.EventId,
-        parentId: { global: headGlobalId + index, local: 0 } satisfies EventId.EventId,
+        id: EventId.make({ global: headGlobalId + index + 1, local: EventId.localDefault }),
+        parentId: EventId.make({ global: headGlobalId + index, local: EventId.localDefault }),
         mutation: event.mutation,
         args: event.args,
-      }) satisfies MutationEvent.Any,
+      }) satisfies MutationEvent.AnyDecoded,
   )
 }

package/src/sync/next/test/mutation-fixtures.ts

@@ -140,16 +140,9 @@ export const toEventNodes = (
 
   let currentEventId: EventId.EventId = EventId.ROOT
 
-  const getNextEventId = (mutationDef: MutationDef.Any): EventId.EventId => {
-    if (mutationDef.options.localOnly) {
-      return { global: currentEventId.global, local: currentEventId.local + 1 }
-    }
-    return { global: currentEventId.global + 1, local: 0 }
-  }
-
   const eventNodes = partialEvents.map((partialEvent) => {
     const mutationDef = mutationDefs[partialEvent.mutation]!
-    const eventId = getNextEventId(mutationDef)
+    const eventId = EventId.nextPair(currentEventId, mutationDef.options.localOnly).id
     currentEventId = eventId
 
     const factsSnapshot = factsSnapshotForDag(historyDagFromNodes(nodesAcc, { skipFactsCheck: true }), undefined)
@@ -224,8 +217,8 @@ const getParentId = (eventId: EventId.EventId): EventId.EventId => {
   const localParentId = eventId.local - 1
 
   if (localParentId < 0) {
-    return { global: globalParentId - 1, local: 0 }
+    return EventId.make({ global: globalParentId - 1, local: EventId.localDefault })
   }
 
-  return { global: globalParentId, local: localParentId }
+  return EventId.make({ global: globalParentId, local: localParentId })
 }

package/src/sync/sync.ts

@@ -18,7 +18,7 @@ export type SyncBackend<TSyncMetadata = Schema.JsonValue> = {
   ) => Stream.Stream<
     {
       batch: ReadonlyArray<{
-        mutationEventEncoded: MutationEvent.AnyEncoded
+        mutationEventEncoded: MutationEvent.AnyEncodedGlobal
         metadata: Option.Option<TSyncMetadata>
       }>
       remaining: number
@@ -33,7 +33,7 @@ export type SyncBackend<TSyncMetadata = Schema.JsonValue> = {
      * - Number of events: 1-100
      * - event ids must be in ascending order
      * */
-    batch: ReadonlyArray<MutationEvent.AnyEncoded>,
+    batch: ReadonlyArray<MutationEvent.AnyEncodedGlobal>,
   ) => Effect.Effect<
     {
       /** Indexes are relative to `batch` */
@@ -46,6 +46,7 @@ export type SyncBackend<TSyncMetadata = Schema.JsonValue> = {
 }
 
 export class IsOfflineError extends Schema.TaggedError<IsOfflineError>()('IsOfflineError', {}) {}
+
 export class InvalidPushError extends Schema.TaggedError<InvalidPushError>()('InvalidPushError', {
   reason: Schema.Union(
     Schema.TaggedStruct('Unexpected', {
@@ -61,6 +62,7 @@ export class InvalidPushError extends Schema.TaggedError<InvalidPushError>()('In
     }),
   ),
 }) {}
+
 export class InvalidPullError extends Schema.TaggedError<InvalidPullError>()('InvalidPullError', {
   message: Schema.String,
 }) {}

package/src/sync/syncstate.test.ts

@@ -7,14 +7,14 @@ import * as SyncState from './syncstate.js'
 
 class TestEvent extends MutationEvent.EncodedWithMeta {
   constructor(
-    public readonly id: EventId.EventId,
-    public readonly parentId: EventId.EventId,
+    id: EventId.EventId | typeof EventId.EventId.Encoded,
+    parentId: EventId.EventId,
     public readonly payload: string,
     public readonly isLocal: boolean,
   ) {
     super({
-      id,
-      parentId,
+      id: EventId.make(id),
+      parentId: EventId.make(parentId),
       mutation: 'a',
       args: payload,
       meta: {},

package/src/sync/validate-push-payload.ts

@@ -1,17 +1,20 @@
 import { Effect } from '@livestore/utils/effect'
 
-import type { MutationEvent } from '../schema/mod.js'
+import type { EventId, MutationEvent } from '../schema/mod.js'
 import { InvalidPushError } from './sync.js'
 
 // TODO proper batch validation
-export const validatePushPayload = (batch: ReadonlyArray<MutationEvent.AnyEncoded>, currentEventId: number) =>
+export const validatePushPayload = (
+  batch: ReadonlyArray<MutationEvent.AnyEncodedGlobal>,
+  currentEventId: EventId.GlobalEventId,
+) =>
   Effect.gen(function* () {
-    if (batch[0]!.id.global <= currentEventId) {
+    if (batch[0]!.id <= currentEventId) {
       return yield* InvalidPushError.make({
         reason: {
           _tag: 'ServerAhead',
           minimumExpectedId: currentEventId + 1,
-          providedId: batch[0]!.id.global,
+          providedId: batch[0]!.id,
         },
       })
     }

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.3.0-dev.2' as const
+export const liveStoreVersion = '0.3.0-dev.4' as const
 
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.