@livestore/utils 0.4.0 → 0.5.0-dev.1

package/src/effect/Effect.ts

@@ -1,22 +1,20 @@
-import * as OtelTracer from '@effect/opentelemetry/Tracer'
+import * as OtelTracer from '@effect/opentelemetry/OtelTracer'
 import {
   Cause,
+  Console,
   type Context,
   Deferred,
   Duration,
   Effect,
+  Function,
   Fiber,
   pipe,
+  Predicate,
   Scope,
   type Stream,
 } from 'effect'
-import type { UnknownException } from 'effect/Cause'
-import { log } from 'effect/Console'
-import { dual, type LazyArg } from 'effect/Function'
-import type { Predicate, Refinement } from 'effect/Predicate'
 
-import { isDevEnv, isPromise, objectToString } from '../mod.ts'
-import { UnknownError } from './Error.ts'
+import { isDevEnv, objectToString } from '../misc.ts'
 
 export * from 'effect/Effect'
 export { spanEvent } from './spanEvent.ts'
@@ -36,16 +34,14 @@ export { spanEvent } from './spanEvent.ts'
 //     console.error(message, ...rest)
 //   })
 
-/** Same as `Effect.scopeWith` but with a `CloseableScope` instead of a `Scope`. */
+/** Same as `Effect.scopeWith` but with a closeable `Scope`. */
 export const scopeWithCloseable = <R, E, A>(
-  fn: (scope: Scope.CloseableScope) => Effect.Effect<A, E, R | Scope.Scope>,
+  fn: (scope: Scope.Closeable) => Effect.Effect<A, E, R | Scope.Scope>,
 ): Effect.Effect<A, E, R | Scope.Scope> =>
   Effect.gen(function* () {
-    // const parentScope = yield* Scope.Scope
-    // const scope = yield* Scope.fork(parentScope, ExecutionStrategy.sequential)
     const scope = yield* Scope.make()
     yield* Effect.addFinalizer((exit) => Scope.close(scope, exit))
-    return yield* fn(scope).pipe(Scope.extend(scope))
+    return yield* fn(scope).pipe(Scope.provide(scope))
   })
 
 export type SyncOrPromiseOrEffect<TResult, TError = never, TContext = never> =
@@ -53,22 +49,43 @@ export type SyncOrPromiseOrEffect<TResult, TError = never, TContext = never> =
   | Promise<TResult>
   | Effect.Effect<TResult, TError, TContext>
 
-export const tryAll = <Res>(
-  fn: () => Res,
-): Res extends Effect.Effect<infer A, infer E>
-  ? Effect.Effect<A, E | UnknownException>
-  : Res extends Promise<infer A>
-    ? Effect.Effect<A, UnknownException>
-    : Effect.Effect<Res, UnknownException> =>
-  Effect.try(() => fn()).pipe(
-    Effect.andThen((fnRes) =>
-      Effect.isEffect(fnRes) === true
-        ? (fnRes as any as Effect.Effect<any>)
-        : isPromise(fnRes) === true
-          ? Effect.promise(() => fnRes)
-          : Effect.succeed(fnRes),
-    ),
-  ) as any
+/**
+ * Creates an Effect from an operation that may return a value, a Promise-like value, or another Effect.
+ *
+ * @remarks
+ * Synchronous values succeed directly, and Promise-like values are awaited. Synchronous throws and Promise rejections
+ * are mapped to `Cause.UnknownError`. When the operation returns an Effect, that Effect is executed rather than
+ * produced as a successful value; its failures and service requirements are preserved.
+ *
+ * @param operation - A callback that may return a synchronous value, a Promise-like value, or an Effect
+ * @returns An Effect representing the normalized outcome of the operation
+ */
+export function trySyncOrPromiseOrEffect<Return>(
+  operation: () => Return,
+): Effect.Effect<
+  Return extends Effect.Effect<infer A, infer _E, infer _R> ? A : Return extends PromiseLike<infer A> ? A : Return,
+  Cause.UnknownError | (Return extends Effect.Effect<infer _A, infer E, infer _R> ? E : never),
+  Return extends Effect.Effect<infer _A, infer _E, infer R> ? R : never
+>
+export function trySyncOrPromiseOrEffect(operation: () => unknown): Effect.Effect<unknown, unknown, unknown> {
+  return Effect.try({
+    try: () => {
+      const result = operation()
+
+      if (Effect.isEffect(result) === true) {
+        // @effect-diagnostics-next-line anyUnknownInErrorContext:off -- dynamic implementation boundary; the public overload preserves exact Effect error and requirement channels
+        return result
+      }
+
+      if (Predicate.isPromiseLike(result) === true) {
+        return Effect.tryPromise(() => result)
+      }
+
+      return Effect.succeed(result)
+    },
+    catch: (cause) => new Cause.UnknownError(cause),
+  }).pipe(Effect.flatten)
+}
 
 export const acquireReleaseLog = (label: string) =>
   Effect.acquireRelease(Effect.log(`${label} acquire`), (_, ex) => Effect.log(`${label} release`, ex))
@@ -85,16 +102,11 @@ export const logBefore =
 
 /** Logs both on errors and defects */
 export const tapCauseLogPretty = <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-  Effect.tapErrorCause(eff, (cause) =>
+  Effect.tapCause(eff, (cause) =>
     Effect.gen(function* () {
-      if (Cause.isInterruptedOnly(cause) === true) {
-        // console.log('interrupted', Cause.pretty(err), err)
-        return
-      }
+      if (Cause.hasInterruptsOnly(cause) === true) return
 
-      const span = yield* OtelTracer.currentOtelSpan.pipe(
-        Effect.catchTag('NoSuchElementException', (_) => Effect.succeed(undefined)),
-      )
+      const span = yield* OtelTracer.currentOtelSpan.pipe(Effect.catchTag('NoSuchElementError', (_) => Effect.void))
 
       const firstErrLine = cause.toString().split('\n')[0]
       yield* Effect.logError(firstErrLine, cause).pipe((_) =>
@@ -117,11 +129,11 @@ export const tapCauseLogPretty = <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.
 export const dieDebugger = (msg: string, ...args: ReadonlyArray<unknown>): Effect.Effect<never> =>
   Effect.suspend(() => {
     if (isDevEnv() === true) {
-      // oxlint-disable-next-line eslint(no-debugger) -- intentional breakpoint during development
+      // oxlint-disable-next-line no-debugger -- intentional breakpoint during development
       debugger
       void args // Keeps the variable in scope so it's inspectable when the debugger pauses
     }
-    return Effect.dieMessage(msg)
+    return Effect.die(new Error(msg))
   })
 
 /**
@@ -136,27 +148,27 @@ export const orDieDebugger = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Eff
   Effect.matchEffect(self, {
     onFailure: (error) =>
       // Keep the debugger hook so that `debugger` runs only when the wrapped effect actually fails, not while building the wrapper.
-      Effect.dieSync(() => {
+      Effect.suspend(() => {
         if (isDevEnv() === true) {
-          // oxlint-disable-next-line eslint(no-debugger) -- intentional breakpoint for impossible states during development
+          // oxlint-disable-next-line no-debugger -- intentional breakpoint for impossible states during development
           debugger
         }
-        return error
+        return Effect.die(error)
       }),
     onSuccess: Effect.succeed,
   })
 
 export const ignoreIf: {
   <E, EB extends E>(
-    refinement: Refinement<NoInfer<E>, EB>,
+    refinement: Predicate.Refinement<NoInfer<E>, EB>,
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, Exclude<E, EB>, R>
-  <E>(predicate: Predicate<NoInfer<E>>): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, E, R>
+  <E>(predicate: Predicate.Predicate<NoInfer<E>>): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, E, R>
   <A, E, R, EB extends E>(
     self: Effect.Effect<A, E, R>,
-    refinement: Refinement<E, EB>,
+    refinement: Predicate.Refinement<E, EB>,
   ): Effect.Effect<void, Exclude<E, EB>, R>
-  <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate<E>): Effect.Effect<void, E, R>
-} = dual(2, <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate<E>) =>
+  <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate.Predicate<E>): Effect.Effect<void, E, R>
+} = Function.dual(2, <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate.Predicate<E>) =>
   self.pipe(Effect.catchIf(predicate, () => Effect.void)),
 )
 
@@ -167,9 +179,9 @@ export const eventListener = <TEvent = unknown>(
   options?: { once?: boolean },
 ) =>
   Effect.gen(function* () {
-    const runtime = yield* Effect.runtime()
+    const services = yield* Effect.context()
 
-    const handlerFn = (event: TEvent) => handler(event).pipe(Effect.provide(runtime), Effect.runFork)
+    const handlerFn = (event: TEvent) => handler(event).pipe(Effect.runForkWith(services))
 
     target.addEventListener(type, handlerFn, { once: options?.once ?? false })
 
@@ -177,10 +189,10 @@ export const eventListener = <TEvent = unknown>(
   })
 
 export const logWarnIfTakesLongerThan =
-  ({ label, duration }: { label: string; duration: Duration.DurationInput }) =>
+  ({ label, duration }: { label: string; duration: Duration.Input }) =>
   <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
     Effect.gen(function* () {
-      const runtime = yield* Effect.runtime()
+      const services = yield* Effect.context()
 
       let tookLongerThanTimer = false
 
@@ -190,8 +202,7 @@ export const logWarnIfTakesLongerThan =
           // TODO include span info
           return Effect.logWarning(`${label}: Took longer than ${objectToString(duration)}ms`)
         }),
-        Effect.provide(runtime),
-        Effect.runFork,
+        Effect.runForkWith(services),
       )
 
       const start = Date.now()
@@ -228,7 +239,7 @@ export const logDuration =
       const start = Date.now()
       const res = yield* eff
       const end = Date.now()
-      yield* Effect.log(`${label}: ${Duration.format(end - start)}`)
+      yield* Effect.log(`${label}: ${Duration.format(Duration.millis(end - start))}`)
       return res
     })
 
@@ -240,7 +251,7 @@ export const tapSync =
 export const debugLogEnv = (msg?: string): Effect.Effect<Context.Context<never>> =>
   pipe(
     Effect.context<never>(),
-    Effect.tap((env) => log(msg ?? 'debugLogEnv', env)),
+    Effect.tap((env) => Console.log(msg ?? 'debugLogEnv', env)),
   )
 
 /**
@@ -250,25 +261,26 @@ export const debugLogEnv = (msg?: string): Effect.Effect<Context.Context<never>>
  *
  * This function allows you to enforce a time limit on the execution of an
  * effect. If the effect does not complete within the given duration, it dies
- * with a {@link Cause.TimeoutException} as an unchecked defect. Unlike
- * {@link Effect.timeout}, which adds `TimeoutException` to the error channel,
+ * with a {@link Cause.TimeoutError} as an unchecked defect. Unlike
+ * {@link Effect.timeout}, which adds `TimeoutError` to the error channel,
  * this function keeps the error channel unchanged by treating the timeout as
  * a defect.
  *
  * The returned effect will either:
  * - Succeed with the original effect's result if it completes within the
  *   specified duration.
- * - Die with a {@link Cause.TimeoutException} defect if the time limit is exceeded.
+ * - Die with a {@link Cause.TimeoutError} defect if the time limit is exceeded.
  *
  * @see {@link timeoutOrDieMessage} for a version with a custom message.
- * @see {@link Effect.timeout} for a version that raises a `TimeoutException` as a typed error.
- * @see {@link Effect.timeoutFailCause} for a version that raises a custom defect.
+ * @see {@link Effect.timeout} for a version that raises a `TimeoutError` as a typed error.
+ * @see {@link Effect.timeoutOrElse} for a version with a custom timeout branch.
  */
-export const timeoutOrDie = (duration: Duration.DurationInput) =>
+export const timeoutOrDie =
+  (duration: Duration.Input) =>
   <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-    Effect.timeoutFailCause(self, {
+    Effect.timeoutOrElse(self, {
       duration,
-      onTimeout: () => Cause.die(new Cause.TimeoutException())
+      orElse: () => Effect.die(new Cause.TimeoutError()),
     })
 
 /**
@@ -278,25 +290,26 @@ export const timeoutOrDie = (duration: Duration.DurationInput) =>
  * @remarks
  *
  * This function behaves like {@link timeoutOrDie}, but allows you to provide
- * a custom message for the {@link Cause.TimeoutException} defect. This is useful
+ * a custom message for the {@link Cause.TimeoutError} defect. This is useful
  * for adding context about which operation timed out, making it easier to
  * diagnose issues in logs or error reports.
  *
  * The returned effect will either:
  * - Succeed with the original effect's result if it completes within the
  *   specified duration.
- * - Die with a {@link Cause.TimeoutException} defect containing the provided
+ * - Die with a {@link Cause.TimeoutError} defect containing the provided
  *   message if the time limit is exceeded.
  *
  * @see {@link timeoutOrDie} for a version without a custom message.
- * @see {@link Effect.timeout} for a version that raises a `TimeoutException` as a typed error.
- * @see {@link Effect.timeoutFailCause} for a version that raises a custom defect.
+ * @see {@link Effect.timeout} for a version that raises a `TimeoutError` as a typed error.
+ * @see {@link Effect.timeoutOrElse} for a version with a custom timeout branch.
  */
-export const timeoutOrDieMessage = (duration: Duration.DurationInput, message: string) =>
+export const timeoutOrDieMessage =
+  (duration: Duration.Input, message: string) =>
   <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-    Effect.timeoutFailCause(self, {
+    Effect.timeoutOrElse(self, {
       duration,
-      onTimeout: () => Cause.die(new Cause.TimeoutException(message))
+      orElse: () => Effect.die(new Cause.TimeoutError(message)),
     })
 
 export const toForkedDeferred = <R, E, A>(
@@ -328,16 +341,16 @@ export const withPerformanceMeasure =
     )
 
 const getSpanTrace = () => {
-  const fiberOption = Fiber.getCurrentFiber()
-  if (fiberOption._tag === 'None' || fiberOption.value.currentSpan === undefined) {
+  const fiber = Fiber.getCurrent()
+  if (fiber === undefined || fiber.cache.span === undefined) {
     return 'No current fiber'
   }
 
   return ''
   // const msg = Effect.runSync(
   //   Effect.fail({ message: '' }).pipe(
-  //     Effect.withParentSpan(fiberOption.value.currentSpan),
-  //     Effect.catchAllCause((cause) => Effect.succeed(cause.toString())),
+  //     Effect.withParentSpan(fiber.currentSpan),
+  //     Effect.catchCause((cause) => Effect.succeed(cause.toString())),
   //   ),
   // )
 

package/src/effect/Logger.ts

@@ -1,49 +1 @@
-import { Cause, HashMap, Logger, LogLevel } from 'effect'
-
 export * from 'effect/Logger'
-
-const defaultDateFormat = (date: Date): string =>
-  `${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}:${date
-    .getSeconds()
-    .toString()
-    .padStart(2, '0')}.${date.getMilliseconds().toString().padStart(3, '0')}`
-
-export const prettyWithThread = (threadName: string, options: { mode?: 'tty' | 'browser' } = {}) =>
-  Logger.replace(
-    Logger.defaultLogger,
-    Logger.prettyLogger({
-      formatDate: (date) => `${defaultDateFormat(date)} ${threadName}`,
-      mode: options.mode,
-    }),
-  )
-
-export const consoleLogger = (threadName: string) =>
-  Logger.make(({ message, annotations, date, logLevel, cause }) => {
-    const isCloudflareWorker = typeof navigator !== 'undefined' && navigator.userAgent === 'Cloudflare-Workers'
-    const consoleFn =
-      logLevel === LogLevel.Debug
-        ? // Cloudflare Workers doesn't support console.debug 🤷
-          isCloudflareWorker === true
-          ? console.log
-          : console.debug
-        : logLevel === LogLevel.Info
-          ? console.info
-          : logLevel === LogLevel.Warning
-            ? console.warn
-            : console.error
-
-    const annotationsObj = Object.fromEntries(HashMap.entries(annotations))
-
-    const messages = Array.isArray(message) === true ? message : [message]
-    if (Cause.isEmpty(cause) === false) {
-      messages.push(Cause.pretty(cause, { renderErrorCause: true }))
-    }
-
-    if (Object.keys(annotationsObj).length > 0) {
-      messages.push(annotationsObj)
-    }
-
-    consoleFn(`[${defaultDateFormat(date)} ${threadName}]`, ...messages)
-  })
-
-export const consoleWithThread = (threadName: string) => Logger.replace(Logger.defaultLogger, consoleLogger(threadName))

package/src/effect/OtelTracer.ts

@@ -1,11 +1,10 @@
-import { makeExternalSpan } from '@effect/opentelemetry/Tracer'
+import { makeExternalSpan } from '@effect/opentelemetry/OtelTracer'
 import type { Link as OtelSpanLink } from '@opentelemetry/api'
 import type { SpanLink as EffectSpanLink } from 'effect/Tracer'
 
-export * from '@effect/opentelemetry/Tracer'
+export * from '@effect/opentelemetry/OtelTracer'
 
 export const makeSpanLink = (otelSpanLink: OtelSpanLink): EffectSpanLink => ({
-  _tag: 'SpanLink',
   span: makeExternalSpan(otelSpanLink.context),
   attributes: otelSpanLink.attributes ?? {},
 })