@livestore/common 0.3.1 → 0.3.2-dev.1

package/src/adapter-types.ts

@@ -1,31 +1,23 @@
-import type { Cause, Queue, Scope, SubscriptionRef, WebChannel } from '@livestore/utils/effect'
-import { Effect, Schema, Stream } from '@livestore/utils/effect'
-
-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 { QueryBuilder } from './schema/state/sqlite/query-builder/api.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 Cause,
+  type Effect,
+  type Queue,
+  Schema,
+  type Scope,
+  type SubscriptionRef,
+  type WebChannel,
+} from '@livestore/utils/effect'
+
+import type { ClientSessionLeaderThreadProxy } from './ClientSessionLeaderThreadProxy.ts'
+import type * as Devtools from './devtools/mod.ts'
+import type { IntentionalShutdownCause, SyncError, UnexpectedError } from './errors.ts'
+import type { LiveStoreSchema } from './schema/mod.ts'
+import type { SqliteDb } from './sqlite-types.ts'
+
+export * as ClientSessionLeaderThreadProxy from './ClientSessionLeaderThreadProxy.ts'
+export * from './defs.ts'
+export * from './errors.ts'
+export * from './sqlite-types.ts'
 
 export interface ClientSession {
   /** SQLite database with synchronous API running in the same thread (usually in-memory) */
@@ -35,91 +27,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
-  execute(queryBuilder: QueryBuilder.Any, options?: { onRowsChanged?: (rowsChanged: number) => void }): void
-
-  select<T>(queryStr: string, bindValues?: PreparedBindValues | undefined): ReadonlyArray<T>
-  select<T>(queryBuilder: QueryBuilder<T, any, any>): 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({
@@ -164,50 +78,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 =
@@ -258,19 +128,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/debug-info.ts

@@ -1,8 +1,8 @@
 /// <reference lib="dom" />
 import { ParseResult, Schema } from '@livestore/utils/effect'
 
-import { BoundArray } from './bounded-collections.js'
-import { PreparedBindValues } from './util.js'
+import { BoundArray } from './bounded-collections.ts'
+import { PreparedBindValues } from './util.ts'
 
 export type SlowQueryInfo = {
   queryStr: string

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/devtools/devtools-messages-client-session.ts

@@ -1,9 +1,9 @@
 import { Schema } from '@livestore/utils/effect'
 
-import { DebugInfo } from '../debug-info.js'
-import { EventSequenceNumber } from '../schema/mod.js'
-import { PreparedBindValues } from '../util.js'
-import { LSDClientSessionChannelMessage, LSDClientSessionReqResMessage } from './devtools-messages-common.js'
+import { DebugInfo } from '../debug-info.ts'
+import { EventSequenceNumber } from '../schema/mod.ts'
+import { PreparedBindValues } from '../util.ts'
+import { LSDClientSessionChannelMessage, LSDClientSessionReqResMessage } from './devtools-messages-common.ts'
 
 export class DebugInfoReq extends LSDClientSessionReqResMessage('LSD.ClientSession.DebugInfoReq', {}) {}
 

package/src/devtools/devtools-messages-common.ts

@@ -1,6 +1,6 @@
 import { Schema } from '@livestore/utils/effect'
 
-import { liveStoreVersion as pkgVersion } from '../version.js'
+import { liveStoreVersion as pkgVersion } from '../version.ts'
 
 export const NetworkStatus = Schema.Struct({
   isConnected: Schema.Boolean,

package/src/devtools/devtools-messages-leader.ts

@@ -1,9 +1,9 @@
 import { Schema, Transferable } from '@livestore/utils/effect'
 
-import * as LiveStoreEvent from '../schema/LiveStoreEvent.js'
-import { EventSequenceNumber } from '../schema/mod.js'
-import * as SyncState from '../sync/syncstate.js'
-import { LeaderReqResMessage, LSDMessage, LSDReqResMessage, NetworkStatus } from './devtools-messages-common.js'
+import * as LiveStoreEvent from '../schema/LiveStoreEvent.ts'
+import { EventSequenceNumber } from '../schema/mod.ts'
+import * as SyncState from '../sync/syncstate.ts'
+import { LeaderReqResMessage, LSDMessage, LSDReqResMessage, NetworkStatus } from './devtools-messages-common.ts'
 
 export class ResetAllDataReq extends LSDReqResMessage('LSD.Leader.ResetAllDataReq', {
   mode: Schema.Literal('all-data', 'only-app-db'),

package/src/devtools/devtools-messages.ts

@@ -1,3 +1,3 @@
-export * as ClientSession from './devtools-messages-client-session.js'
-export * as Leader from './devtools-messages-leader.js'
-export * from './devtools-messages-common.js'
+export * as ClientSession from './devtools-messages-client-session.ts'
+export * from './devtools-messages-common.ts'
+export * as Leader from './devtools-messages-leader.ts'

package/src/devtools/mod.ts

@@ -3,10 +3,10 @@ import { Schema } from '@livestore/utils/effect'
 import { nanoid } from '@livestore/utils/nanoid'
 import type { MeshNode } from '@livestore/webmesh'
 
-import * as SessionInfo from './devtools-sessioninfo.js'
+import * as SessionInfo from './devtools-sessioninfo.ts'
 
-export * from './devtools-messages.js'
-export * as SessionInfo from './devtools-sessioninfo.js'
+export * from './devtools-messages.ts'
+export * as SessionInfo from './devtools-sessioninfo.ts'
 
 export const DevtoolsMode = Schema.Union(
   Schema.TaggedStruct('node', {

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

@@ -1,16 +1,16 @@
-export * from './schema/state/sqlite/system-tables.js'
-export * from './util.js'
-export * from './adapter-types.js'
-export * from './schema-management/migrations.js'
-export * from './materializer-helper.js'
-export * from './rematerialize-from-eventlog.js'
-export * from './sync/index.js'
-export * as Devtools from './devtools/mod.js'
-export * from './debug-info.js'
-export * from './bounded-collections.js'
-export * from './version.js'
-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'
+export * from './adapter-types.ts'
+export * from './bounded-collections.ts'
+export * from './debug-info.ts'
+export * as Devtools from './devtools/mod.ts'
+export * from './make-client-session.ts'
+export * from './materializer-helper.ts'
+export * from './otel.ts'
+export * from './rematerialize-from-eventlog.ts'
+export * from './schema/state/sqlite/query-builder/mod.ts'
+export * from './schema/state/sqlite/system-tables.ts'
+export * from './schema-management/migrations.ts'
+export * as SqliteDbHelper from './sqlite-db-helper.ts'
+export * from './sync/index.ts'
+export * as SyncState from './sync/syncstate.ts'
+export * from './util.ts'
+export * from './version.ts'