@livestore/common 0.3.0-dev.8 → 0.3.0

package/src/devtools/devtools-window-message.ts

@@ -1,27 +0,0 @@
-import { Schema, Transferable } from '@livestore/utils/effect'
-
-const appHostId = Schema.String
-
-export namespace DevtoolsWindowMessage {
-  /** Message is being created in contentscript-iframe, sent to contentscript and then sent to Store */
-  export class MessagePortReady extends Schema.TaggedStruct('LSD.WindowMessage.MessagePortReady', {
-    port: Transferable.MessagePort,
-    appHostId,
-  }) {}
-
-  export class ContentscriptListening extends Schema.TaggedStruct('LSD.WindowMessage.ContentscriptListening', {}) {}
-
-  // export class ContentscriptReady extends Schema.TaggedStruct('LSD.WindowMessage.ContentscriptReady', {
-  // 	appHostId,
-  // }) {}
-
-  export class LoadIframe extends Schema.TaggedStruct('LSD.WindowMessage.LoadIframe', {}) {}
-
-  export class StoreReady extends Schema.TaggedStruct('LSD.WindowMessage.StoreReady', {
-    appHostId,
-  }) {}
-
-  export class MessageForStore extends Schema.Union(MessagePortReady, ContentscriptListening) {}
-
-  export class MessageForContentscript extends Schema.Union(StoreReady, LoadIframe) {}
-}

package/src/devtools/index.ts

@@ -1,48 +0,0 @@
-import type { Effect, Scope } from '@livestore/utils/effect'
-import { Schema, WebChannel } from '@livestore/utils/effect'
-
-export * from './devtools-messages.js'
-export * from './devtools-window-message.js'
-export * from './devtools-bridge.js'
-
-export namespace WebBridge {
-  export class AppHostReady extends Schema.TaggedStruct('LSD.WebBridge.AppHostReady', {
-    appHostId: Schema.String,
-    // storeId: Schema.String,
-    isLeader: Schema.Boolean,
-  }) {}
-
-  export class DevtoolsReady extends Schema.TaggedStruct('LSD.WebBridge.DevtoolsReady', {
-    devtoolsId: Schema.String,
-  }) {}
-
-  export class ConnectToDevtools extends Schema.TaggedStruct('LSD.WebBridge.ConnectToDevtools', {
-    devtoolsId: Schema.String,
-    appHostId: Schema.String,
-    /**
-     * Given the m:n relationship between devtools and app hosts and the fact that appHostIds are usually
-     * sticky, we generate a new unique id for the lifetime of the web bridge.
-     */
-    webBridgeId: Schema.String,
-    isLeader: Schema.Boolean,
-    storeId: Schema.String,
-  }) {}
-
-  export class AppHostWillDisconnect extends Schema.TaggedStruct('LSD.WebBridge.AppHostWillDisconnect', {
-    appHostId: Schema.String,
-  }) {}
-
-  // export class DevtoolsWillDisconnect extends Schema.TaggedStruct('LSD.WebBridge.DevtoolsWillDisconnect', {
-  //   appHostId: Schema.String,
-  // }) {}
-
-  export class All extends Schema.Union(AppHostReady, DevtoolsReady, ConnectToDevtools, AppHostWillDisconnect) {}
-
-  export const makeBroadcastChannel = (
-    key?: string,
-  ): Effect.Effect<WebChannel.WebChannel<typeof All.Type, typeof All.Type>, never, Scope.Scope> =>
-    WebChannel.broadcastChannel({
-      channelName: `livestore-web-bridge-devtools${key ? `-${key}` : ''}`,
-      schema: All,
-    })
-}

package/src/init-singleton-tables.ts

@@ -1,24 +0,0 @@
-import type { SynchronousDatabase } from './adapter-types.js'
-import type { LiveStoreSchema } from './schema/mod.js'
-import { getDefaultValuesEncoded } from './schema/schema-helpers.js'
-import { prepareBindValues, sql } from './util.js'
-
-export const initializeSingletonTables = (schema: LiveStoreSchema, db: SynchronousDatabase) => {
-  for (const [, tableDef] of schema.tables) {
-    if (tableDef.options.isSingleton) {
-      const defaultValues = getDefaultValuesEncoded(tableDef, undefined)
-
-      const defaultColumnNames = [...Object.keys(defaultValues), 'id']
-      const columnValues = defaultColumnNames.map((name) => `$${name}`).join(', ')
-
-      const tableName = tableDef.sqliteDef.name
-      const insertQuery = sql`insert into ${tableName} (${defaultColumnNames.join(
-        ', ',
-      )}) select ${columnValues} where not exists(select 1 from ${tableName} where id = 'singleton')`
-
-      const bindValues = prepareBindValues({ ...defaultValues, id: 'singleton' }, insertQuery)
-
-      db.execute(insertQuery, bindValues)
-    }
-  }
-}

package/src/leader-thread/apply-mutation.ts

@@ -1,161 +0,0 @@
-import { memoizeByRef, shouldNeverHappen } from '@livestore/utils'
-import type { Scope } from '@livestore/utils/effect'
-import { Effect, Option, Schema } from '@livestore/utils/effect'
-
-import type { SqliteError, SynchronousDatabase, UnexpectedError } from '../index.js'
-import { getExecArgsFromMutation } from '../mutation.js'
-import {
-  type LiveStoreSchema,
-  MUTATION_LOG_META_TABLE,
-  type MutationEvent,
-  mutationLogMetaTable,
-  SESSION_CHANGESET_META_TABLE,
-  sessionChangesetMetaTable,
-} from '../schema/mod.js'
-import { insertRow } from '../sql-queries/index.js'
-import { execSql, execSqlPrepared } from './connection.js'
-import { LeaderThreadCtx } from './types.js'
-
-export type ApplyMutation = (
-  mutationEventEncoded: MutationEvent.AnyEncoded,
-  options?: {
-    /** Needed for rehydrateFromMutationLog */
-    skipMutationLog?: boolean
-  },
-) => Effect.Effect<void, SqliteError | UnexpectedError>
-
-export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope | LeaderThreadCtx> = Effect.gen(
-  function* () {
-    const leaderThreadCtx = yield* LeaderThreadCtx
-    const shouldExcludeMutationFromLog = makeShouldExcludeMutationFromLog(leaderThreadCtx.schema)
-
-    const mutationDefSchemaHashMap = new Map(
-      // TODO Running `Schema.hash` can be a bottleneck for larger schemas. There is an opportunity to run this
-      // at build time and lookup the pre-computed hash at runtime.
-      // Also see https://github.com/Effect-TS/effect/issues/2719
-      [...leaderThreadCtx.schema.mutations.entries()].map(([k, v]) => [k, Schema.hash(v.schema)] as const),
-    )
-
-    return (mutationEventEncoded, options) =>
-      Effect.gen(function* () {
-        const { schema, db, dbLog } = leaderThreadCtx
-        const skipMutationLog = options?.skipMutationLog ?? false
-
-        const mutationName = mutationEventEncoded.mutation
-        const mutationDef = schema.mutations.get(mutationName) ?? shouldNeverHappen(`Unknown mutation: ${mutationName}`)
-
-        const execArgsArr = getExecArgsFromMutation({
-          mutationDef,
-          mutationEvent: { decoded: undefined, encoded: mutationEventEncoded },
-        })
-
-        // NOTE we might want to bring this back if we want to debug no-op mutations
-        // const makeExecuteOptions = (statementSql: string, bindValues: any) => ({
-        //   onRowsChanged: (rowsChanged: number) => {
-        //     if (rowsChanged === 0) {
-        //       console.warn(`Mutation "${mutationDef.name}" did not affect any rows:`, statementSql, bindValues)
-        //     }
-        //   },
-        // })
-
-        // console.group('[@livestore/common:leader-thread:applyMutation]', { mutationName })
-
-        const session = db.session()
-
-        for (const { statementSql, bindValues } of execArgsArr) {
-          // console.debug(mutationName, statementSql, bindValues)
-          // TODO use cached prepared statements instead of exec
-          yield* execSqlPrepared(db, statementSql, bindValues)
-        }
-
-        const changeset = session.changeset()
-        session.finish()
-
-        // TODO use prepared statements
-        yield* execSql(
-          db,
-          ...insertRow({
-            tableName: SESSION_CHANGESET_META_TABLE,
-            columns: sessionChangesetMetaTable.sqliteDef.columns,
-            values: {
-              idGlobal: mutationEventEncoded.id.global,
-              idLocal: mutationEventEncoded.id.local,
-              // NOTE the changeset will be empty (i.e. null) for no-op mutations
-              changeset: changeset ?? null,
-              debug: execArgsArr,
-            },
-          }),
-        )
-
-        // console.groupEnd()
-
-        // write to mutation_log
-        const excludeFromMutationLog = shouldExcludeMutationFromLog(mutationName, mutationEventEncoded)
-        if (skipMutationLog === false && excludeFromMutationLog === false) {
-          yield* insertIntoMutationLog(mutationEventEncoded, dbLog, mutationDefSchemaHashMap)
-        } else {
-          //   console.debug('[@livestore/common:leader-thread] skipping mutation log write', mutation, statementSql, bindValues)
-        }
-      }).pipe(
-        Effect.withSpan(`@livestore/common:leader-thread:applyMutation`, {
-          attributes: {
-            mutationName: mutationEventEncoded.mutation,
-            mutationId: mutationEventEncoded.id,
-            'span.label': mutationEventEncoded.mutation,
-          },
-        }),
-        // Effect.logDuration('@livestore/common:leader-thread:applyMutation'),
-      )
-  },
-)
-
-const insertIntoMutationLog = (
-  mutationEventEncoded: MutationEvent.AnyEncoded,
-  dbLog: SynchronousDatabase,
-  mutationDefSchemaHashMap: Map<string, number>,
-) =>
-  Effect.gen(function* () {
-    const mutationName = mutationEventEncoded.mutation
-    const mutationDefSchemaHash =
-      mutationDefSchemaHashMap.get(mutationName) ?? shouldNeverHappen(`Unknown mutation: ${mutationName}`)
-
-    // TODO use prepared statements
-    yield* execSql(
-      dbLog,
-      ...insertRow({
-        tableName: MUTATION_LOG_META_TABLE,
-        columns: mutationLogMetaTable.sqliteDef.columns,
-        values: {
-          idGlobal: mutationEventEncoded.id.global,
-          idLocal: mutationEventEncoded.id.local,
-          parentIdGlobal: mutationEventEncoded.parentId.global,
-          parentIdLocal: mutationEventEncoded.parentId.local,
-          mutation: mutationEventEncoded.mutation,
-          argsJson: mutationEventEncoded.args ?? {},
-          schemaHash: mutationDefSchemaHash,
-          syncMetadataJson: Option.none(),
-        },
-      }),
-    )
-  })
-
-// TODO let's consider removing this "should exclude" mechanism in favour of log compaction etc
-const makeShouldExcludeMutationFromLog = memoizeByRef((schema: LiveStoreSchema) => {
-  const migrationOptions = schema.migrationOptions
-  const mutationLogExclude =
-    migrationOptions.strategy === 'from-mutation-log'
-      ? (migrationOptions.excludeMutations ?? new Set(['livestore.RawSql']))
-      : new Set(['livestore.RawSql'])
-
-  return (mutationName: string, mutationEventEncoded: MutationEvent.AnyEncoded): boolean => {
-    if (mutationLogExclude.has(mutationName)) return true
-
-    const mutationDef = schema.mutations.get(mutationName) ?? shouldNeverHappen(`Unknown mutation: ${mutationName}`)
-    const execArgsArr = getExecArgsFromMutation({
-      mutationDef,
-      mutationEvent: { decoded: undefined, encoded: mutationEventEncoded },
-    })
-
-    return execArgsArr.some((_) => _.statementSql.includes('__livestore'))
-  }
-})

package/src/leader-thread/mutationlog.ts

@@ -1,46 +0,0 @@
-import { Effect, Schema } from '@livestore/utils/effect'
-
-import type { SynchronousDatabase } from '../adapter-types.js'
-import * as EventId from '../schema/EventId.js'
-import type * as MutationEvent from '../schema/MutationEvent.js'
-import { MUTATION_LOG_META_TABLE, mutationLogMetaTable, SYNC_STATUS_TABLE } from '../schema/system-tables.js'
-import { prepareBindValues, sql } from '../util.js'
-import { LeaderThreadCtx } from './types.js'
-
-export const getMutationEventsSince = (
-  since: EventId.EventId,
-): Effect.Effect<ReadonlyArray<MutationEvent.AnyEncoded>, never, LeaderThreadCtx> =>
-  Effect.gen(function* () {
-    const { dbLog } = yield* LeaderThreadCtx
-
-    const query = mutationLogMetaTable.query.where('idGlobal', '>=', since.global).asSql()
-    const pendingMutationEventsRaw = dbLog.select(query.query, prepareBindValues(query.bindValues, query.query))
-    const pendingMutationEvents = Schema.decodeUnknownSync(mutationLogMetaTable.schema.pipe(Schema.Array))(
-      pendingMutationEventsRaw,
-    )
-
-    return pendingMutationEvents
-      .map((_) => ({
-        mutation: _.mutation,
-        args: _.argsJson,
-        id: { global: _.idGlobal, local: _.idLocal },
-        parentId: { global: _.parentIdGlobal, local: _.parentIdLocal },
-      }))
-      .filter((_) => EventId.compare(_.id, since) > 0)
-  })
-
-export const getLocalHeadFromDb = (dbLog: SynchronousDatabase): EventId.EventId => {
-  const res = dbLog.select<{ idGlobal: EventId.GlobalEventId; idLocal: EventId.LocalEventId }>(
-    sql`select idGlobal, idLocal from ${MUTATION_LOG_META_TABLE} order by idGlobal DESC, idLocal DESC limit 1`,
-  )[0]
-
-  return res ? { global: res.idGlobal, local: res.idLocal } : EventId.ROOT
-}
-
-export const getBackendHeadFromDb = (dbLog: SynchronousDatabase): EventId.GlobalEventId =>
-  dbLog.select<{ head: EventId.GlobalEventId }>(sql`select head from ${SYNC_STATUS_TABLE}`)[0]?.head ??
-  EventId.ROOT.global
-
-// TODO use prepared statements
-export const updateBackendHead = (dbLog: SynchronousDatabase, head: EventId.EventId) =>
-  dbLog.execute(sql`UPDATE ${SYNC_STATUS_TABLE} SET head = ${head.global}`)

package/src/leader-thread/pull-queue-set.ts

@@ -1,58 +0,0 @@
-import { Effect, Queue } from '@livestore/utils/effect'
-
-import * as MutationEvent from '../schema/MutationEvent.js'
-import { getMutationEventsSince } from './mutationlog.js'
-import { type PullQueueItem, type PullQueueSet } from './types.js'
-
-export const makePullQueueSet = Effect.gen(function* () {
-  const set = new Set<Queue.Queue<PullQueueItem>>()
-
-  yield* Effect.addFinalizer(() =>
-    Effect.gen(function* () {
-      for (const queue of set) {
-        yield* Queue.shutdown(queue)
-      }
-
-      set.clear()
-    }),
-  )
-
-  const makeQueue: PullQueueSet['makeQueue'] = (since) =>
-    Effect.gen(function* () {
-      const queue = yield* Queue.unbounded<PullQueueItem>().pipe(Effect.acquireRelease(Queue.shutdown))
-
-      yield* Effect.addFinalizer(() => Effect.sync(() => set.delete(queue)))
-
-      const mutationEvents = yield* getMutationEventsSince(since)
-
-      if (mutationEvents.length > 0) {
-        const newEvents = mutationEvents.map((mutationEvent) => new MutationEvent.EncodedWithMeta(mutationEvent))
-        yield* queue.offer({ payload: { _tag: 'upstream-advance', newEvents }, remaining: 0 })
-      }
-
-      set.add(queue)
-
-      return queue
-    })
-
-  const offer: PullQueueSet['offer'] = (item) =>
-    Effect.gen(function* () {
-      // Short-circuit if the payload is an empty upstream advance
-      if (
-        item.payload._tag === 'upstream-advance' &&
-        item.payload.newEvents.length === 0 &&
-        item.payload.trimRollbackUntil === undefined
-      ) {
-        return
-      }
-
-      for (const queue of set) {
-        yield* Queue.offer(queue, item)
-      }
-    })
-
-  return {
-    makeQueue,
-    offer,
-  }
-})

package/src/mutation.ts

@@ -1,91 +0,0 @@
-import { Schema } from '@livestore/utils/effect'
-
-import { SessionIdSymbol } from './adapter-types.js'
-import type * as MutationEvent from './schema/MutationEvent.js'
-import type { MutationDef } from './schema/mutations.js'
-import type { PreparedBindValues } from './util.js'
-import { prepareBindValues } from './util.js'
-
-export const getExecArgsFromMutation = ({
-  mutationDef,
-  mutationEvent,
-}: {
-  mutationDef: MutationDef.Any
-  /** Both encoded and decoded mutation events are supported to reduce the number of times we need to decode/encode */
-  mutationEvent:
-    | {
-        decoded: MutationEvent.AnyDecoded | MutationEvent.PartialAnyDecoded
-        encoded: undefined
-      }
-    | {
-        decoded: undefined
-        encoded: MutationEvent.AnyEncoded | MutationEvent.PartialAnyEncoded
-      }
-}): ReadonlyArray<{
-  statementSql: string
-  bindValues: PreparedBindValues
-  writeTables: ReadonlySet<string> | undefined
-}> => {
-  let statementRes: ReadonlyArray<
-    string | { sql: string; bindValues: Record<string, unknown>; writeTables?: ReadonlySet<string> }
-  >
-
-  switch (typeof mutationDef.sql) {
-    case 'function': {
-      const mutationArgsDecoded =
-        mutationEvent.decoded?.args ?? Schema.decodeUnknownSync(mutationDef.schema)(mutationEvent.encoded!.args)
-      const res = mutationDef.sql(mutationArgsDecoded)
-      statementRes = Array.isArray(res) ? res : [res]
-      break
-    }
-    case 'string': {
-      statementRes = [mutationDef.sql]
-      break
-    }
-    default: {
-      statementRes = mutationDef.sql
-      break
-    }
-  }
-
-  return statementRes.map((statementRes) => {
-    const statementSql = typeof statementRes === 'string' ? statementRes : statementRes.sql
-
-    const mutationArgsEncoded =
-      mutationEvent.encoded?.args ?? Schema.encodeUnknownSync(mutationDef.schema)(mutationEvent.decoded!.args)
-    const bindValues = typeof statementRes === 'string' ? mutationArgsEncoded : statementRes.bindValues
-
-    const writeTables = typeof statementRes === 'string' ? undefined : statementRes.writeTables
-
-    return { statementSql, bindValues: prepareBindValues(bindValues ?? {}, statementSql), writeTables }
-  })
-}
-
-// NOTE we should explore whether there is a more elegant solution
-// e.g. by leveraging the schema to replace the sessionIdSymbol
-export const replaceSessionIdSymbol = (
-  bindValues: Record<string, unknown> | ReadonlyArray<unknown>,
-  sessionId: string,
-) => {
-  deepReplaceValue(bindValues, SessionIdSymbol, sessionId)
-}
-
-const deepReplaceValue = <S, R>(input: any, searchValue: S, replaceValue: R): void => {
-  if (Array.isArray(input)) {
-    for (const i in input) {
-      if (input[i] === searchValue) {
-        input[i] = replaceValue
-      } else {
-        deepReplaceValue(input[i], searchValue, replaceValue)
-      }
-    }
-  } else if (typeof input === 'object' && input !== null) {
-    for (const key in input) {
-      if (input[key] === searchValue) {
-        input[key] = replaceValue
-      } else {
-        deepReplaceValue(input[key], searchValue, replaceValue)
-      }
-    }
-  }
-}