@livestore/common 0.4.0 → 0.5.0-dev.1

package/src/errors.ts

@@ -1,77 +1,89 @@
-import { Cause, Effect, Layer, Schema, Stream } from '@livestore/utils/effect'
+import { Cause, Effect, Layer, Option, Schema, Stream, Struct } from '@livestore/utils/effect'
 
 import * as LiveStoreEvent from './schema/LiveStoreEvent/mod.ts'
 
 export class UnknownError extends Schema.TaggedError<UnknownError>('~@livestore/common/UnknownError')('UnknownError', {
-  cause: Schema.Defect,
+  cause: Schema.Defect(),
   note: Schema.optional(Schema.String),
   payload: Schema.optional(Schema.Any),
 }) {
   static mapToUnknownError = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
     effect.pipe(
       Effect.mapError((cause) => (Schema.is(UnknownError)(cause) === true ? cause : new UnknownError({ cause }))),
-      Effect.catchAllDefect((cause) => new UnknownError({ cause })),
+      Effect.catchDefect((cause) => new UnknownError({ cause })),
     )
 
   static mapToUnknownErrorLayer = <A, E, R>(layer: Layer.Layer<A, E, R>) =>
     layer.pipe(
-      Layer.catchAllCause((cause) =>
-        Cause.isFailType(cause) === true && Schema.is(UnknownError)(cause.error) === true
-          ? Layer.fail(cause.error)
-          : Layer.fail(new UnknownError({ cause: cause })),
-      ),
+      Layer.catchCause((cause) => {
+        const error = Cause.findErrorOption(cause)
+        return Option.isSome(error) === true && Schema.is(UnknownError)(error.value) === true
+          ? Layer.effectContext<A, UnknownError, never>(Effect.fail(error.value))
+          : Layer.effectContext<A, UnknownError, never>(Effect.fail(new UnknownError({ cause: cause })))
+      }),
     )
 
   static mapToUnknownErrorStream = <A, E, R>(stream: Stream.Stream<A, E, R>) =>
-    stream.pipe(Stream.mapError((cause) => (Schema.is(UnknownError)(cause) === true ? cause : new UnknownError({ cause }))))
+    stream.pipe(
+      Stream.mapError((cause) => (Schema.is(UnknownError)(cause) === true ? cause : new UnknownError({ cause }))),
+    )
 }
 
+const materializerHashMismatchNote = 'Please make sure your event materializer is a pure function without side effects.'
+
 export class MaterializerHashMismatchError extends Schema.TaggedError<MaterializerHashMismatchError>(
   '~@livestore/common/MaterializerHashMismatchError',
 )('MaterializerHashMismatchError', {
-    eventName: Schema.String,
-    note: Schema.optionalWith(Schema.String, {
-      default: () => 'Please make sure your event materializer is a pure function without side effects.',
-    }),
-  },
-) {}
+  eventName: Schema.String,
+  note: Schema.String.pipe(
+    Schema.withDecodingDefaultType(Effect.succeed(materializerHashMismatchNote)),
+    Schema.withConstructorDefault(Effect.succeed(materializerHashMismatchNote)),
+  ),
+}) {}
 
 export class IntentionalShutdownCause extends Schema.TaggedError<IntentionalShutdownCause>(
   '~@livestore/common/IntentionalShutdownCause',
 )('IntentionalShutdownCause', {
-  reason: Schema.Literal('devtools-reset', 'devtools-import', 'adapter-reset', 'manual', 'backend-id-mismatch'),
+  reason: Schema.Literals(['devtools-reset', 'devtools-import', 'adapter-reset', 'manual', 'backend-id-mismatch']),
 }) {}
 
-export class StoreInterrupted extends Schema.TaggedError<StoreInterrupted>(
-  '~@livestore/common/StoreInterrupted',
-)('StoreInterrupted', {
-  reason: Schema.String,
-}) {}
+export class StoreInterrupted extends Schema.TaggedError<StoreInterrupted>('~@livestore/common/StoreInterrupted')(
+  'StoreInterrupted',
+  {
+    reason: Schema.String,
+  },
+) {}
 
 export class SqliteError extends Schema.TaggedError<SqliteError>('~@livestore/common/SqliteError')('SqliteError', {
   query: Schema.optional(
     Schema.Struct({
       sql: Schema.String,
-      bindValues: Schema.Union(Schema.Record({ key: Schema.String, value: Schema.Any }), Schema.Array(Schema.Any)),
+      bindValues: Schema.Union([Schema.Record(Schema.String, 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)),
+  code: Schema.optional(Schema.Union([Schema.Finite, Schema.String])),
   /** The original SQLite3 error */
-  cause: Schema.Defect,
+  cause: Schema.Defect(),
   note: Schema.optional(Schema.String),
 }) {}
 
-export class UnknownEventError extends Schema.TaggedError<UnknownEventError>('~@livestore/common/UnknownEventError')('UnknownEventError', {
-  event: LiveStoreEvent.Client.Encoded.pipe(Schema.pick('name', 'args', 'seqNum', 'clientId', 'sessionId')),
-  reason: Schema.Literal('event-definition-missing', 'materializer-missing'),
-  operation: Schema.String,
-  note: Schema.optional(Schema.String),
-}) {}
+export class UnknownEventError extends Schema.TaggedError<UnknownEventError>('~@livestore/common/UnknownEventError')(
+  'UnknownEventError',
+  {
+    event: LiveStoreEvent.Client.Encoded.mapFields(Struct.pick(['name', 'args', 'seqNum', 'clientId', 'sessionId'])),
+    reason: Schema.Literals(['event-definition-missing', 'materializer-missing']),
+    operation: Schema.String,
+    note: Schema.optional(Schema.String),
+  },
+) {}
 
-export class MaterializeError extends Schema.TaggedError<MaterializeError>('~@livestore/common/MaterializeError')('MaterializeError', {
-  cause: Schema.Union(MaterializerHashMismatchError, SqliteError, UnknownEventError),
-  note: Schema.optional(Schema.String),
-}) {}
+export class MaterializeError extends Schema.TaggedError<MaterializeError>('~@livestore/common/MaterializeError')(
+  'MaterializeError',
+  {
+    cause: Schema.Union([MaterializerHashMismatchError, SqliteError, UnknownEventError]),
+    note: Schema.optional(Schema.String),
+  },
+) {}

package/src/index.ts

@@ -2,16 +2,23 @@ export * from './adapter-types.ts'
 export * from './bounded-collections.ts'
 export * from './debug-info.ts'
 export * as Devtools from './devtools/mod.ts'
+export * from './leader-thread/RejectedPushError.ts'
 export * as LogConfig from './logging.ts'
 export * from './make-client-session.ts'
+export * as MaterializationJournal from './MaterializationJournal.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/mod.ts'
 export * from './schema-management/migrations.ts'
+export {
+  resolveSessionIdSymbolInBindValues,
+  SessionIdSymbol,
+  type BindableWithSessionIdSymbol,
+} from './session-id-symbol.ts'
 export * as SqliteDbHelper from './sqlite-db-helper.ts'
-export * from './leader-thread/RejectedPushError.ts'
+export * as StateHead from './StateHead.ts'
 export * from './sync/index.ts'
 export * as SyncState from './sync/syncstate.ts'
 export * from './util.ts'