effect 4.0.0-beta.97 → 4.0.0-beta.99

package/src/unstable/reactivity/AtomHttpApi.ts

@@ -40,7 +40,7 @@ import * as Reactivity from "./Reactivity.ts"
  * @category models
  * @since 4.0.0
  */
-export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpApiGroup.Any>
+export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpApiGroup.Constraint>
   extends Context.Service<Self, HttpApiClient.Client<Groups, never, never>>
 {
   new(_: never): Context.ServiceClass.Shape<Id, HttpApiClient.Client<Groups, never, never>>
@@ -48,23 +48,23 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
   readonly runtime: Atom.AtomRuntime<Self>
 
   readonly mutation: <
-    GroupName extends HttpApiGroup.Name<Groups>,
-    Name extends HttpApiEndpoint.Name<HttpApiGroup.Endpoints<Group>>,
-    Group extends HttpApiGroup.Any = HttpApiGroup.WithName<Groups, GroupName>,
-    Endpoint extends HttpApiEndpoint.Any = HttpApiEndpoint.WithName<
+    GroupIdentifier extends HttpApiGroup.Identifier<Groups>,
+    EndpointIdentifier extends HttpApiEndpoint.Identifier<HttpApiGroup.Endpoints<Group>>,
+    Group extends HttpApiGroup.Constraint = HttpApiGroup.WithIdentifier<Groups, GroupIdentifier>,
+    Endpoint extends HttpApiEndpoint.Constraint = HttpApiEndpoint.WithIdentifier<
       HttpApiGroup.Endpoints<Group>,
-      Name
+      EndpointIdentifier
     >,
     const ResponseMode extends HttpApiEndpoint.ClientResponseMode = HttpApiEndpoint.ClientResponseMode
   >(
-    group: GroupName,
-    endpoint: Name,
+    group: GroupIdentifier,
+    endpoint: EndpointIdentifier,
     options?: {
       readonly responseMode?: ResponseMode | undefined
     }
   ) => [Endpoint] extends [
     HttpApiEndpoint.HttpApiEndpoint<
-      infer _Name,
+      infer _Identifier,
       infer _Method,
       infer _Path,
       infer _Params,
@@ -88,20 +88,20 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
     : never
 
   readonly query: <
-    GroupName extends HttpApiGroup.Name<Groups>,
-    Name extends HttpApiEndpoint.Name<HttpApiGroup.Endpoints<Group>>,
-    Group extends HttpApiGroup.Any = HttpApiGroup.WithName<Groups, GroupName>,
-    Endpoint extends HttpApiEndpoint.Any = HttpApiEndpoint.WithName<
+    GroupIdentifier extends HttpApiGroup.Identifier<Groups>,
+    EndpointIdentifier extends HttpApiEndpoint.Identifier<HttpApiGroup.Endpoints<Group>>,
+    Group extends HttpApiGroup.Constraint = HttpApiGroup.WithIdentifier<Groups, GroupIdentifier>,
+    Endpoint extends HttpApiEndpoint.Constraint = HttpApiEndpoint.WithIdentifier<
       HttpApiGroup.Endpoints<Group>,
-      Name
+      EndpointIdentifier
     >,
     const ResponseMode extends HttpApiEndpoint.ClientResponseMode = "decoded-only"
   >(
-    group: GroupName,
-    endpoint: Name,
+    group: GroupIdentifier,
+    endpoint: EndpointIdentifier,
     request: [Endpoint] extends [
       HttpApiEndpoint.HttpApiEndpoint<
-        infer _Name,
+        infer _Identifier,
         infer _Method,
         infer _Path,
         infer _Params,
@@ -126,7 +126,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
       : never
   ) => [Endpoint] extends [
     HttpApiEndpoint.HttpApiEndpoint<
-      infer _Name,
+      infer _Identifier,
       infer _Method,
       infer _Path,
       infer _Params,
@@ -166,157 +166,159 @@ declare global {
  * @category constructors
  * @since 4.0.0
  */
-export const Service = <Self>() =>
-<const Id extends string, ApiId extends string, Groups extends HttpApiGroup.Any>(
-  id: Id,
-  options: {
-    readonly api: HttpApi.HttpApi<ApiId, Groups>
-    readonly httpClient:
-      | Layer.Layer<
-        | HttpApiGroup.ClientServices<Groups>
-        | HttpClient.HttpClient
-      >
-      | ((get: Atom.AtomContext) => Layer.Layer<
-        | HttpApiGroup.ClientServices<Groups>
-        | HttpClient.HttpClient
-      >)
-    readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined
-    readonly transformResponse?:
-      | ((effect: Effect.Effect<unknown, unknown, unknown>) => Effect.Effect<unknown, unknown, unknown>)
-      | undefined
-    readonly baseUrl?: URL | string | undefined
-    readonly runtime?: Atom.RuntimeFactory | undefined
-  }
-): AtomHttpApiClient<Self, Id, Groups> => {
-  const self: Mutable<AtomHttpApiClient<Self, Id, Groups>> = Context.Service<
-    Self,
-    HttpApiClient.Client<Groups, never, never>
-  >()(id) as any
-
-  const layer = Layer.effect(
-    self,
-    HttpApiClient.make(options.api, options)
-  )
-  const runtimeFactory = options.runtime ?? Atom.runtime
-  self.runtime = runtimeFactory(
-    typeof options.httpClient === "function" ?
-      (get) =>
-        Layer.provide(
-          layer,
-          (options.httpClient as (get: Atom.AtomContext) => Layer.Layer<
-            | HttpApiGroup.ClientServices<Groups>
-            | HttpClient.HttpClient
-          >)(get)
-        ) as Layer.Layer<Self> :
-      Layer.provide(layer, options.httpClient) as Layer.Layer<Self>
-  )
+export const Service =
+  <Self>() =>
+  <const Id extends string, ApiId extends string, Groups extends HttpApiGroup.Constraint>(
+    id: Id,
+    options: {
+      readonly api: HttpApi.HttpApi<ApiId, Groups>
+      readonly httpClient:
+        | Layer.Layer<
+          | HttpApiGroup.ClientServices<Groups>
+          | HttpClient.HttpClient
+        >
+        | ((get: Atom.AtomContext) => Layer.Layer<
+          | HttpApiGroup.ClientServices<Groups>
+          | HttpClient.HttpClient
+        >)
+      readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined
+      readonly transformResponse?:
+        | ((effect: Effect.Effect<unknown, unknown, unknown>) => Effect.Effect<unknown, unknown, unknown>)
+        | undefined
+      readonly baseUrl?: URL | string | undefined
+      readonly runtime?: Atom.RuntimeFactory | undefined
+    }
+  ): AtomHttpApiClient<Self, Id, Groups> => {
+    const self: Mutable<AtomHttpApiClient<Self, Id, Groups>> = Context.Service<
+      Self,
+      HttpApiClient.Client<Groups, never, never>
+    >()(id) as any
 
-  const catchErrors = Effect.catch((e: unknown) =>
-    Schema.isSchemaError(e) || HttpClientError.isHttpClientError(e) ? Effect.die(e) : Effect.fail(e)
-  )
+    const layer = Layer.effect(
+      self,
+      HttpApiClient.make(options.api, options)
+    )
+    const runtimeFactory = options.runtime ?? Atom.runtime
+    self.runtime = runtimeFactory(
+      typeof options.httpClient === "function" ?
+        (get) =>
+          Layer.provide(
+            layer,
+            (options.httpClient as (get: Atom.AtomContext) => Layer.Layer<
+              | HttpApiGroup.ClientServices<Groups>
+              | HttpClient.HttpClient
+            >)(get)
+          ) as Layer.Layer<Self> :
+        Layer.provide(layer, options.httpClient) as Layer.Layer<Self>
+    )
 
-  const mutationFamily = Atom.family(({ endpoint, group, responseMode }: MutationKey) => {
-    const atom = self.runtime.fn<{
-      params: any
-      query: any
-      headers: any
-      payload: any
-      reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
-    }>()(
-      Effect.fnUntraced(function*(opts) {
-        const client = (yield* self) as any
-        const effect = catchErrors(client[group][endpoint]({
-          ...opts,
-          responseMode
-        }) as Effect.Effect<any>)
-        return yield* opts.reactivityKeys
-          ? Reactivity.mutation(effect, opts.reactivityKeys)
-          : effect
-      })
+    const catchErrors = Effect.catch((e: unknown) =>
+      Schema.isSchemaError(e) || HttpClientError.isHttpClientError(e) ? Effect.die(e) : Effect.fail(e)
     )
-    if (responseMode === "decoded-only") {
-      const definition = options.api.groups[group]!.endpoints[endpoint]! as HttpApiEndpoint.AnyWithProps
-      return Atom.serializable(atom, {
-        key: `AtomHttpApi:mutation:${group}:${endpoint}`,
-        schema: AsyncResult.Schema({
-          success: Schema.Union(HttpApiEndpoint.getSuccessSchemas(definition)),
-          error: Schema.Union(HttpApiEndpoint.getErrorSchemas(definition))
-        }) as any
-      })
-    }
-    return atom
-  }) as any
+    const groups = options.api.groups as unknown as Record<string, HttpApiGroup.Top>
 
-  self.mutation = ((group: string, endpoint: string, options?: {
-    readonly responseMode?: HttpApiEndpoint.ClientResponseMode | undefined
-  }) =>
-    mutationFamily({
-      group,
-      endpoint,
-      responseMode: options?.responseMode ?? "decoded-only"
-    })) as any
+    const mutationFamily = Atom.family(({ endpoint, group, responseMode }: MutationKey) => {
+      const atom = self.runtime.fn<{
+        params: any
+        query: any
+        headers: any
+        payload: any
+        reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
+      }>()(
+        Effect.fnUntraced(function*(opts) {
+          const client = (yield* self) as any
+          const effect = catchErrors(client[group][endpoint]({
+            ...opts,
+            responseMode
+          }) as Effect.Effect<any>)
+          return yield* opts.reactivityKeys
+            ? Reactivity.mutation(effect, opts.reactivityKeys)
+            : effect
+        })
+      )
+      if (responseMode === "decoded-only") {
+        const definition = groups[group].endpoints[endpoint]
+        return Atom.serializable(atom, {
+          key: `AtomHttpApi:mutation:${group}:${endpoint}`,
+          schema: AsyncResult.Schema({
+            success: Schema.Union(HttpApiEndpoint.getSuccessSchemas(definition)),
+            error: Schema.Union(HttpApiEndpoint.getErrorSchemas(definition))
+          }) as any
+        })
+      }
+      return atom
+    }) as any
 
-  const queryFamily = Atom.family((opts: QueryKey) => {
-    let atom = self.runtime.atom(self.use((client_) => {
-      const client = client_ as any
-      return catchErrors(client[opts.group][opts.endpoint](opts) as Effect.Effect<
-        any,
-        HttpClientError.HttpClientError | SchemaError
-      >)
-    }))
-    if (opts.responseMode === "decoded-only" && opts.serializationKey) {
-      const endpoint = options.api.groups[opts.group]!.endpoints[opts.endpoint]! as HttpApiEndpoint.AnyWithProps
-      atom = Atom.serializable(atom, {
-        key: `AtomHttpApi:${opts.group}:${opts.endpoint}:${opts.serializationKey}`,
-        schema: AsyncResult.Schema({
-          success: Schema.Union(HttpApiEndpoint.getSuccessSchemas(endpoint)),
-          error: Schema.Union(HttpApiEndpoint.getErrorSchemas(endpoint))
-        }) as any
-      })
-    }
-    if (opts.timeToLive) {
-      atom = Duration.isFinite(opts.timeToLive)
-        ? Atom.setIdleTTL(atom, opts.timeToLive)
-        : Atom.keepAlive(atom)
-    }
-    return opts.reactivityKeys
-      ? self.runtime.factory.withReactivity(opts.reactivityKeys)(atom)
-      : atom
-  })
+    self.mutation = ((group: string, endpoint: string, options?: {
+      readonly responseMode?: HttpApiEndpoint.ClientResponseMode | undefined
+    }) =>
+      mutationFamily({
+        group,
+        endpoint,
+        responseMode: options?.responseMode ?? "decoded-only"
+      })) as any
 
-  self.query = ((
-    group: string,
-    endpoint: string,
-    request: {
-      readonly params?: any
-      readonly query?: any
-      readonly payload?: any
-      readonly headers?: any
-      readonly responseMode?: HttpApiEndpoint.ClientResponseMode
-      readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
-      readonly timeToLive?: Duration.Input | undefined
-      readonly serializationKey?: string | undefined
-    }
-  ) => {
-    const key: QueryKey = {
-      group,
-      endpoint,
-      params: request.params,
-      query: request.query,
-      payload: request.payload,
-      headers: request.headers,
-      responseMode: request.responseMode ?? "decoded-only",
-      reactivityKeys: request.reactivityKeys,
-      timeToLive: request.timeToLive
-        ? Duration.fromInputUnsafe(request.timeToLive)
-        : undefined,
-      serializationKey: request.serializationKey
-    }
-    return queryFamily(key)
-  }) as any
+    const queryFamily = Atom.family((opts: QueryKey) => {
+      let atom = self.runtime.atom(self.use((client_) => {
+        const client = client_ as any
+        return catchErrors(client[opts.group][opts.endpoint](opts) as Effect.Effect<
+          any,
+          HttpClientError.HttpClientError | SchemaError
+        >)
+      }))
+      if (opts.responseMode === "decoded-only" && opts.serializationKey) {
+        const endpoint = groups[opts.group].endpoints[opts.endpoint]
+        atom = Atom.serializable(atom, {
+          key: `AtomHttpApi:${opts.group}:${opts.endpoint}:${opts.serializationKey}`,
+          schema: AsyncResult.Schema({
+            success: Schema.Union(HttpApiEndpoint.getSuccessSchemas(endpoint)),
+            error: Schema.Union(HttpApiEndpoint.getErrorSchemas(endpoint))
+          }) as any
+        })
+      }
+      if (opts.timeToLive) {
+        atom = Duration.isFinite(opts.timeToLive)
+          ? Atom.setIdleTTL(atom, opts.timeToLive)
+          : Atom.keepAlive(atom)
+      }
+      return opts.reactivityKeys
+        ? self.runtime.factory.withReactivity(opts.reactivityKeys)(atom)
+        : atom
+    })
 
-  return self as AtomHttpApiClient<Self, Id, Groups>
-}
+    self.query = ((
+      group: string,
+      endpoint: string,
+      request: {
+        readonly params?: any
+        readonly query?: any
+        readonly payload?: any
+        readonly headers?: any
+        readonly responseMode?: HttpApiEndpoint.ClientResponseMode
+        readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
+        readonly timeToLive?: Duration.Input | undefined
+        readonly serializationKey?: string | undefined
+      }
+    ) => {
+      const key: QueryKey = {
+        group,
+        endpoint,
+        params: request.params,
+        query: request.query,
+        payload: request.payload,
+        headers: request.headers,
+        responseMode: request.responseMode ?? "decoded-only",
+        reactivityKeys: request.reactivityKeys,
+        timeToLive: request.timeToLive
+          ? Duration.fromInputUnsafe(request.timeToLive)
+          : undefined,
+        serializationKey: request.serializationKey
+      }
+      return queryFamily(key)
+    }) as any
+
+    return self as AtomHttpApiClient<Self, Id, Groups>
+  }
 
 interface MutationKey {
   group: string

package/src/unstable/rpc/RpcServer.ts

@@ -67,7 +67,9 @@ import { withRun } from "./Utils.ts"
  * @since 4.0.0
  */
 export interface RpcServer<A extends Rpc.Any> {
-  readonly write: (clientId: number, message: FromClient<A>) => Effect.Effect<void>
+  readonly write: (clientId: number, message: FromClient<A>, options?: {
+    readonly onRequest?: (<A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>) | undefined
+  }) => Effect.Effect<void>
   readonly disconnect: (clientId: number) => Effect.Effect<void>
 }
 
@@ -164,7 +166,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
       return Effect.void
     })
 
-  const write = (clientId: number, message: FromClient<Rpcs>): Effect.Effect<void> =>
+  const write: RpcServer<Rpcs>["write"] = (clientId, message, opts) =>
     Effect.catchDefect(
       Effect.withFiber((requestFiber) => {
         if (isShutdown) return Effect.interrupt
@@ -184,7 +186,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
 
         switch (message._tag) {
           case "Request": {
-            return handleRequest(requestFiber, client, message)
+            return handleRequest(requestFiber, client, message, opts)
           }
           case "Ack": {
             const latch = client.latches.get(message.requestId)
@@ -231,7 +233,8 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
   const handleRequest = (
     requestFiber: Fiber.Fiber<any, any>,
     client: Client,
-    request: Request<Rpcs>
+    request: Request<Rpcs>,
+    opts: Parameters<RpcServer<Rpcs>["write"]>[2]
   ): Effect.Effect<void> => {
     if (client.fibers.has(request.id)) {
       return Effect.interrupt
@@ -312,6 +315,9 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
       }
       return close ? Effect.ensuring(write, close) : write
     })
+    if (opts?.onRequest) {
+      effect = opts.onRequest(effect)
+    }
     if (enableTracing) {
       const parentSpan = requestFiber.context.mapUnsafe.get(
         Tracer.ParentSpan.key

package/src/unstable/sql/SqlClient.ts

@@ -62,8 +62,7 @@ export interface SqlClient extends Constructor {
   readonly transactionService: Context.Service<TransactionConnection, TransactionConnection.Service>
 
   /**
-   * Use the Reactivity service from @effect/experimental to create a reactive
-   * query.
+   * Use the Reactivity service to create a reactive query.
    */
   readonly reactive: <A, E, R>(
     keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>,

package/src/unstable/workflow/DurableDeferred.ts

@@ -292,7 +292,7 @@ export const raceAll = <
     const engine = yield* EngineTag
     const exit = yield* engine.deferredResult(deferred)
     if (Option.isSome(exit)) {
-      return yield* Effect.flatten(exit.value) as Effect.Effect<any, any, any>
+      return yield* exit.value
     }
     return yield* into(
       Effect.raceAll(options.effects),

package/src/unstable/workflow/WorkflowProxyServer.ts

@@ -29,28 +29,27 @@ import type { WorkflowEngine } from "./WorkflowEngine.ts"
  */
 export const layerHttpApi = <
   ApiId extends string,
-  Groups extends HttpApiGroup.Any,
-  Name extends HttpApiGroup.Name<Groups>,
+  Groups extends HttpApiGroup.Constraint,
+  Identifier extends HttpApiGroup.Identifier<Groups>,
   const Workflows extends NonEmptyReadonlyArray<Workflow.Any>
 >(
   api: HttpApi.HttpApi<ApiId, Groups>,
-  name: Name,
+  identifier: Identifier,
   workflows: Workflows
 ): Layer.Layer<
-  HttpApiGroup.ApiGroup<ApiId, Name>,
+  HttpApiGroup.Service<ApiId, Identifier>,
   never,
   WorkflowEngine | Workflow.RequirementsHandler<Workflows[number]>
 > =>
   HttpApiBuilder.group(
     api,
-    name,
-    Effect.fnUntraced(function*(handlers_) {
-      let handlers = handlers_ as any
+    identifier,
+    Effect.fnUntraced(function*(handlers: any) {
       for (const workflow_ of workflows) {
         const workflow = workflow_ as Workflow.AnyWithProps
         handlers = handlers
           .handle(
-            workflow._tag as any,
+            workflow._tag,
             ({ payload }: { payload: any }) =>
               workflow.execute(payload).pipe(
                 Effect.tapDefect(Effect.logError),
@@ -61,9 +60,9 @@ export const layerHttpApi = <
               )
           )
           .handle(
-            workflow._tag + "Discard" as any,
+            workflow._tag + "Discard",
             ({ payload }: { payload: any }) =>
-              workflow.execute(payload, { discard: true } as any).pipe(
+              workflow.execute(payload, { discard: true }).pipe(
                 Effect.tapDefect(Effect.logError),
                 Effect.annotateLogs({
                   module: "WorkflowProxyServer",
@@ -72,7 +71,7 @@ export const layerHttpApi = <
               )
           )
           .handle(
-            workflow._tag + "Resume" as any,
+            workflow._tag + "Resume",
             ({ payload }: { payload: any }) =>
               workflow.resume(payload.executionId).pipe(
                 Effect.tapDefect(Effect.logError),
@@ -83,7 +82,7 @@ export const layerHttpApi = <
               )
           )
       }
-      return handlers as HttpApiBuilder.Handlers<never, never>
+      return handlers as HttpApiBuilder.Handlers<never>
     })
   )