effect 4.0.0-beta.25 → 4.0.0-beta.27

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/schema/Model.ts

@@ -301,6 +301,37 @@ export const FieldOption: <Field extends VariantSchema.Field<any> | Schema.Top>(
     jsonUpdate: optionalOption
   }) as any
 
+/**
+ * @since 4.0.0
+ * @category booleans
+ */
+export interface BooleanSqlite extends
+  VariantSchema.Field<{
+    readonly select: Schema.BooleanFromBit
+    readonly insert: Schema.BooleanFromBit
+    readonly update: Schema.BooleanFromBit
+    readonly json: Schema.Boolean
+    readonly jsonCreate: Schema.Boolean
+    readonly jsonUpdate: Schema.Boolean
+  }>
+{}
+
+/**
+ * A schema for sqlite booleans that are represented as `0 | 1` in database
+ * variants and `boolean` in JSON variants.
+ *
+ * @since 4.0.0
+ * @category booleans
+ */
+export const BooleanSqlite: BooleanSqlite = Field({
+  select: Schema.BooleanFromBit,
+  insert: Schema.BooleanFromBit,
+  update: Schema.BooleanFromBit,
+  json: Schema.Boolean,
+  jsonCreate: Schema.Boolean,
+  jsonUpdate: Schema.Boolean
+})
+
 /**
  * @since 4.0.0
  * @category date & time

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,