effect 4.0.5 → 4.0.7

package/src/SchemaTransformation.ts

@@ -20,6 +20,7 @@ import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import { format, formatDate, formatJson } from "./Formatter.ts"
 import { dual } from "./Function.ts"
+import * as InternalContent from "./internal/schema/content.ts"
 import * as Option from "./Option.ts"
 import * as Pipeable from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
@@ -613,7 +614,10 @@ export function trim(): Transformation<string, string> {
  *
  * Decoding converts values such as `"my_field_name"` to `"myFieldName"`.
  * Encoding converts values such as `"myFieldName"` back to `"my_field_name"`.
- * The transformation is round-trippable for standard snake_case and camelCase.
+ * Lowercase snake_case values round-trip when single underscores separate the
+ * segments and every segment after the first starts with a letter. A segment
+ * that starts with a digit does not: `"foo_2_bar"` decodes to `"foo2Bar"`,
+ * which encodes to `"foo2_bar"`.
  *
  * **Example** (Converting snake case to camel case)
  *
@@ -1877,7 +1881,7 @@ export const stringFromHexString: Transformation<string, string> = new Transform
  * **When to use**
  *
  * Use when you need a schema transformation to store structured data in URL
- * query parameters or fragments, such as composing with `Schema.parseJson` to
+ * query parameters or fragments, such as composing with `Schema.fromJsonString` to
  * round-trip JSON through a URL.
  *
  * **Details**
@@ -1950,7 +1954,10 @@ export function fromJsonString(options?: {
 }): Transformation<unknown, string> {
   return new Transformation(
     SchemaGetter.parseJson(options ?? {}),
-    SchemaGetter.stringifyJson(options)
+    InternalContent.setContent(SchemaGetter.stringifyJson(options), {
+      mediaType: "application/json",
+      preserveSchema: options?.reviver === undefined && options?.replacer === undefined
+    })
   )
 }
 

package/src/Scope.ts

@@ -159,8 +159,13 @@ export declare namespace State {
     finalizers: Map<{}, (exit: Exit<any, any>) => Effect<void>> | undefined
   }
   /**
-   * Represents a closed scope state where finalizers have been executed
-   * and the scope is no longer accepting new resources.
+   * Represents a closed scope state where the scope is no longer accepting
+   * new resources.
+   *
+   * **Details**
+   *
+   * The scope enters this state when closing starts, so its finalizers may
+   * still be running.
    *
    * **Example** (Inspecting a closed scope state)
    *
@@ -557,6 +562,11 @@ export const forkUnsafe: (scope: Scope, finalizerStrategy?: "sequential" | "para
  * By default, finalizers run uninterruptibly, so interrupting the closing fiber
  * waits for them to finish; a finalizer can explicitly restore interruptibility.
  *
+ * **Gotchas**
+ *
+ * Closing a scope that is already closed returns immediately, even when the
+ * finalizers of an earlier close are still running.
+ *
  * **Example** (Running scope finalizers)
  *
  * ```ts import.meta.vitest

package/src/ScopedCache.ts

@@ -7,6 +7,8 @@
  * remaining entries when the cache is closed. Lookups for the same missing key
  * share one in-progress effect, and entries can expire, be refreshed, be
  * invalidated, or be evicted by capacity limits.
+ * Expiry cleanup is lazy: an expired entry is removed on access to that key or
+ * a `keys`/`values`/`entries` scan, not by a background timer.
  *
  * @stability stable
  * @since 4.0.0
@@ -39,14 +41,15 @@ const TypeId = "~effect/ScopedCache"
  * **When to use**
  *
  * Use to cache values that acquire scoped resources and must release those
- * resources when entries expire, are evicted, or are invalidated.
+ * resources when entries are removed or the owning scope closes.
  *
  * **Details**
  *
  * Concurrent requests for the same key share the same in-flight lookup.
  * Entries can expire based on the lookup exit, are evicted when capacity is
- * exceeded, and release their entry scopes when invalidated, evicted, expired,
- * or when the cache's owning scope closes.
+ * exceeded, and release their entry scopes when invalidated, evicted, or when
+ * the cache's owning scope closes. Expired entries are cleaned up lazily on
+ * access to that key or a `keys`/`values`/`entries` scan, never in the background.
  *
  * @see {@link make} for creating a scoped cache with a fixed time-to-live
  * @see {@link makeWith} for creating a scoped cache with dynamic time-to-live
@@ -127,8 +130,9 @@ export interface Entry<A, E> {
  * **Details**
  *
  * The cache must be constructed in a `Scope`. Each lookup runs in its own entry
- * scope, and that scope is closed when the entry expires, is invalidated, is
- * evicted by capacity, or when the cache's owning scope closes.
+ * scope, and that scope is closed when the entry is invalidated, is evicted by
+ * capacity, or when the cache's owning scope closes. Expired entries are cleaned
+ * up on access to that key or a `keys`/`values`/`entries` scan, not in the background.
  * `requireServicesAt` controls whether lookup services are captured at
  * construction time or required when lookup operations run.
  *
@@ -192,8 +196,9 @@ export const makeWith = <
  *
  * This is the constant-TTL variant of `makeWith`: values are acquired by the
  * lookup effect in per-entry scopes, capacity can evict older entries, and
- * entry scopes are closed when entries expire, are invalidated, are evicted, or
- * when the cache's owning scope closes.
+ * entry scopes are closed when entries are invalidated, are evicted, or when
+ * the cache's owning scope closes. Expiry cleanup is lazy: expired entries close
+ * on access to that key or a `keys`/`values`/`entries` scan, not in the background.
  *
  * @see {@link makeWith} for computing time-to-live from each lookup result and key
  *
@@ -330,55 +335,7 @@ export const get: {
           return awaitEntry(self, key, oentry.value, restore)
         }
         const scope = Scope.makeUnsafe()
-        const deferred = Deferred.makeUnsafe</**
-         * Gets the value for a key, running the cache lookup when no unexpired entry is
-         * present.
-         *
-         * **When to use**
-         *
-         * Use to retrieve a scoped cached value by key when a missing or expired entry
-         * should run the cache lookup and share the in-flight lookup with concurrent
-         * callers.
-         *
-         * **Details**
-         *
-         * Concurrent `get` calls for the same key share the same in-flight lookup.
-         * Successful and failed lookup exits are cached according to the configured
-         * TTL. If the cache is closed, the effect is interrupted.
-         *
-         * @see {@link getOption} for reading only when an unexpired entry is already cached
-         * @see {@link getSuccess} for inspecting an already-completed successful entry
-         * @see {@link refresh} for forcing a new lookup
-         *
-         * @stability stable
-         * @category combinators
-         * @since 4.0.0
-         */
-        A, /**
-         * Gets the value for a key, running the cache lookup when no unexpired entry is
-         * present.
-         *
-         * **When to use**
-         *
-         * Use to retrieve a scoped cached value by key when a missing or expired entry
-         * should run the cache lookup and share the in-flight lookup with concurrent
-         * callers.
-         *
-         * **Details**
-         *
-         * Concurrent `get` calls for the same key share the same in-flight lookup.
-         * Successful and failed lookup exits are cached according to the configured
-         * TTL. If the cache is closed, the effect is interrupted.
-         *
-         * @see {@link getOption} for reading only when an unexpired entry is already cached
-         * @see {@link getSuccess} for inspecting an already-completed successful entry
-         * @see {@link refresh} for forcing a new lookup
-         *
-         * @stability stable
-         * @category combinators
-         * @since 4.0.0
-         */
-        E>()
+        const deferred = Deferred.makeUnsafe<A, E>()
         const entry: Entry<A, E> = {
           expiresAt: undefined,
           deferred,
@@ -748,49 +705,7 @@ export const set: {
         const oentry = MutableHashMap.get(self.state.map, key)
         const state = self.state
         const exit = core.exitSucceed(value)
-        const deferred = Deferred.makeUnsafe</**
-         * Sets a successful value for a key without running the lookup function.
-         *
-         * **When to use**
-         *
-         * Use to seed or overwrite a scoped cache entry with an already available
-         * successful value.
-         *
-         * **Details**
-         *
-         * This replaces and closes any existing entry scope for the key, applies the
-         * cache's TTL using a successful exit for the value, and may evict older
-         * entries if the cache capacity is exceeded.
-         *
-         * @see {@link get} for reading or computing a cached value
-         * @see {@link refresh} for replacing an entry by running the lookup function
-         *
-         * @stability stable
-         * @category combinators
-         * @since 4.0.0
-         */
-        A, /**
-         * Sets a successful value for a key without running the lookup function.
-         *
-         * **When to use**
-         *
-         * Use to seed or overwrite a scoped cache entry with an already available
-         * successful value.
-         *
-         * **Details**
-         *
-         * This replaces and closes any existing entry scope for the key, applies the
-         * cache's TTL using a successful exit for the value, and may evict older
-         * entries if the cache capacity is exceeded.
-         *
-         * @see {@link get} for reading or computing a cached value
-         * @see {@link refresh} for replacing an entry by running the lookup function
-         *
-         * @stability stable
-         * @category combinators
-         * @since 4.0.0
-         */
-        E>()
+        const deferred = Deferred.makeUnsafe<A, E>()
         Deferred.doneUnsafe(deferred, exit)
         const ttl = self.timeToLive(exit, key)
         MutableHashMap.set(state.map, key, {
@@ -1149,47 +1064,7 @@ export const refresh: {
       if (!MutableHashMap.has(self.state.map, key)) return yield* restore(get(self, key))
       const fiber = Fiber.getCurrent()!
       const scope = Scope.makeUnsafe()
-      const deferred = Deferred.makeUnsafe</**
-       * Forces a refresh of the value associated with the specified key in the cache.
-       *
-       * **When to use**
-       *
-       * Use to recompute a scoped cache entry immediately, even when an unexpired
-       * value is already cached.
-       *
-       * **Details**
-       *
-       * It will always invoke the lookup function to construct a new value,
-       * overwriting any existing value for that key.
-       *
-       * @see {@link get} for reusing an unexpired entry before running the lookup
-       * @see {@link invalidate} for removing an entry without recomputing it
-       *
-       * @stability stable
-       * @category combinators
-       * @since 4.0.0
-       */
-      A, /**
-       * Forces a refresh of the value associated with the specified key in the cache.
-       *
-       * **When to use**
-       *
-       * Use to recompute a scoped cache entry immediately, even when an unexpired
-       * value is already cached.
-       *
-       * **Details**
-       *
-       * It will always invoke the lookup function to construct a new value,
-       * overwriting any existing value for that key.
-       *
-       * @see {@link get} for reusing an unexpired entry before running the lookup
-       * @see {@link invalidate} for removing an entry without recomputing it
-       *
-       * @stability stable
-       * @category combinators
-       * @since 4.0.0
-       */
-      E>()
+      const deferred = Deferred.makeUnsafe<A, E>()
       const exit = yield* effect.exit(effect.suspend(() => restore(Scope.provide(self.lookup(key), scope))))
       Deferred.doneUnsafe(deferred, exit)
       if (effect.exitHasInterrupts(exit)) {
@@ -1252,11 +1127,11 @@ const invalidateAllImpl = <Key, A, E>(
   // Detach the batch before finalizers can reenter the cache.
   const entries = Array.from(MutableHashMap.values(map))
   MutableHashMap.clear(map)
-  const fibers = Arr.empty<Fiber.Fiber<unknown, unknown>>()
+  const fibers = Arr.empty<Fiber.Fiber<void>>()
   for (const entry of entries) {
     fibers.push(effect.forkUnsafe(parent as any, Scope.close(entry.scope, effect.exitVoid), true, true))
   }
-  return effect.fiberAwaitAll(fibers)
+  return effect.flatMap(effect.fiberAwaitAll(fibers), Exit.asVoidAll)
 }
 
 /**