@livestore/common 0.3.1-dev.0 → 0.3.2-dev.0

package/src/adapter-types.ts

@@ -1,30 +1,22 @@
-import type { Cause, Queue, Scope, SubscriptionRef, WebChannel } from '@livestore/utils/effect'
-import { Effect, Schema, Stream } from '@livestore/utils/effect'
-
+import {
+  type Cause,
+  type Effect,
+  type Queue,
+  Schema,
+  type Scope,
+  type SubscriptionRef,
+  type WebChannel,
+} from '@livestore/utils/effect'
+
+import type { ClientSessionLeaderThreadProxy } from './ClientSessionLeaderThreadProxy.js'
 import type * as Devtools from './devtools/mod.js'
-import * as EventSequenceNumber from './schema/EventSequenceNumber.js'
-import type { LiveStoreEvent, LiveStoreSchema } from './schema/mod.js'
-import type { LeaderAheadError } from './sync/sync.js'
-import type { PayloadUpstream, SyncState } from './sync/syncstate.js'
-import type { PreparedBindValues } from './util.js'
-
-export interface PreparedStatement {
-  execute(bindValues: PreparedBindValues | undefined, options?: { onRowsChanged?: (rowsChanged: number) => void }): void
-  select<T>(bindValues: PreparedBindValues | undefined): ReadonlyArray<T>
-  finalize(): void
-  sql: string
-}
-
-export type SqliteDbSession = {
-  changeset: () => Uint8Array | undefined
-  finish: () => void
-}
-
-export type SqliteDbChangeset = {
-  // TODO combining changesets (requires changes in the SQLite WASM binding)
-  invert: () => SqliteDbChangeset
-  apply: () => void
-}
+import type { IntentionalShutdownCause, SyncError, UnexpectedError } from './errors.js'
+import type { LiveStoreSchema } from './schema/mod.js'
+import type { SqliteDb } from './sqlite-types.js'
+export * as ClientSessionLeaderThreadProxy from './ClientSessionLeaderThreadProxy.js'
+export * from './defs.js'
+export * from './errors.js'
+export * from './sqlite-types.js'
 
 export interface ClientSession {
   /** SQLite database with synchronous API running in the same thread (usually in-memory) */
@@ -34,87 +26,13 @@ export interface ClientSession {
   sessionId: string
   /** Status info whether current session is leader or not */
   lockStatus: SubscriptionRef.SubscriptionRef<LockStatus>
-  shutdown: (cause: Cause.Cause<UnexpectedError | IntentionalShutdownCause>) => Effect.Effect<void>
+  shutdown: (cause: Cause.Cause<UnexpectedError | IntentionalShutdownCause | SyncError>) => Effect.Effect<void>
   /** A proxy API to communicate with the leader thread */
   leaderThread: ClientSessionLeaderThreadProxy
   /** A unique identifier for the current instance of the client session. Used for debugging purposes. */
   debugInstanceId: string
 }
 
-export const LeaderPullCursor = Schema.Struct({
-  mergeCounter: Schema.Number,
-  eventNum: EventSequenceNumber.EventSequenceNumber,
-})
-
-export type LeaderPullCursor = typeof LeaderPullCursor.Type
-
-export interface ClientSessionLeaderThreadProxy {
-  events: {
-    pull: (args: {
-      cursor: LeaderPullCursor
-    }) => Stream.Stream<{ payload: typeof PayloadUpstream.Type; mergeCounter: number }, UnexpectedError>
-    /** It's important that a client session doesn't call `push` concurrently. */
-    push(batch: ReadonlyArray<LiveStoreEvent.AnyEncoded>): Effect.Effect<void, UnexpectedError | LeaderAheadError>
-  }
-  /** The initial state after the leader thread has booted */
-  readonly initialState: {
-    /** The latest event sequence number during boot. Used for the client session to resume syncing. */
-    readonly leaderHead: EventSequenceNumber.EventSequenceNumber
-    /** The migrations report from the leader thread */
-    readonly migrationsReport: MigrationsReport
-  }
-  export: Effect.Effect<Uint8Array, UnexpectedError>
-  getEventlogData: Effect.Effect<Uint8Array, UnexpectedError>
-  getSyncState: Effect.Effect<SyncState, UnexpectedError>
-  /** For debugging purposes it can be useful to manually trigger devtools messages (e.g. to reset the database) */
-  sendDevtoolsMessage: (message: Devtools.Leader.MessageToApp) => Effect.Effect<void, UnexpectedError>
-}
-
-/**
- * Common interface for SQLite databases used by LiveStore to facilitate a consistent API across different platforms.
- * Always assumes a synchronous SQLite build with the `bytecode` and `session` extensions enabled.
- * Can be either in-memory or persisted to disk.
- */
-export interface SqliteDb<TReq = any, TMetadata extends TReq = TReq> {
-  _tag: 'SqliteDb'
-  metadata: TMetadata
-  prepare(queryStr: string): PreparedStatement
-  execute(
-    queryStr: string,
-    bindValues?: PreparedBindValues | undefined,
-    options?: { onRowsChanged?: (rowsChanged: number) => void },
-  ): void
-  select<T>(queryStr: string, bindValues?: PreparedBindValues | undefined): ReadonlyArray<T>
-  export(): Uint8Array
-  import: (data: Uint8Array | SqliteDb<TReq>) => void
-  close(): void
-  destroy(): void
-  session(): SqliteDbSession
-  makeChangeset: (data: Uint8Array) => SqliteDbChangeset
-}
-
-// TODO refactor this helper type. It's quite cumbersome to use and should be revisited.
-export type MakeSqliteDb<
-  TReq = { dbPointer: number; persistenceInfo: PersistenceInfo },
-  TInput_ extends { _tag: string } = { _tag: string },
-  TMetadata_ extends TReq = TReq,
-  R = never,
-> = <
-  TInput extends TInput_,
-  TMetadata extends TMetadata_ & { _tag: TInput['_tag'] } = TMetadata_ & { _tag: TInput['_tag'] },
->(
-  input: TInput,
-) => Effect.Effect<SqliteDb<TReq, Extract<TMetadata, { _tag: TInput['_tag'] }>>, SqliteError | UnexpectedError, R>
-
-export const PersistenceInfo = Schema.Struct(
-  {
-    fileName: Schema.String,
-  },
-  { key: Schema.String, value: Schema.Any },
-).annotations({ title: 'LiveStore.PersistenceInfo' })
-
-export type PersistenceInfo<With extends {} = {}> = typeof PersistenceInfo.Type & With
-
 export type ResetMode = 'all-data' | 'only-app-db'
 
 export const BootStateProgress = Schema.Struct({
@@ -159,50 +77,6 @@ export type SessionIdSymbol = typeof SessionIdSymbol
 
 export type LockStatus = 'has-lock' | 'no-lock'
 
-export class UnexpectedError extends Schema.TaggedError<UnexpectedError>()('LiveStore.UnexpectedError', {
-  cause: Schema.Defect,
-  note: Schema.optional(Schema.String),
-  payload: Schema.optional(Schema.Any),
-}) {
-  static mapToUnexpectedError = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-    effect.pipe(
-      Effect.mapError((cause) => (Schema.is(UnexpectedError)(cause) ? cause : new UnexpectedError({ cause }))),
-      Effect.catchAllDefect((cause) => new UnexpectedError({ cause })),
-    )
-
-  static mapToUnexpectedErrorStream = <A, E, R>(stream: Stream.Stream<A, E, R>) =>
-    stream.pipe(
-      Stream.mapError((cause) => (Schema.is(UnexpectedError)(cause) ? cause : new UnexpectedError({ cause }))),
-    )
-}
-
-export class IntentionalShutdownCause extends Schema.TaggedError<IntentionalShutdownCause>()(
-  'LiveStore.IntentionalShutdownCause',
-  {
-    reason: Schema.Literal('devtools-reset', 'devtools-import', 'adapter-reset', 'manual'),
-  },
-) {}
-
-export class StoreInterrupted extends Schema.TaggedError<StoreInterrupted>()('LiveStore.StoreInterrupted', {
-  reason: Schema.String,
-}) {}
-
-export class SqliteError extends Schema.TaggedError<SqliteError>()('LiveStore.SqliteError', {
-  query: Schema.optional(
-    Schema.Struct({
-      sql: Schema.String,
-      bindValues: Schema.Union(Schema.Record({ key: Schema.String, value: Schema.Any }), Schema.Array(Schema.Any)),
-    }),
-  ),
-  /** The SQLite result code */
-  // code: Schema.optional(Schema.Number),
-  // Added string support for Expo SQLite (we should refactor this to have a unified error type)
-  code: Schema.optional(Schema.Union(Schema.Number, Schema.String)),
-  /** The original SQLite3 error */
-  cause: Schema.Defect,
-  note: Schema.optional(Schema.String),
-}) {}
-
 // TODO possibly allow a combination of these options
 // TODO allow a way to stream the migration progress back to the app
 export type MigrationOptions =
@@ -253,19 +127,3 @@ export interface AdapterArgs {
    */
   syncPayload: Schema.JsonValue | undefined
 }
-
-export const MigrationsReportEntry = Schema.Struct({
-  tableName: Schema.String,
-  hashes: Schema.Struct({
-    expected: Schema.Number,
-    actual: Schema.optional(Schema.Number),
-  }),
-})
-
-export const MigrationsReport = Schema.Struct({
-  migrations: Schema.Array(MigrationsReportEntry),
-})
-
-export type MigrationsReport = typeof MigrationsReport.Type
-
-export type MigrationsReportEntry = typeof MigrationsReportEntry.Type

package/src/defs.ts

@@ -0,0 +1,17 @@
+import { Schema } from '@livestore/utils/effect'
+
+export const MigrationsReportEntry = Schema.Struct({
+  tableName: Schema.String,
+  hashes: Schema.Struct({
+    expected: Schema.Number,
+    actual: Schema.optional(Schema.Number),
+  }),
+})
+
+export const MigrationsReport = Schema.Struct({
+  migrations: Schema.Array(MigrationsReportEntry),
+})
+
+export type MigrationsReport = typeof MigrationsReport.Type
+
+export type MigrationsReportEntry = typeof MigrationsReportEntry.Type

package/src/errors.ts

@@ -0,0 +1,49 @@
+import { Effect, Schema, Stream } from '@livestore/utils/effect'
+
+export class UnexpectedError extends Schema.TaggedError<UnexpectedError>()('LiveStore.UnexpectedError', {
+  cause: Schema.Defect,
+  note: Schema.optional(Schema.String),
+  payload: Schema.optional(Schema.Any),
+}) {
+  static mapToUnexpectedError = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+    effect.pipe(
+      Effect.mapError((cause) => (Schema.is(UnexpectedError)(cause) ? cause : new UnexpectedError({ cause }))),
+      Effect.catchAllDefect((cause) => new UnexpectedError({ cause })),
+    )
+
+  static mapToUnexpectedErrorStream = <A, E, R>(stream: Stream.Stream<A, E, R>) =>
+    stream.pipe(
+      Stream.mapError((cause) => (Schema.is(UnexpectedError)(cause) ? cause : new UnexpectedError({ cause }))),
+    )
+}
+
+export class SyncError extends Schema.TaggedError<SyncError>()('LiveStore.SyncError', {
+  cause: Schema.Defect,
+}) {}
+
+export class IntentionalShutdownCause extends Schema.TaggedError<IntentionalShutdownCause>()(
+  'LiveStore.IntentionalShutdownCause',
+  {
+    reason: Schema.Literal('devtools-reset', 'devtools-import', 'adapter-reset', 'manual'),
+  },
+) {}
+
+export class StoreInterrupted extends Schema.TaggedError<StoreInterrupted>()('LiveStore.StoreInterrupted', {
+  reason: Schema.String,
+}) {}
+
+export class SqliteError extends Schema.TaggedError<SqliteError>()('LiveStore.SqliteError', {
+  query: Schema.optional(
+    Schema.Struct({
+      sql: Schema.String,
+      bindValues: Schema.Union(Schema.Record({ key: Schema.String, value: Schema.Any }), Schema.Array(Schema.Any)),
+    }),
+  ),
+  /** The SQLite result code */
+  // code: Schema.optional(Schema.Number),
+  // Added string support for Expo SQLite (we should refactor this to have a unified error type)
+  code: Schema.optional(Schema.Union(Schema.Number, Schema.String)),
+  /** The original SQLite3 error */
+  cause: Schema.Defect,
+  note: Schema.optional(Schema.String),
+}) {}

package/src/index.ts

@@ -13,3 +13,4 @@ export * from './schema/state/sqlite/query-builder/mod.js'
 export * as SyncState from './sync/syncstate.js'
 export * from './otel.js'
 export * from './make-client-session.js'
+export * as SqliteDbHelper from './sqlite-db-helper.js'