effect-app 4.0.0-beta.3 → 4.0.0-beta.300

package/src/client/clientFor.ts

@@ -2,12 +2,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import * as Record from "effect/Record"
-import type * as Request from "effect/Request"
+import type * as Stream from "effect/Stream"
 import type { Path } from "path-parser"
 import qs from "query-string"
-import type * as Effect from "../Effect.js"
-import type * as S from "../Schema.js"
-import { type Req } from "./apiClientFactory.js"
+import type * as Effect from "../Effect.ts"
+import type * as S from "../Schema.ts"
+import { type Req } from "./apiClientFactory.ts"
 
 export function makePathWithQuery(
   path: Path,
@@ -48,9 +48,14 @@ export function makePathWithBody(
   return path.build(pars, { ignoreSearch: true, ignoreConstraints: true })
 }
 
-export type Requests<ModuleName extends string = string> = { meta: { moduleName: ModuleName } } & RequestsAny
+export type Requests = RequestsAny
 export type RequestsAny = Record<string, any>
 
+export type ExtractModuleName<M extends RequestsAny> =
+  { [K in keyof M]: M[K] extends { moduleName: infer N extends string } ? N : never }[keyof M] extends
+    infer R extends string ? R
+    : string
+
 export type Client<M extends RequestsAny, ModuleName extends string> = RequestHandlers<
   never,
   never,
@@ -58,56 +63,124 @@ export type Client<M extends RequestsAny, ModuleName extends string> = RequestHa
   ModuleName
 >
 
-export type ExtractResponse<T> = T extends S.Codec<any> ? S.Schema.Type<T>
+export type ExtractResponse<T> = T extends S.Codec<any> ? T["Type"]
   : T extends unknown ? void
   : never
 
-export type ExtractEResponse<T> = T extends S.Codec<any> ? S.Codec.Encoded<T>
+export type ExtractEResponse<T> = T extends S.Codec<any> ? T["Encoded"]
   : T extends unknown ? void
   : never
 
-type IsEmpty<T> = keyof T extends never ? true
-  : false
-
-// v4: Request.RequestTypeId, S.symbolSerializable, S.symbolWithResult removed — use keyof Request to filter internal props
-type Cruft = "_tag" | keyof Request.Request<any, any, any>
-
 export interface ClientForOptions {
   readonly skipQueryKey?: readonly string[]
+  /**
+   * Middleware tag to attach to every rpc on the client. Schema-only — the
+   * client never invokes the middleware (no Live impl required), but its
+   * declared `error` schema joins the rpc failure union via
+   * `Rpc.exitSchema`'s `rpc.middlewares[*].error` walk. Required when
+   * middleware can throw errors that aren't part of the resource's declared
+   * error union (e.g. auth middleware throwing `NotLoggedInError`); without
+   * it the client decode would fail with a `SchemaError` for stream rpcs.
+   */
 }
 
-export interface RequestHandler<A, E, R, Request extends Req, Id extends string> {
-  handler: Effect.Effect<A, E, R>
+// $Project/$Configuration.Index
+// -> "$Project", "$Configuration", "Index"
+export const makeQueryKey = ({ id, options }: { id: string; options?: ClientForOptions }) =>
+  id
+    .split("/")
+    .filter((segment: string) => !options || !options.skipQueryKey?.includes(segment))
+    .map((segment: string) => "$" + segment)
+    .join(".")
+    .split(".")
+
+export interface RequestHandlerWithInput<I, A, E, R, Request extends Req, Id extends string> {
+  handler: (i: I) => Effect.Effect<A, E, R>
   id: Id
   options?: ClientForOptions
   Request: Request
+  queryKeyProjectionHash?: string
+  disableQueryInvalidation?: boolean
 }
 
-export interface RequestHandlerWithInput<I, A, E, R, Request extends Req, Id extends string> {
-  handler: (i: I) => Effect.Effect<A, E, R>
+/** Type alias: a no-input handler is simply `RequestHandlerWithInput<void, …>`. */
+export type RequestHandler<A, E, R, Request extends Req, Id extends string> = RequestHandlerWithInput<
+  void,
+  A,
+  E,
+  R,
+  Request,
+  Id
+>
+
+export interface RequestStreamHandlerWithInput<I, A, E, R, Request extends Req, Id extends string, Final = A> {
+  handler: (i: I) => Stream.Stream<A, E, R>
   id: Id
   options?: ClientForOptions
   Request: Request
+  /**
+   * Phantom type property (never set at runtime) that carries the `Final` type to
+   * `StreamMutationWithExtensions`. The tilde prefix follows the Effect convention for
+   * phantom/virtual properties and prevents accidental runtime access.
+   * Stream failures bubble through the execute effect's typed error channel `E`;
+   * the reactive `AsyncResult` ref also mirrors the failure for live progress UI.
+   */
+  readonly "~final"?: Final
 }
 
+/** Type alias: a no-input stream handler is simply `RequestStreamHandlerWithInput<void, …>`. */
+export type RequestStreamHandler<A, E, R, Request extends Req, Id extends string, Final = A> =
+  RequestStreamHandlerWithInput<void, A, E, R, Request, Id, Final>
+
 // make sure this is exported or d.ts of apiClientFactory breaks?!
-type ReqDecodingServices<M> = M extends { readonly "~decodingServices": infer DS } ? DS : never
+export type RequestInputFromMake<I extends { readonly make: (...args: any[]) => any }> = Parameters<I["make"]> extends
+  [] ? void : Parameters<I["make"]>[0]
+
+// Has no input only when the request schema declares no payload fields (the auto-added
+// `_tag` field is ignored). Any payload fields (even all-optional) produce a function handler.
+type HasNoFields<I> = I extends { readonly fields: infer F extends S.Struct.Fields }
+  ? [Exclude<keyof F, "_tag">] extends [never] ? true : false
+  : false
+
+type RequestInput<I extends { readonly make: (...args: any[]) => any }> = Parameters<I["make"]>[0]
+
+/**
+ * Caller-facing input type for a request. `void` when the request schema has no fields;
+ * otherwise `make`'s first param type.
+ */
+export type HandlerInput<I extends { readonly make: (...args: any[]) => any }> = HasNoFields<I> extends true ? void
+  : RequestInput<I>
+
+/** Extracts the final-value type from a stream request. Defaults to the success type when no `final` schema is set. */
+type FinalTypeOf<T extends Req> = T extends { readonly final: infer F extends S.Top } ? F["Type"]
+  : T["success"]["Type"]
+
+// `T["success"]` / `T["error"]` are constrained to `S.Top` via `Req`, so we
+// can read `["DecodingServices"]` directly. Avoids the conditional in
+// `S.Codec.DecodingServices<X> = X extends Top ? X["DecodingServices"] : never`,
+// which tsgo (native) fails to reduce in this generic position and leaves as
+// `unknown`, polluting the `R` channel of every client handler.
+type RequestHandlerFor<R, E, T extends Req, Id extends string> = T["stream"] extends true
+  ? RequestStreamHandlerWithInput<
+    HandlerInput<T>,
+    T["success"]["Type"],
+    T["error"]["Type"] | E,
+    R | T["success"]["DecodingServices"] | T["error"]["DecodingServices"],
+    T,
+    Id,
+    FinalTypeOf<T>
+  >
+  : RequestHandlerWithInput<
+    HandlerInput<T>,
+    T["success"]["Type"],
+    T["error"]["Type"] | E,
+    R | T["success"]["DecodingServices"] | T["error"]["DecodingServices"],
+    T,
+    Id
+  >
 
 export type RequestHandlers<R, E, M extends RequestsAny, ModuleName extends string> = {
-  [K in keyof M as M[K] extends Req ? K : never]: IsEmpty<Omit<S.Schema.Type<M[K]>, Cruft>> extends true
-    ? RequestHandler<
-      S.Schema.Type<M[K]["success"]>,
-      S.Schema.Type<M[K]["error"]> | E,
-      R | ReqDecodingServices<M[K]>,
-      M[K],
-      `${ModuleName}.${K & string}`
-    >
-    : RequestHandlerWithInput<
-      Omit<S.Schema.Type<M[K]>, Cruft>,
-      S.Schema.Type<M[K]["success"]>,
-      S.Schema.Type<M[K]["error"]> | E,
-      R | ReqDecodingServices<M[K]>,
-      M[K],
-      `${ModuleName}.${K & string}`
-    >
+  [K in keyof M as M[K] extends Req ? K : never]: Extract<M[K], Req> extends infer T extends Req
+    ? RequestHandlerFor<R, E, T, `${ModuleName}.${K & string}`>
+    : never
 }

package/src/client/errors.ts

@@ -1,19 +1,20 @@
 /** @effect-diagnostics overriddenSchemaConstructor:skip-file */
-import { TaggedError } from "effect-app/Schema"
+import { TaggedErrorClass } from "effect-app/Schema"
 import * as Cause from "effect/Cause"
-import * as S from "../Schema.js"
+import * as S from "../Schema.ts"
 
-export const tryToJson = (error: { toJSON(): unknown; toString(): string }) => {
+export const tryToJson = (error: unknown) => {
   try {
-    return error.toJSON()
+    const errorJson = (error as any).toJSON()
+    return errorJson && typeof errorJson === "object" ? errorJson as Record<string, unknown> : { error }
   } catch {
     try {
-      return error.toString()
+      return { error: (error as any).toString() }
     } catch (err) {
       try {
-        return `Failed to convert error: ${err}`
+        return { error: `Failed to convert error: ${err}` }
       } catch {
-        return `Failed to convert error: unknown failure`
+        return { error: `Failed to convert error: unknown failure` }
       }
     }
   }
@@ -21,7 +22,7 @@ export const tryToJson = (error: { toJSON(): unknown; toString(): string }) => {
 
 // eslint-disable-next-line unused-imports/no-unused-vars
 // @ts-expect-error type not used
-export class NotFoundError<ItemType = string> extends TaggedError<NotFoundError<ItemType>>()("NotFoundError", {
+export class NotFoundError<ItemType = string> extends TaggedErrorClass<NotFoundError<ItemType>>()("NotFoundError", {
   type: S.String,
   id: S.Unknown
 }) {
@@ -29,70 +30,97 @@ export class NotFoundError<ItemType = string> extends TaggedError<NotFoundError<
     props: { type: string; id: unknown; cause?: unknown },
     disableValidation?: boolean
   ) {
-    super(props as any, disableValidation as any)
+    super(props, disableValidation as any)
   }
   override get message() {
     return `Didn't find ${(this as any).type}#${JSON.stringify((this as any).id)}`
   }
+  override toString() {
+    return `NotFoundError: ${this.message}`
+  }
 }
 
 const messageFallback = (messageOrObject?: string | { message: string }) =>
   typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject ?? "" }
 
-export class InvalidStateError extends TaggedError<InvalidStateError>()("InvalidStateError", {
+export class InvalidStateError extends TaggedErrorClass<InvalidStateError>()("InvalidStateError", {
   message: S.String
 }) {
   constructor(messageOrObject: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any, disableValidation as any)
+    super(
+      typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject },
+      disableValidation as any
+    )
+  }
+  override toString() {
+    return `InvalidStateError: ${this.message}`
   }
 }
 
-export class ServiceUnavailableError extends TaggedError<ServiceUnavailableError>()("ServiceUnavailableError", {
+export class ServiceUnavailableError extends TaggedErrorClass<ServiceUnavailableError>()("ServiceUnavailableError", {
   message: S.String
 }) {
   constructor(messageOrObject: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any, disableValidation as any)
+    super(
+      typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject },
+      disableValidation as any
+    )
+  }
+  override toString() {
+    return `ServiceUnavailableError: ${this.message}`
   }
 }
 
-export class ValidationError extends TaggedError<ValidationError>()("ValidationError", {
+export class ValidationError extends TaggedErrorClass<ValidationError>()("ValidationError", {
   errors: S.Array(S.Unknown)
 }) {
   constructor(
     props: { errors: ReadonlyArray<unknown>; cause?: unknown },
     disableValidation?: boolean
   ) {
-    super(props as any, disableValidation as any)
+    super(props, disableValidation as any)
   }
   override get message() {
     return `Validation failed: ${(this as any).errors.map((e: any) => JSON.stringify(e, undefined, 2)).join(",\n")}`
   }
+  override toString() {
+    return `ValidationError: ${this.message}`
+  }
 }
 
-export class NotLoggedInError extends TaggedError<NotLoggedInError>()("NotLoggedInError", {
+export class NotLoggedInError extends TaggedErrorClass<NotLoggedInError>()("NotLoggedInError", {
   message: S.String
 }) {
   constructor(messageOrObject?: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(messageFallback(messageOrObject) as any, disableValidation as any)
+    super(messageFallback(messageOrObject), disableValidation as any)
+  }
+  override toString() {
+    return `NotLoggedInError: ${this.message}`
   }
 }
 
 /**
  * The user carries a valid Userprofile, but there is a problem with the login none the less.
  */
-export class LoginError extends TaggedError<LoginError>()("NotLoggedInError", {
+export class LoginError extends TaggedErrorClass<LoginError>()("NotLoggedInError", {
   message: S.String
 }) {
   constructor(messageOrObject?: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(messageFallback(messageOrObject) as any, disableValidation as any)
+    super(messageFallback(messageOrObject), disableValidation as any)
+  }
+  override toString() {
+    return `LoginError: ${this.message}`
   }
 }
 
-export class UnauthorizedError extends TaggedError<UnauthorizedError>()("UnauthorizedError", {
+export class UnauthorizedError extends TaggedErrorClass<UnauthorizedError>()("UnauthorizedError", {
   message: S.String
 }) {
   constructor(messageOrObject?: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(messageFallback(messageOrObject) as any, disableValidation as any)
+    super(messageFallback(messageOrObject), disableValidation as any)
+  }
+  override toString() {
+    return `UnauthorizedError: ${this.message}`
   }
 }
 
@@ -104,7 +132,7 @@ type OptimisticConcurrencyDetails = {
   readonly found?: string | undefined
 }
 
-export class OptimisticConcurrencyException extends TaggedError<OptimisticConcurrencyException>()(
+export class OptimisticConcurrencyException extends TaggedErrorClass<OptimisticConcurrencyException>()(
   "OptimisticConcurrencyException",
   { message: S.String }
 ) {
@@ -116,11 +144,56 @@ export class OptimisticConcurrencyException extends TaggedError<OptimisticConcur
       | ({ message: string; cause?: unknown; raw?: unknown }),
     disableValidation?: boolean
   ) {
-    super("message" in args ? args : { message: `Existing ${args.type} ${args.id} record changed` } as any, disableValidation as any)
+    super(
+      "message" in args ? args : { message: `Existing ${args.type} ${args.id} record changed` },
+      disableValidation as any
+    )
     if (!("message" in args)) {
       this.details = args
     }
   }
+  override toString() {
+    return `OptimisticConcurrencyException: ${this.message}`
+  }
+}
+
+/**
+ * Raised by a store adapter when a database operation fails for an
+ * infrastructure reason (request timeout, throttle, 5xx, dropped socket, or any
+ * non-conflict error). Distinct from `OptimisticConcurrencyException`, which is
+ * an expected etag conflict.
+ *
+ * `transient` is set by the adapter for failures worth retrying (timeout /
+ * throttle / 5xx / network). `cause` is the underlying adapter error, carried
+ * through a `Defect` schema so it serializes (an `Error` encodes to
+ * `{ name, message, cause }`) instead of breaking JSON encoding of the channel.
+ *
+ * Treated by the api/client/FE machinery like an unexpected (500-class) error.
+ */
+export class DatabaseError extends TaggedErrorClass<DatabaseError>()(
+  "DatabaseError",
+  {
+    message: S.String,
+    transient: S.Boolean,
+    cause: S.optional(S.Defect())
+  }
+) {
+  constructor(
+    args: { message?: string; transient?: boolean; cause?: unknown },
+    disableValidation?: boolean
+  ) {
+    super(
+      {
+        message: args.message ?? "Database operation failed",
+        transient: args.transient ?? false,
+        cause: args.cause
+      },
+      disableValidation as any
+    )
+  }
+  override toString() {
+    return `DatabaseError: ${this.message}`
+  }
 }
 
 const MutationOnlyErrors = [
@@ -134,7 +207,8 @@ const GeneralErrors = [
   LoginError,
   UnauthorizedError,
   ValidationError,
-  ServiceUnavailableError
+  ServiceUnavailableError,
+  DatabaseError
 ] as const
 
 export const SupportedErrors = S.Union([
@@ -169,11 +243,17 @@ export const silenceError = (e: Record<PropertyKey, any>) => {
 }
 
 export class CauseException<E> extends Error {
-  constructor(readonly originalCause: Cause.Cause<E>, readonly _tag: string) {
+  readonly originalCause: Cause.Cause<E>
+  readonly _tag: string
+
+  constructor(originalCause: Cause.Cause<E>, _tag: string) {
     const limit = Error.stackTraceLimit
     Error.stackTraceLimit = 0
     super()
     Error.stackTraceLimit = limit
+    this.originalCause = originalCause
+    this._tag = _tag
+    this.cause = Cause.squash(originalCause)
     // v4: makeFiberFailure removed — use Cause.prettyErrors instead
     const errors = Cause.prettyErrors(originalCause)
     const first = errors[0]
@@ -213,17 +293,17 @@ export class CauseException<E> extends Error {
   }
 }
 
-export const tryToReport = (error: { toReport(): unknown; toString(): string }) => {
+export const tryToReport = (error: { toReport(): Record<string, unknown>; toString(): string }) => {
   try {
     return error.toReport()
   } catch {
     try {
-      return error.toString()
+      return { error: error.toString() }
     } catch (err) {
       try {
-        return `Failed to convert error: ${err}`
+        return { error: `Failed to convert error: ${err}` }
       } catch {
-        return `Failed to convert error: unknown failure`
+        return { error: `Failed to convert error: unknown failure` }
       }
     }
   }