@livestore/utils 0.0.54-dev.22 → 0.0.54-dev.24

package/src/effect/Effect.ts

@@ -1,5 +1,6 @@
-import type { Context, Duration } from 'effect'
-import { Cause, Deferred, Effect, pipe } from 'effect'
+import type { Context, Duration, Scope } from 'effect'
+import { Cause, Deferred, Effect, Fiber, pipe } from 'effect'
+import { log } from 'effect/Console'
 import type { LazyArg } from 'effect/Function'
 
 import { isNonEmptyString } from '../index.js'
@@ -7,20 +8,20 @@ import { UnknownError } from './Error.js'
 
 export * from 'effect/Effect'
 
-export const log = <A>(message: A, ...rest: any[]): Effect.Effect<void> =>
-  Effect.sync(() => {
-    console.log(message, ...rest)
-  })
+// export const log = <A>(message: A, ...rest: any[]): Effect.Effect<void> =>
+//   Effect.sync(() => {
+//     console.log(message, ...rest)
+//   })
 
-export const logWarn = <A>(message: A, ...rest: any[]): Effect.Effect<void> =>
-  Effect.sync(() => {
-    console.warn(message, ...rest)
-  })
+// export const logWarn = <A>(message: A, ...rest: any[]): Effect.Effect<void> =>
+//   Effect.sync(() => {
+//     console.warn(message, ...rest)
+//   })
 
-export const logError = <A>(message: A, ...rest: any[]): Effect.Effect<void> =>
-  Effect.sync(() => {
-    console.error(message, ...rest)
-  })
+// export const logError = <A>(message: A, ...rest: any[]): Effect.Effect<void> =>
+//   Effect.sync(() => {
+//     console.error(message, ...rest)
+//   })
 
 const getThreadName = () =>
   isNonEmptyString(self.name) ? self.name : typeof window === 'object' ? 'Browser Main Thread' : 'unknown-thread'
@@ -29,17 +30,51 @@ const getThreadName = () =>
 export const tapCauseLogPretty = <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
   Effect.tapErrorCause(eff, (err) => {
     if (Cause.isInterruptedOnly(err)) {
+      // console.log('interrupted', Cause.pretty(err), err)
       return Effect.void
     }
 
     const threadName = getThreadName()
 
     // const prettyError = (err as any).error ? (err as any).error.toString() : Cause.pretty(err)
-    const prettyError = Cause.pretty(err)
+    // const prettyError = Cause.pretty(err)
 
-    return logError(`Error on ${threadName}:`, prettyError)
+    // return Effect.logError(`Error on ${threadName}:`, prettyError)
+    const firstErrLine = err.toString().split('\n')[0]
+    return Effect.logError(`Error on ${threadName}: ${firstErrLine}`, err)
   })
 
+export const logWarnIfTakesLongerThan =
+  ({ label, duration }: { label: string; duration: Duration.DurationInput }) =>
+  <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.gen(function* () {
+      const runtime = yield* Effect.runtime<never>()
+
+      let timedOut = false
+
+      const timeoutFiber = Effect.sleep(duration).pipe(
+        Effect.tap(() => {
+          timedOut = true
+          // TODO include span info
+          return Effect.logWarning(`${label}: Took longer than ${duration}ms`)
+        }),
+        Effect.provide(runtime),
+        Effect.runFork,
+      )
+
+      const start = Date.now()
+      const res = yield* eff
+
+      if (timedOut) {
+        const end = Date.now()
+        yield* Effect.logWarning(`${label}: Actual duration: ${end - start}ms`)
+      }
+
+      yield* Fiber.interrupt(timeoutFiber)
+
+      return res
+    })
+
 export const tapSync =
   <A>(tapFn: (a: A) => unknown) =>
   <R, E>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
@@ -67,14 +102,15 @@ export const timeoutDieMsg =
 
 export const toForkedDeferred = <R, E, A>(
   eff: Effect.Effect<A, E, R>,
-): Effect.Effect<Deferred.Deferred<A, E>, never, R> =>
+): Effect.Effect<Deferred.Deferred<A, E>, never, R | Scope.Scope> =>
   pipe(
     Deferred.make<A, E>(),
     Effect.tap((deferred) =>
       pipe(
         Effect.exit(eff),
         Effect.flatMap((ex) => Deferred.done(deferred, ex)),
-        Effect.forkDaemon,
+        tapCauseLogPretty,
+        Effect.forkScoped,
       ),
     ),
   )

package/src/effect/Schema.ts

@@ -1,5 +1,8 @@
+import { Transferable } from '@effect/platform'
 import { Schema } from '@effect/schema'
-import { Hash } from 'effect'
+import type { ParseOptions } from '@effect/schema/AST'
+import type { ParseError } from '@effect/schema/ParseResult'
+import { Effect, Hash } from 'effect'
 
 import { objectToString } from '../misc.js'
 
@@ -21,7 +24,7 @@ export const hash = (schema: Schema.Schema<any>) => {
 
 const errorStructSchema = Schema.Struct({
   message: Schema.String,
-  stack: Schema.String,
+  stack: Schema.optional(Schema.String),
 })
 
 export class AnyError extends Schema.transform(errorStructSchema, Schema.Any, {
@@ -41,3 +44,16 @@ export class AnyError extends Schema.transform(errorStructSchema, Schema.Any, {
     stack: anyError.stack,
   }),
 }) {}
+
+export const encodeWithTransferables =
+  <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) =>
+  (a: A, overrideOptions?: ParseOptions | undefined): Effect.Effect<[I, Transferable[]], ParseError, R> =>
+    Effect.gen(function* () {
+      const collector = yield* Transferable.makeCollector
+
+      const encoded: I = yield* Schema.encode(schema, options)(a, overrideOptions).pipe(
+        Effect.provideService(Transferable.Collector, collector),
+      )
+
+      return [encoded, collector.unsafeRead() as Transferable[]]
+    })

package/src/effect/SubscriptionRef.ts

@@ -1,15 +1,30 @@
-import type { Effect } from 'effect'
-import { pipe, Stream, SubscriptionRef } from 'effect'
+import { Chunk, Effect, pipe, Stream, SubscriptionRef } from 'effect'
 import { dual } from 'effect/Function'
+import type { Predicate, Refinement } from 'effect/Predicate'
 
 export * from 'effect/SubscriptionRef'
 
 export const changeStreamIncludingCurrent = <A>(sref: SubscriptionRef.SubscriptionRef<A>) =>
   pipe(Stream.fromEffect(SubscriptionRef.get(sref)), Stream.concat(sref.changes))
 
-export const waitUntil = dual<
-  <A>(predicate: (a: A) => boolean) => (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<void>,
-  <A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: (a: A) => boolean) => Effect.Effect<void>
->(2, <A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: (a: A) => boolean) =>
-  pipe(changeStreamIncludingCurrent(sref), Stream.filter(predicate), Stream.take(1), Stream.runDrain),
+export const waitUntil: {
+  <A, B extends A>(
+    refinement: Refinement<NoInfer<A>, B>,
+  ): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<B, never, never>
+  <A, B extends A>(
+    predicate: Predicate<B>,
+  ): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<A, never, never>
+  <A, B extends A>(
+    sref: SubscriptionRef.SubscriptionRef<A>,
+    refinement: Refinement<NoInfer<A>, B>,
+  ): Effect.Effect<B, never, never>
+  <A, B extends A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: Predicate<B>): Effect.Effect<A, never, never>
+} = dual(2, <A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: (a: A) => boolean) =>
+  pipe(
+    changeStreamIncludingCurrent(sref),
+    Stream.filter(predicate),
+    Stream.take(1),
+    Stream.runCollect,
+    Effect.map(Chunk.unsafeHead),
+  ),
 )

package/src/effect/WebLock.ts

@@ -3,18 +3,36 @@ import { Deferred, Effect, Runtime } from 'effect'
 
 // See https://developer.mozilla.org/en-US/docs/Web/API/Web_Locks_API
 export const withLock =
-  (lockName: string, options?: Omit<LockOptions, 'signal'>) =>
-  <Ctx, E, A>(eff: Effect.Effect<A, E, Ctx>): Effect.Effect<A | void, E, Ctx> =>
+  <E2>({
+    lockName,
+    onTaken,
+    options,
+  }: {
+    lockName: string
+    onTaken?: Effect.Effect<void, E2>
+    options?: Omit<LockOptions, 'signal'>
+  }) =>
+  <Ctx, E, A>(eff: Effect.Effect<A, E, Ctx>): Effect.Effect<A | void, E | E2, Ctx> =>
     Effect.gen(function* ($) {
       const runtime = yield* $(Effect.runtime<Ctx>())
 
       const exit = yield* $(
-        Effect.tryPromise<Exit.Exit<A, E>, E>({
+        Effect.tryPromise<Exit.Exit<A, E>, E | E2>({
           try: (signal) => {
+            if (signal.aborted) return 'aborted' as never
+
             // NOTE The 'signal' and 'ifAvailable' options cannot be used together.
             const requestOptions = options?.ifAvailable === true ? options : { ...options, signal }
             return navigator.locks.request(lockName, requestOptions, async (lock) => {
-              if (lock === null) return
+              if (lock === null) {
+                if (onTaken) {
+                  const exit = await Runtime.runPromiseExit(runtime)(onTaken)
+                  if (exit._tag === 'Failure') {
+                    return exit
+                  }
+                }
+                return
+              }
 
               // TODO also propagate Effect interruption to the execution
               return Runtime.runPromiseExit(runtime)(eff)
@@ -33,25 +51,35 @@ export const withLock =
 
 export const waitForDeferredLock = (deferred: Deferred.Deferred<void>, lockName: string) =>
   Effect.async<void>((cb, signal) => {
-    navigator.locks.request(lockName, { signal, mode: 'exclusive', ifAvailable: false }, async (_lock) => {
-      // immediately continuing calling Effect since we have the lock
-      cb(Effect.void)
+    if (signal.aborted) return
 
-      // the code below is still running
+    navigator.locks
+      .request(lockName, { signal, mode: 'exclusive', ifAvailable: false }, (_lock) => {
+        // immediately continuing calling Effect since we have the lock
+        cb(Effect.void)
 
-      // holding lock until deferred is resolved
-      await Effect.runPromise(Deferred.await(deferred))
-    })
+        // the code below is still running
+
+        // holding lock until deferred is resolved
+        return Effect.runPromise(Deferred.await(deferred))
+      })
+      .catch((error) => {
+        if (error.code === 20 && error.message === 'signal is aborted without reason') {
+          // Given signal interruption is handled via Effect, we can ignore this case
+        } else {
+          throw error
+        }
+      })
   })
 
 export const tryGetDeferredLock = (deferred: Deferred.Deferred<void>, lockName: string) =>
   Effect.async<boolean>((cb) => {
-    navigator.locks.request(lockName, { mode: 'exclusive', ifAvailable: true }, async (lock) => {
+    navigator.locks.request(lockName, { mode: 'exclusive', ifAvailable: true }, (lock) => {
       cb(Effect.succeed(lock !== null))
 
       // the code below is still running
 
       // holding lock until deferred is resolved
-      await Effect.runPromise(Deferred.await(deferred))
+      return Effect.runPromise(Deferred.await(deferred))
     })
   })

package/src/effect/index.ts

@@ -36,6 +36,8 @@ export {
   HashSet,
   MutableHashSet,
   Option,
+  LogLevel,
+  Logger,
   Layer,
   STM,
   TRef,
@@ -55,6 +57,7 @@ export {
   TreeFormatter,
   AST as SchemaAST,
   Pretty as SchemaPretty,
+  Equivalence as SchemaEquivalence,
   Serializable,
   JSONSchema,
   ParseResult,
@@ -64,6 +67,7 @@ export * as OtelTracer from '@effect/opentelemetry/Tracer'
 
 export { Transferable, FileSystem, Worker, WorkerError, WorkerRunner, Terminal, HttpServer } from '@effect/platform'
 export { BrowserWorker, BrowserWorkerRunner } from '@effect/platform-browser'
+export * as PortPlatformRunner from './port-platform-runner.js'
 
 export * as Effect from './Effect.js'
 export * as Schedule from './Schedule.js'

package/src/effect/port-platform-runner.ts

@@ -0,0 +1,73 @@
+import { WorkerError } from '@effect/platform/WorkerError'
+import * as Runner from '@effect/platform/WorkerRunner'
+import { Deferred } from 'effect'
+import * as Cause from 'effect/Cause'
+import * as Effect from 'effect/Effect'
+import * as Layer from 'effect/Layer'
+import * as Queue from 'effect/Queue'
+import * as Schedule from 'effect/Schedule'
+
+const platformRunnerImpl = (port: MessagePort) =>
+  Runner.PlatformRunner.of({
+    [Runner.PlatformRunnerTypeId]: Runner.PlatformRunnerTypeId,
+    start: <I, O>(shutdown: Effect.Effect<void>) => {
+      return Effect.gen(function* () {
+        const queue = yield* Queue.unbounded<readonly [portId: number, message: I]>()
+
+        const latch = yield* Deferred.make<void>()
+
+        yield* Effect.async<never, WorkerError>((resume) => {
+          const onMessage = (msg: MessageEvent<Runner.BackingRunner.Message<I>>) => {
+            const message = msg.data
+            if (message[0] === 0) {
+              queue.unsafeOffer([0, message[1]])
+            } else {
+              Effect.runFork(shutdown)
+            }
+          }
+
+          const onError = (error: any) => {
+            resume(new WorkerError({ reason: 'decode', error }))
+          }
+
+          port.addEventListener('message', onMessage)
+          port.addEventListener('messageerror', onError)
+          port.addEventListener('error', onError)
+
+          Deferred.unsafeDone(latch, Effect.void)
+
+          return Effect.sync(() => {
+            port.removeEventListener('message', onMessage as any)
+            port.removeEventListener('error', onError as any)
+          })
+        }).pipe(
+          Effect.tapErrorCause((cause) => (Cause.isInterruptedOnly(cause) ? Effect.void : Effect.logDebug(cause))),
+          Effect.retry(Schedule.forever),
+          Effect.annotateLogs({
+            package: '@livestore/utils/effect',
+            module: 'PortPlatformRunner',
+          }),
+          Effect.interruptible,
+          Effect.forkScoped,
+        )
+
+        yield* Deferred.await(latch)
+
+        port.start()
+
+        const send = (_portId: number, message: O, transfers?: ReadonlyArray<unknown>) =>
+          Effect.try({
+            try: () => port.postMessage([1, message], transfers as any),
+            catch: (error) => new WorkerError({ reason: 'send', error }),
+          }).pipe(Effect.catchTag('WorkerError', Effect.orDie))
+
+        // ready
+        port.postMessage([0])
+
+        return { queue, send }
+      })
+    },
+  })
+
+/** @internal */
+export const layer = (port: MessagePort) => Layer.succeed(Runner.PlatformRunner, platformRunnerImpl(port))