effect 4.0.0-beta.24 → 4.0.0-beta.26

package/src/unstable/httpapi/HttpApiEndpoint.ts

@@ -15,7 +15,7 @@ import * as HttpRouter from "../http/HttpRouter.ts"
 import type { HttpServerRequest } from "../http/HttpServerRequest.ts"
 import type { HttpServerResponse } from "../http/HttpServerResponse.ts"
 import type * as Multipart from "../http/Multipart.ts"
-import { HttpApiSchemaError } from "./HttpApiError.ts"
+import { BadRequestFromSchemaError, type BadRequestNoContent } from "./HttpApiError.ts"
 import type * as HttpApiGroup from "./HttpApiGroup.ts"
 import type * as HttpApiMiddleware from "./HttpApiMiddleware.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
@@ -53,7 +53,7 @@ export interface HttpApiEndpoint<
   out Payload extends Schema.Top = never,
   out Headers extends Schema.Top = never,
   out Success extends Schema.Top = typeof HttpApiSchema.NoContent,
-  out Error extends Schema.Top = typeof HttpApiSchemaError,
+  out Error extends Schema.Top = typeof BadRequestNoContent,
   in out Middleware = never,
   out MiddlewareR = never
 > extends Pipeable {
@@ -179,7 +179,7 @@ export function getErrorSchemas(endpoint: AnyWithProps): [Schema.Top, ...Array<S
       schemas.add(key.error)
     }
   }
-  return Arr.append(Array.from(schemas), HttpApiSchemaError)
+  return Arr.append(Array.from(schemas), BadRequestFromSchemaError)
 }
 
 /**
@@ -936,7 +936,7 @@ export const make = <Method extends HttpMethod>(method: Method) =>
     : Payload,
   Headers extends Schema.Struct.Fields ? Schema.Struct<Headers> : Headers,
   Success extends ReadonlyArray<Schema.Top> ? Success[number] : Success,
-  (Error extends ReadonlyArray<Schema.Top> ? Error[number] : Error) | typeof HttpApiSchemaError
+  (Error extends ReadonlyArray<Schema.Top> ? Error[number] : Error) | typeof BadRequestNoContent
 > => {
   return makeProto({
     name,

package/src/unstable/httpapi/HttpApiError.ts

@@ -2,30 +2,11 @@
  * @since 4.0.0
  */
 import * as ErrorReporter from "../../ErrorReporter.ts"
+import { identity } from "../../Function.ts"
 import * as Schema from "../../Schema.ts"
+import * as Transformation from "../../SchemaTransformation.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
 
-/**
- * @category errors
- * @since 4.0.0
- */
-export class HttpApiSchemaError extends Schema.ErrorClass<HttpApiSchemaError>("effect/HttpApiSchemaError")({
-  _tag: Schema.tag("HttpApiSchemaError"),
-  message: Schema.String
-}, {
-  httpApiStatus: 400,
-  description: "The request or response did not match the expected schema"
-}) {
-  /**
-   * @since 4.0.0
-   */
-  static fromSchemaError(error: Schema.SchemaError): HttpApiSchemaError {
-    return new HttpApiSchemaError({ message: error.message })
-  }
-
-  override readonly [ErrorReporter.ignore] = true
-}
-
 /**
  * @category Built-in errors
  * @since 4.0.0
@@ -37,6 +18,7 @@ export class BadRequest extends Schema.ErrorClass<BadRequest>("effect/HttpApiErr
   httpApiStatus: 400
 }) {
   override readonly [ErrorReporter.ignore] = true
+  static readonly singleton = new BadRequest()
 }
 
 /**
@@ -47,6 +29,26 @@ export const BadRequestNoContent = BadRequest.pipe(HttpApiSchema.asNoContent({
   decode: () => new BadRequest({})
 }))
 
+/**
+ * @category Built-in errors
+ * @since 4.0.0
+ */
+export const BadRequestFromSchemaError = BadRequest.pipe(
+  Schema.decodeTo(
+    Schema.Union([Schema.declare(Schema.isSchemaError), BadRequest]),
+    Transformation.transform({
+      encode: (_) => BadRequest.singleton,
+      decode: identity
+    })
+  ),
+  HttpApiSchema.asNoContent({
+    decode: () => new BadRequest({})
+  })
+).annotate({
+  httpApiStatus: 400,
+  description: "BadRequest"
+})
+
 /**
  * @category Built-in errors
  * @since 4.0.0

package/src/unstable/reactivity/Atom.ts

@@ -1750,6 +1750,138 @@ export const withRefresh: {
   }
 )
 
+/**
+ * Adds stale-while-revalidate refresh behavior to an async result atom.
+ *
+ * Automatic revalidation during reads is skipped while the current value is
+ * fresh within `staleTime`. Manual `refresh` calls remain forceful and always
+ * forward to the wrapped atom.
+ *
+ * Use `revalidateOnMount` to control whether stale data should trigger a
+ * background refresh on first mount. Use `revalidateOnFocus` to control
+ * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
+ *
+ * @since 4.0.0
+ * @category combinators
+ */
+export const swr: {
+  /**
+   * Adds stale-while-revalidate refresh behavior to an async result atom.
+   *
+   * Automatic revalidation during reads is skipped while the current value is
+   * fresh within `staleTime`. Manual `refresh` calls remain forceful and always
+   * forward to the wrapped atom.
+   *
+   * Use `revalidateOnMount` to control whether stale data should trigger a
+   * background refresh on first mount. Use `revalidateOnFocus` to control
+   * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    options: {
+      readonly staleTime: Duration.Input
+      readonly revalidateOnMount?: boolean | undefined
+      readonly revalidateOnFocus?: boolean | "always" | undefined
+      readonly focusSignal?: Atom<any> | undefined
+    }
+  ): <R extends Atom<AsyncResult.AsyncResult<any, any>>>(self: R) => WithoutSerializable<R>
+  /**
+   * Adds stale-while-revalidate refresh behavior to an async result atom.
+   *
+   * Automatic revalidation during reads is skipped while the current value is
+   * fresh within `staleTime`. Manual `refresh` calls remain forceful and always
+   * forward to the wrapped atom.
+   *
+   * Use `revalidateOnMount` to control whether stale data should trigger a
+   * background refresh on first mount. Use `revalidateOnFocus` to control
+   * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  <R extends Atom<AsyncResult.AsyncResult<any, any>>>(
+    self: R,
+    options: {
+      readonly staleTime: Duration.Input
+      readonly revalidateOnMount?: boolean | undefined
+      readonly revalidateOnFocus?: boolean | "always" | undefined
+      readonly focusSignal?: Atom<any> | undefined
+    }
+  ): WithoutSerializable<R>
+} = dual(
+  2,
+  <A, E>(
+    self: Atom<AsyncResult.AsyncResult<A, E>>,
+    options: {
+      readonly staleTime: Duration.Input
+      readonly revalidateOnMount?: boolean | undefined
+      readonly revalidateOnFocus?: boolean | "always" | undefined
+      readonly focusSignal?: Atom<any> | undefined
+    }
+  ): Atom<AsyncResult.AsyncResult<A, E>> => {
+    const staleTime = Duration.toMillis(Duration.fromInputUnsafe(options.staleTime))
+    const refresh = self.refresh ?? function(f: <A>(atom: Atom<A>) => void) {
+      f(self)
+    }
+    function read(get: Context) {
+      const current = get.once(self)
+      get.subscribe(self, (value) => {
+        get.setSelf(value)
+      })
+      if (options.revalidateOnFocus && options.focusSignal) {
+        get.once(options.focusSignal)
+        get.subscribe(
+          options.focusSignal,
+          options.revalidateOnFocus === "always" ? () => get.refresh(self) : () => {
+            const current = get.once(self)
+            if (shouldRevalidateSWR(current, staleTime)) {
+              get.refresh(self)
+            }
+          }
+        )
+      }
+      const firstRead = Option.isNone(get.self<AsyncResult.AsyncResult<A, E>>())
+      if (firstRead && options.revalidateOnMount === false) {
+        return current
+      }
+      if (shouldRevalidateSWR(current, staleTime)) {
+        get.refresh(self)
+      }
+      return current
+    }
+    return isWritable(self)
+      ? writable(read, (ctx, value) => {
+        ctx.set(self, value)
+      }, refresh)
+      : readable(read, refresh)
+  }
+) as any
+
+const swrTimestamp = <A, E>(result: AsyncResult.AsyncResult<A, E>): Option.Option<number> => {
+  if (result._tag === "Success") {
+    return Option.some(result.timestamp)
+  }
+  if (result._tag === "Failure") {
+    return Option.map(result.previousSuccess, (success) => success.timestamp)
+  }
+  return Option.none()
+}
+
+const isFreshWithin = (timestamp: number, staleTime: number, now: number): boolean => now - timestamp < staleTime
+
+const shouldRevalidateSWR = <A, E>(result: AsyncResult.AsyncResult<A, E>, staleTime: number): boolean => {
+  if (result.waiting) {
+    return false
+  }
+  const timestamp = Option.getOrUndefined(swrTimestamp(result))
+  if (timestamp === undefined) {
+    return result._tag !== "Initial"
+  }
+  return !isFreshWithin(timestamp, staleTime, Date.now())
+}
+
 /**
  * @since 4.0.0
  * @category Optimistic

package/src/unstable/reactivity/AtomHttpApi.ts

@@ -67,7 +67,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
         }
       >,
       WithResponse extends true ? [_Success["Type"], HttpClientResponse] : _Success["Type"],
-      _Error | HttpClientError.HttpClientError | SchemaError
+      _Error["Type"] | HttpClientError.HttpClientError | SchemaError
     >
     : never
 
@@ -124,7 +124,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
   ] ? Atom.Atom<
       AsyncResult.AsyncResult<
         WithResponse extends true ? [_Success["Type"], HttpClientResponse] : _Success["Type"],
-        _Error | HttpClientError.HttpClientError | SchemaError
+        _Error["Type"] | HttpClientError.HttpClientError | SchemaError
       >
     >
     : never

package/src/unstable/rpc/RpcServer.ts

@@ -739,6 +739,7 @@ export const layerHttp = <Rpcs extends Rpc.Any>(options: {
   readonly spanPrefix?: string | undefined
   readonly spanAttributes?: Record<string, unknown> | undefined
   readonly concurrency?: number | "unbounded" | undefined
+  readonly disableFatalDefects?: boolean | undefined
 }): Layer.Layer<
   never,
   never,
@@ -1080,6 +1081,7 @@ export const toHttpEffect: <Rpcs extends Rpc.Any>(
     readonly disableTracing?: boolean | undefined
     readonly spanPrefix?: string | undefined
     readonly spanAttributes?: Record<string, unknown> | undefined
+    readonly disableFatalDefects?: boolean | undefined
   } | undefined
 ) => Effect.Effect<
   Effect.Effect<HttpServerResponse.HttpServerResponse, never, Scope.Scope | HttpServerRequest.HttpServerRequest>,
@@ -1095,6 +1097,7 @@ export const toHttpEffect: <Rpcs extends Rpc.Any>(
     readonly disableTracing?: boolean | undefined
     readonly spanPrefix?: string | undefined
     readonly spanAttributes?: Record<string, unknown> | undefined
+    readonly disableFatalDefects?: boolean | undefined
   }
 ) {
   const { httpEffect, protocol } = yield* makeProtocolWithHttpEffect
@@ -1116,6 +1119,7 @@ export const toHttpEffectWebsocket: <Rpcs extends Rpc.Any>(
     readonly disableTracing?: boolean | undefined
     readonly spanPrefix?: string | undefined
     readonly spanAttributes?: Record<string, unknown> | undefined
+    readonly disableFatalDefects?: boolean | undefined
   } | undefined
 ) => Effect.Effect<
   Effect.Effect<HttpServerResponse.HttpServerResponse, never, Scope.Scope | HttpServerRequest.HttpServerRequest>,
@@ -1131,6 +1135,7 @@ export const toHttpEffectWebsocket: <Rpcs extends Rpc.Any>(
     readonly disableTracing?: boolean | undefined
     readonly spanPrefix?: string | undefined
     readonly spanAttributes?: Record<string, unknown> | undefined
+    readonly disableFatalDefects?: boolean | undefined
   }
 ) {
   const { httpEffect, protocol } = yield* makeProtocolWithHttpEffectWebsocket

package/src/unstable/sql/SqlResolver.ts

@@ -104,14 +104,14 @@ export const ordered = <Req extends Schema.Top, Res extends Schema.Top, _, E, R>
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       const results = yield* options.execute(inputs as any).pipe(
         Effect.provideServices(entries[0].services)
       )
       if (results.length !== inputs.length) {
-        return yield* Effect.fail(new ResultLengthMismatch({ expected: inputs.length, actual: results.length }))
+        return yield* new ResultLengthMismatch({ expected: inputs.length, actual: results.length })
       }
       const decodedResults = yield* decodeArray(results).pipe(
         Effect.provideServices(entries[0].services)
@@ -160,7 +160,7 @@ export const grouped = <Req extends Schema.Top, Res extends Schema.Top, K, Row,
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       const resultMap = MutableHashMap.empty<K, Arr.NonEmptyArray<Res["Type"]>>()
@@ -226,7 +226,11 @@ export const findById = <Id extends Schema.Top, Res extends Schema.Top, Row, E,
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key(entry) {
+      const conn = entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key)
+      if (!conn) return undefined
+      return Equal.byReferenceUnsafe(conn)
+    },
     resolver: Effect.fnUntraced(function*(entries) {
       const [inputs, idMap] = yield* partitionRequestsById(entries, options.Id)
       const results = yield* options.execute(inputs as any).pipe(
@@ -279,7 +283,7 @@ const void_ = <Req extends Schema.Top, _, E, R>(
     >,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       yield* options.execute(inputs as any).pipe(
@@ -354,3 +358,9 @@ const partitionRequestsById = function*<In, A, E, R, InE>(
 
   return [inputs, byIdMap] as const
 }
+
+function transactionKey<A>(entry: Request.Entry<A>): SqlClient.TransactionConnection["Service"] | undefined {
+  const conn = entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key)
+  if (!conn) return undefined
+  return Equal.byReferenceUnsafe(conn)
+}

package/src/unstable/sql/SqlSchema.ts

@@ -23,7 +23,7 @@ export const findAll = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   const encodeRequest = Schema.encodeEffect(options.Request)
   const decode = Schema.decodeUnknownEffect(Schema.mutable(Schema.Array(options.Result)))
   return (
-    request: Req["Encoded"]
+    request: Req["Type"]
   ): Effect.Effect<
     Array<Res["Type"]>,
     E | Schema.SchemaError,
@@ -46,7 +46,7 @@ export const findNonEmpty = <Req extends Schema.Top, Res extends Schema.Top, E,
 ) => {
   const find = findAll(options)
   return (
-    request: Req["Encoded"]
+    request: Req["Type"]
   ): Effect.Effect<
     Arr.NonEmptyArray<Res["Type"]>,
     E | Schema.SchemaError | Cause.NoSuchElementError,