@effect/rpc - npm Package Compare versions

Comparing version 0.32.3 to 0.33.0

dist/cjs/internal/rpc.js

@@ -40,4 +40,4 @@ "use strict";
     [Serializable.symbolResult]: {
-      Success: isStream ? Schema.Never : Serializable.successSchema(options.request),
-      Failure: isStream ? Schema.Never : Serializable.failureSchema(options.request)
+      success: isStream ? Schema.Never : Serializable.successSchema(options.request),
+      failure: isStream ? Schema.Never : Serializable.failureSchema(options.request)
     },
@@ -44,0 +44,0 @@ [Equal.symbol](that) {

dist/cjs/Router.js

@@ -80,3 +80,4 @@ "use strict";
   failure: Schema.Never,
-  success: Schema.Never
+  success: Schema.Never,
+  defect: Schema.Defect
 }))( /*#__PURE__*/Exit.failCause(Cause.empty));
@@ -83,0 +84,0 @@ /**

dist/cjs/Rpc.js

@@ -57,4 +57,4 @@ "use strict";
  */
-const StreamRequest = () => (tag, failure, success, fields) => {
-  return class extends Schema.TaggedRequest()(tag, failure, success, fields) {
+const StreamRequest = () => (tag, options) => {
+  return class extends Schema.TaggedRequest()(tag, options) {
     constructor(props, disableValidation) {
@@ -90,3 +90,6 @@ super(props, disableValidation);
   sampled: Schema.Boolean,
-  headers: Schema.Record(Schema.String, Schema.String)
+  headers: Schema.Record({
+    key: Schema.String,
+    value: Schema.String
+  })
 });
@@ -93,0 +96,0 @@ /**

dist/dts/Resolver.d.ts

@@ -22,4 +22,4 @@ /**
 export declare const annotateHeaders: {
-    (headers: Headers.Input): <Req extends Schema.TaggedRequest.Any, R>(self: RequestResolver.RequestResolver<Rpc.Request<Req>, R>) => RequestResolver.RequestResolver<Rpc.Request<Req>, R>;
-    <Req extends Schema.TaggedRequest.Any, R>(self: RequestResolver.RequestResolver<Rpc.Request<Req>, R>, headers: Headers.Input): RequestResolver.RequestResolver<Rpc.Request<Req>, R>;
+    (headers: Headers.Input): <Req extends Schema.TaggedRequest.All, R>(self: RequestResolver.RequestResolver<Rpc.Request<Req>, R>) => RequestResolver.RequestResolver<Rpc.Request<Req>, R>;
+    <Req extends Schema.TaggedRequest.All, R>(self: RequestResolver.RequestResolver<Rpc.Request<Req>, R>, headers: Headers.Input): RequestResolver.RequestResolver<Rpc.Request<Req>, R>;
 };
@@ -31,4 +31,4 @@ /**
 export declare const annotateHeadersEffect: {
-    <E, R2>(headers: Effect.Effect<Headers.Input, E, R2>): <Req extends Schema.TaggedRequest.Any, R>(self: RequestResolver.RequestResolver<Rpc.Request<Req>, R>) => RequestResolver.RequestResolver<Rpc.Request<Req>, R | R2>;
-    <Req extends Schema.TaggedRequest.Any, R, E, R2>(self: RequestResolver.RequestResolver<Rpc.Request<Req>, R>, headers: Effect.Effect<Headers.Input, E, R2>): RequestResolver.RequestResolver<Rpc.Request<Req>, R | R2>;
+    <E, R2>(headers: Effect.Effect<Headers.Input, E, R2>): <Req extends Schema.TaggedRequest.All, R>(self: RequestResolver.RequestResolver<Rpc.Request<Req>, R>) => RequestResolver.RequestResolver<Rpc.Request<Req>, R | R2>;
+    <Req extends Schema.TaggedRequest.All, R, E, R2>(self: RequestResolver.RequestResolver<Rpc.Request<Req>, R>, headers: Effect.Effect<Headers.Input, E, R2>): RequestResolver.RequestResolver<Rpc.Request<Req>, R | R2>;
 };
@@ -35,0 +35,0 @@ /**

dist/dts/Router.d.ts

@@ -31,3 +31,3 @@ /**
  */
-export interface Router<Reqs extends Schema.TaggedRequest.Any, R> extends Pipeable {
+export interface Router<Reqs extends Schema.TaggedRequest.All, R> extends Pipeable {
     readonly [TypeId]: TypeId;
@@ -62,3 +62,3 @@ readonly rpcs: ReadonlySet<Rpc.Rpc<Reqs, R>>;
         index: number,
-        response: Schema.ExitEncoded<any, any> | ReadonlyArray<Schema.ExitEncoded<any, any>>
+        response: Schema.ExitEncoded<any, any, unknown> | ReadonlyArray<Schema.ExitEncoded<any, any, unknown>>
     ];
@@ -69,3 +69,3 @@ /**
      */
-    type ResponseEffect = Schema.ExitEncoded<any, any> | ReadonlyArray<Schema.ExitEncoded<any, any>>;
+    type ResponseEffect = Schema.ExitEncoded<any, any, unknown> | ReadonlyArray<Schema.ExitEncoded<any, any, unknown>>;
 }
@@ -90,4 +90,4 @@ /**
 export declare const provideServiceEffect: {
-    <I, S, E, R2>(tag: Context.Tag<I, S>, effect: Effect.Effect<S, E, R2>): <Reqs extends Schema.TaggedRequest.Any, R>(self: Router<Reqs, R>) => Router<Reqs, Exclude<R, I> | R2>;
-    <Reqs extends Schema.TaggedRequest.Any, R, I, S, E, R2>(self: Router<Reqs, R>, tag: Context.Tag<I, S>, effect: Effect.Effect<S, E, R2>): Router<Reqs, Exclude<R, I> | R2>;
+    <I, S, E, R2>(tag: Context.Tag<I, S>, effect: Effect.Effect<S, E, R2>): <Reqs extends Schema.TaggedRequest.All, R>(self: Router<Reqs, R>) => Router<Reqs, Exclude<R, I> | R2>;
+    <Reqs extends Schema.TaggedRequest.All, R, I, S, E, R2>(self: Router<Reqs, R>, tag: Context.Tag<I, S>, effect: Effect.Effect<S, E, R2>): Router<Reqs, Exclude<R, I> | R2>;
 };
@@ -99,4 +99,4 @@ /**
 export declare const provideService: {
-    <I, S>(tag: Context.Tag<I, S>, service: S): <Reqs extends Schema.TaggedRequest.Any, R>(self: Router<Reqs, R>) => Router<Reqs, Exclude<R, I>>;
-    <Reqs extends Schema.TaggedRequest.Any, R, I, S>(self: Router<Reqs, R>, tag: Context.Tag<I, S>, service: S): Router<Reqs, Exclude<R, I>>;
+    <I, S>(tag: Context.Tag<I, S>, service: S): <Reqs extends Schema.TaggedRequest.All, R>(self: Router<Reqs, R>) => Router<Reqs, Exclude<R, I>>;
+    <Reqs extends Schema.TaggedRequest.All, R, I, S>(self: Router<Reqs, R>, tag: Context.Tag<I, S>, service: S): Router<Reqs, Exclude<R, I>>;
 };
@@ -103,0 +103,0 @@ /**

dist/dts/Rpc.d.ts

@@ -38,3 +38,3 @@ /**
  */
-export type Rpc<Req extends Schema.TaggedRequest.Any, R> = RpcEffect<Req, R> | RpcStream<Req, R>;
+export type Rpc<Req extends Schema.TaggedRequest.All, R> = RpcEffect<Req, R> | RpcStream<Req, R>;
 /**
@@ -44,3 +44,3 @@ * @since 1.0.0
  */
-export interface RpcEffect<Req extends Schema.TaggedRequest.Any, R> extends Rpc.Proto<Req> {
+export interface RpcEffect<Req extends Schema.TaggedRequest.All, R> extends Rpc.Proto<Req> {
     readonly _tag: "Effect";
@@ -53,3 +53,3 @@ readonly handler: (request: Req) => Effect.Effect<EffectRequest.Request.Success<Req>, EffectRequest.Request.Error<Req>, R>;
  */
-export interface RpcStream<Req extends Schema.TaggedRequest.Any, R> extends Rpc.Proto<Req> {
+export interface RpcStream<Req extends Schema.TaggedRequest.All, R> extends Rpc.Proto<Req> {
     readonly _tag: "Stream";
@@ -67,3 +67,3 @@ readonly handler: (request: Req) => Stream.Stream<Req extends Serializable.WithResult<infer A, infer _I, infer _E, infer _EI, infer _R> ? A : never, Req extends Serializable.WithResult<infer _A, infer _I, infer E, infer _EI, infer _R> ? E : never, R>;
      */
-    interface Proto<Req extends Schema.TaggedRequest.Any> extends Pipeable {
+    interface Proto<Req extends Schema.TaggedRequest.All> extends Pipeable {
         readonly [TypeId]: TypeId;
@@ -87,3 +87,3 @@ readonly _tag: string;
      */
-    type Result<A extends Schema.TaggedRequest.Any, R = never> = StreamRequestTypeId extends keyof A ? EffectRequest.Request.Success<A> : Effect.Effect<EffectRequest.Request.Success<A>, EffectRequest.Request.Error<A>, R>;
+    type Result<A extends Schema.TaggedRequest.All, R = never> = StreamRequestTypeId extends keyof A ? EffectRequest.Request.Success<A> : Effect.Effect<EffectRequest.Request.Success<A>, EffectRequest.Request.Error<A>, R>;
     /**
@@ -93,3 +93,3 @@ * @since 1.0.0
      */
-    type ResultUndecoded<A extends Schema.TaggedRequest.Any, R = never> = A extends Serializable.WithResult<infer _A, infer I, infer E, infer _EI, infer _R> ? StreamRequestTypeId extends keyof A ? Stream.Stream<I, E, R> : Effect.Effect<I, E, R> : never;
+    type ResultUndecoded<A extends Schema.TaggedRequest.All, R = never> = A extends Serializable.WithResult<infer _A, infer I, infer E, infer _EI, infer _R> ? StreamRequestTypeId extends keyof A ? Stream.Stream<I, E, R> : Effect.Effect<I, E, R> : never;
 }
@@ -100,3 +100,3 @@ /**
  */
-export declare const effect: <Req extends Schema.TaggedRequest.Any, R>(schema: Schema.Schema<Req, any, unknown>, handler: (request: Req) => Effect.Effect<EffectRequest.Request.Success<Req>, EffectRequest.Request.Error<Req>, R>) => Rpc<Req, R>;
+export declare const effect: <Req extends Schema.TaggedRequest.All, R>(schema: Schema.Schema<Req, any, unknown>, handler: (request: Req) => Effect.Effect<EffectRequest.Request.Success<Req>, EffectRequest.Request.Error<Req>, R>) => Rpc<Req, R>;
 /**
@@ -146,3 +146,7 @@ * @since 1.0.0
  */
-export declare const StreamRequest: <Self>() => <Tag extends string, E, IE, RE, A, IA, RA, Fields extends Schema.Struct.Fields>(tag: Tag, failure: Schema.Schema<E, IE, RE>, success: Schema.Schema<A, IA, RA>, fields: Fields) => StreamRequestConstructor<Tag, Self, Schema.Schema.Context<Fields[keyof Fields]>, Types.Simplify<Schema.Struct.Encoded<Fields>>, Types.Simplify<Schema.Struct.Type<Fields>>, RE | RA, IE, E, IA, A>;
+export declare const StreamRequest: <Self>() => <Tag extends string, E, IE, RE, A, IA, RA, Payload extends Schema.Struct.Fields>(tag: Tag, options: {
+    readonly failure: Schema.Schema<E, IE, RE>;
+    readonly success: Schema.Schema<A, IA, RA>;
+    readonly payload: Payload;
+}) => StreamRequestConstructor<Tag, Self, Schema.Schema.Context<Payload[keyof Payload]>, Types.Simplify<Schema.Struct.Encoded<Payload>>, Types.Simplify<Schema.Struct.Type<Payload>>, RE | RA, IE, E, IA, A>;
 /**
@@ -157,3 +161,3 @@ * @since 1.0.0
  */
-export interface Request<A extends Schema.TaggedRequest.Any> extends EffectRequest.Request<EffectRequest.Request.Success<A>, EffectRequest.Request.Error<A>>, PrimaryKey.PrimaryKey, Serializable.WithResult<Serializable.WithResult.Context<A>, Schema.Schema.Encoded<A[typeof Serializable.symbolResult]["Failure"]>, Schema.Schema.Type<A[typeof Serializable.symbolResult]["Failure"]>, Schema.Schema.Encoded<A[typeof Serializable.symbolResult]["Success"]>, Schema.Schema.Type<A[typeof Serializable.symbolResult]["Success"]>> {
+export interface Request<A extends Schema.TaggedRequest.All> extends EffectRequest.Request<EffectRequest.Request.Success<A>, EffectRequest.Request.Error<A>>, PrimaryKey.PrimaryKey, Serializable.WithResult<Serializable.WithResult.Context<A>, Schema.Schema.Encoded<A[typeof Serializable.symbolResult]["failure"]>, Schema.Schema.Type<A[typeof Serializable.symbolResult]["failure"]>, Schema.Schema.Encoded<A[typeof Serializable.symbolResult]["success"]>, Schema.Schema.Type<A[typeof Serializable.symbolResult]["success"]>> {
     readonly request: A;
@@ -203,3 +207,3 @@ readonly traceId: string;
  */
-export declare const request: <A extends Schema.TaggedRequest.Any>(request: A, options?: {
+export declare const request: <A extends Schema.TaggedRequest.All>(request: A, options?: {
     readonly spanPrefix?: string;
@@ -211,3 +215,3 @@ }) => Effect.Effect<Request<A>, never, Scope>;
  */
-export declare const call: <A extends Schema.TaggedRequest.Any, R extends RequestResolver.RequestResolver<Request<A>> | Effect.Effect<RequestResolver.RequestResolver<Request<A>>, never, any>>(req: A, resolver: R, options?: {
+export declare const call: <A extends Schema.TaggedRequest.All, R extends RequestResolver.RequestResolver<Request<A>> | Effect.Effect<RequestResolver.RequestResolver<Request<A>>, never, any>>(req: A, resolver: R, options?: {
     readonly spanPrefix?: string;
@@ -220,4 +224,4 @@ }) => R extends Effect.Effect<infer _A, infer _E, infer R_1> ? Rpc.Result<A, R_1> : Rpc.Result<A>;
 export declare const provideServiceEffect: {
-    <I, S, E, R2>(tag: Context.Tag<I, S>, effect: Effect.Effect<S, E, R2>): <Req extends Schema.TaggedRequest.Any, R>(self: Rpc<Req, R>) => Rpc<Req, Exclude<R, I> | R2>;
-    <Req extends Schema.TaggedRequest.Any, R, I, S, E, R2>(self: Rpc<Req, R>, tag: Context.Tag<I, S>, effect: Effect.Effect<S, E, R2>): Rpc<Req, Exclude<R, I> | R2>;
+    <I, S, E, R2>(tag: Context.Tag<I, S>, effect: Effect.Effect<S, E, R2>): <Req extends Schema.TaggedRequest.All, R>(self: Rpc<Req, R>) => Rpc<Req, Exclude<R, I> | R2>;
+    <Req extends Schema.TaggedRequest.All, R, I, S, E, R2>(self: Rpc<Req, R>, tag: Context.Tag<I, S>, effect: Effect.Effect<S, E, R2>): Rpc<Req, Exclude<R, I> | R2>;
 };
@@ -229,5 +233,5 @@ /**
 export declare const provideService: {
-    <I, S>(tag: Context.Tag<I, S>, service: S): <Req extends Schema.TaggedRequest.Any, R>(self: Rpc<Req, R>) => Rpc<Req, Exclude<R, I>>;
-    <Req extends Schema.TaggedRequest.Any, R, I, S>(self: Rpc<Req, R>, tag: Context.Tag<I, S>, service: S): Rpc<Req, Exclude<R, I>>;
+    <I, S>(tag: Context.Tag<I, S>, service: S): <Req extends Schema.TaggedRequest.All, R>(self: Rpc<Req, R>) => Rpc<Req, Exclude<R, I>>;
+    <Req extends Schema.TaggedRequest.All, R, I, S>(self: Rpc<Req, R>, tag: Context.Tag<I, S>, service: S): Rpc<Req, Exclude<R, I>>;
 };
 //# sourceMappingURL=Rpc.d.ts.map

dist/esm/internal/rpc.js

@@ -31,4 +31,4 @@ import * as Schema from "@effect/schema/Schema";
     [Serializable.symbolResult]: {
-      Success: isStream ? Schema.Never : Serializable.successSchema(options.request),
-      Failure: isStream ? Schema.Never : Serializable.failureSchema(options.request)
+      success: isStream ? Schema.Never : Serializable.successSchema(options.request),
+      failure: isStream ? Schema.Never : Serializable.failureSchema(options.request)
     },
@@ -35,0 +35,0 @@ [Equal.symbol](that) {

dist/esm/Router.js

@@ -70,3 +70,4 @@ import * as Schema from "@effect/schema/Schema";
   failure: Schema.Never,
-  success: Schema.Never
+  success: Schema.Never,
+  defect: Schema.Defect
 }))( /*#__PURE__*/Exit.failCause(Cause.empty));
@@ -73,0 +74,0 @@ /**

dist/esm/Rpc.js

@@ -46,4 +46,4 @@ /**
  */
-export const StreamRequest = () => (tag, failure, success, fields) => {
-  return class extends Schema.TaggedRequest()(tag, failure, success, fields) {
+export const StreamRequest = () => (tag, options) => {
+  return class extends Schema.TaggedRequest()(tag, options) {
     constructor(props, disableValidation) {
@@ -77,3 +77,6 @@ super(props, disableValidation);
   sampled: Schema.Boolean,
-  headers: Schema.Record(Schema.String, Schema.String)
+  headers: Schema.Record({
+    key: Schema.String,
+    value: Schema.String
+  })
 });
@@ -80,0 +83,0 @@ /**

package.json

 {
   "name": "@effect/rpc",
-  "version": "0.32.3",
+  "version": "0.33.0",
   "description": "Functional programming in TypeScript",
@@ -13,4 +13,4 @@ "license": "MIT",
   "peerDependencies": {
-    "@effect/platform": "^0.59.3",
-    "@effect/schema": "^0.68.27",
+    "@effect/platform": "^0.60.0",
+    "@effect/schema": "^0.69.0",
     "effect": "^3.5.7"
@@ -17,0 +17,0 @@ },

README.md

@@ -44,18 +44,16 @@ # Introduction
 // Request to retrieve a list of users
-export class UserList extends Schema.TaggedRequest<UserList>()(
-  "UserList",
-  Schema.Never, // Indicates that no errors are expected
-  Schema.Array(User), // Specifies that the response is an array of Users
-  {}
-) {}
+export class UserList extends Schema.TaggedRequest<UserList>()("UserList", {
+  failure: Schema.Never, // Indicates that no errors are expected
+  success: Schema.Array(User), // Specifies that the response is an array of Users
+  payload: {}
+}) {}
 
 // Request to retrieve a user by ID
-export class UserById extends Schema.TaggedRequest<UserById>()(
-  "UserById",
-  Schema.String, // Indicates that errors, if any, will be returned as strings
-  User, // Specifies that the response is a User
-  {
+export class UserById extends Schema.TaggedRequest<UserById>()("UserById", {
+  failure: Schema.String, // Indicates that errors, if any, will be returned as strings
+  success: User, // Specifies that the response is a User
+  payload: {
     id: Schema.String
   }
-) {}
+}) {}
 
@@ -65,6 +63,8 @@ // Request to create a new user
   "UserCreate",
-  Schema.Never, // Indicates that no errors are expected
-  User, // Specifies that the response is a User
   {
-    name: Schema.String
+    failure: Schema.Never, // Indicates that no errors are expected
+    success: User, // Specifies that the response is a User
+    payload: {
+      name: Schema.String
+    }
   }
@@ -216,8 +216,7 @@ ) {}
 
-export class Counts extends Rpc.StreamRequest<Counts>()(
-  "Counts",
-  Schema.Never, // No error schema defined
-  Schema.Number, // Output is a number
-  {}
-) {}
+export class Counts extends Rpc.StreamRequest<Counts>()("Counts", {
+  failure: Schema.Never, // Indicates that no errors are expected
+  success: Schema.Number, // Specifies that the response is a number
+  payload: {}
+}) {}
 ```
@@ -224,0 +223,0 @@

src/internal/rpc.ts

@@ -17,3 +17,3 @@ import type * as Headers from "@effect/platform/Headers"
   const cache = new Map<string, A>()
-  return (request: Schema.TaggedRequest.Any): A => {
+  return (request: Schema.TaggedRequest.All): A => {
     let result = cache.get(request._tag)
@@ -35,3 +35,3 @@ if (result !== undefined) {
 /** @internal */
-export const makeRequest = <A extends Schema.TaggedRequest.Any>(
+export const makeRequest = <A extends Schema.TaggedRequest.All>(
   options: {
@@ -52,6 +52,6 @@ readonly request: A
     [Serializable.symbolResult]: {
-      Success: isStream
+      success: isStream
         ? Schema.Never
         : Serializable.successSchema(options.request as any),
-      Failure: isStream ? Schema.Never : Serializable.failureSchema(options.request as any)
+      failure: isStream ? Schema.Never : Serializable.failureSchema(options.request as any)
     },
@@ -58,0 +58,0 @@ [Equal.symbol](that: Rpc.Request<A>) {

src/Resolver.ts

@@ -34,72 +34,74 @@ /**
 
-  return RequestResolver.makeBatched((requests: Arr.NonEmptyArray<Rpc.Request<Schema.TaggedRequest.Any>>) => {
-    const [effectRequests, streamRequests] = Arr.partition(
-      requests,
-      (_): _ is Rpc.Request<Rpc.StreamRequest.Any> => StreamRequestTypeId in _.request
-    )
+  return RequestResolver.makeBatched(
+    (requests: Arr.NonEmptyArray<Rpc.Request<Schema.TaggedRequest.All>>) => {
+      const [effectRequests, streamRequests] = Arr.partition(
+        requests,
+        (_): _ is Rpc.Request<Rpc.StreamRequest.Any> => StreamRequestTypeId in _.request
+      )
 
-    const processEffects = pipe(
-      Effect.forEach(effectRequests, (_) =>
-        Effect.map(
-          Serializable.serialize(_.request),
-          (request) => ({ ..._, request })
-        )),
-      Effect.flatMap((payload) =>
-        Stream.runForEach(
-          Stream.filter(
-            handler(payload),
-            (_): _ is Router.Router.Response => Arr.isArray(_) && _.length === 2
-          ),
-          ([index, response]): Effect.Effect<void, ParseError, any> => {
-            const request = effectRequests[index]
-            return Effect.matchCauseEffect(Effect.orDie(getDecode(request.request)(response)), {
-              onFailure: (cause) => Request.failCause(request, cause as any),
-              onSuccess: (exit) => Request.complete(request, exit as any)
-            })
-          }
+      const processEffects = pipe(
+        Effect.forEach(effectRequests, (_) =>
+          Effect.map(
+            Serializable.serialize(_.request),
+            (request) => ({ ..._, request })
+          )),
+        Effect.flatMap((payload) =>
+          Stream.runForEach(
+            Stream.filter(
+              handler(payload),
+              (_): _ is Router.Router.Response => Arr.isArray(_) && _.length === 2
+            ),
+            ([index, response]): Effect.Effect<void, ParseError, any> => {
+              const request = effectRequests[index]
+              return Effect.matchCauseEffect(Effect.orDie(getDecode(request.request)(response)), {
+                onFailure: (cause) => Request.failCause(request, cause as any),
+                onSuccess: (exit) => Request.complete(request, exit as any)
+              })
+            }
+          )
+        ),
+        Effect.orDie,
+        Effect.catchAllCause((cause) =>
+          Effect.forEach(
+            effectRequests,
+            (request) => Request.failCause(request, cause),
+            { discard: true }
+          )
         )
-      ),
-      Effect.orDie,
-      Effect.catchAllCause((cause) =>
-        Effect.forEach(
-          effectRequests,
-          (request) => Request.failCause(request, cause),
-          { discard: true }
-        )
       )
-    )
 
-    const processStreams = pipe(
-      Effect.forEach(streamRequests, (request) => {
-        const decode = getDecodeChunk(request.request)
-        const stream = pipe(
-          Serializable.serialize(request.request),
-          Effect.map((_) => ({ ...request, request: _ })),
-          Effect.map((payload) =>
-            pipe(
-              handler([payload]),
-              Stream.mapEffect((_) => Effect.orDie(decode((_ as Router.Router.Response)[1]))),
-              Stream.flattenChunks,
-              Stream.flatMap(Exit.match({
-                onFailure: (cause) => Cause.isEmptyType(cause) ? Stream.empty : Stream.failCause(cause),
-                onSuccess: Stream.succeed
-              }))
-            )
-          ),
-          Effect.orDie,
-          Stream.unwrap
+      const processStreams = pipe(
+        Effect.forEach(streamRequests, (request) => {
+          const decode = getDecodeChunk(request.request)
+          const stream = pipe(
+            Serializable.serialize(request.request),
+            Effect.map((_) => ({ ...request, request: _ })),
+            Effect.map((payload) =>
+              pipe(
+                handler([payload]),
+                Stream.mapEffect((_) => Effect.orDie(decode((_ as Router.Router.Response)[1]))),
+                Stream.flattenChunks,
+                Stream.flatMap(Exit.match({
+                  onFailure: (cause) => Cause.isEmptyType(cause) ? Stream.empty : Stream.failCause(cause),
+                  onSuccess: Stream.succeed
+                }))
+              )
+            ),
+            Effect.orDie,
+            Stream.unwrap
+          )
+          return Request.succeed(request, stream as any)
+        }, { discard: true }),
+        Effect.catchAllCause((cause) =>
+          Effect.forEach(
+            streamRequests,
+            (request) => Request.failCause(request, cause),
+            { discard: true }
+          )
         )
-        return Request.succeed(request, stream as any)
-      }, { discard: true }),
-      Effect.catchAllCause((cause) =>
-        Effect.forEach(
-          streamRequests,
-          (request) => Request.failCause(request, cause),
-          { discard: true }
-        )
       )
-    )
 
-    return Effect.zipRight(processStreams, processEffects)
-  })
+      return Effect.zipRight(processStreams, processEffects)
+    }
+  )
 }
@@ -114,10 +116,10 @@
     headers: Headers.Input
-  ): <Req extends Schema.TaggedRequest.Any, R>(
+  ): <Req extends Schema.TaggedRequest.All, R>(
     self: RequestResolver.RequestResolver<Rpc.Request<Req>, R>
   ) => RequestResolver.RequestResolver<Rpc.Request<Req>, R>
-  <Req extends Schema.TaggedRequest.Any, R>(
+  <Req extends Schema.TaggedRequest.All, R>(
     self: RequestResolver.RequestResolver<Rpc.Request<Req>, R>,
     headers: Headers.Input
   ): RequestResolver.RequestResolver<Rpc.Request<Req>, R>
-} = dual(2, <Req extends Schema.TaggedRequest.Any, R>(
+} = dual(2, <Req extends Schema.TaggedRequest.All, R>(
   self: RequestResolver.RequestResolver<Rpc.Request<Req>, R>,
@@ -144,10 +146,10 @@ headers: Headers.Input
     headers: Effect.Effect<Headers.Input, E, R2>
-  ): <Req extends Schema.TaggedRequest.Any, R>(
+  ): <Req extends Schema.TaggedRequest.All, R>(
     self: RequestResolver.RequestResolver<Rpc.Request<Req>, R>
   ) => RequestResolver.RequestResolver<Rpc.Request<Req>, R | R2>
-  <Req extends Schema.TaggedRequest.Any, R, E, R2>(
+  <Req extends Schema.TaggedRequest.All, R, E, R2>(
     self: RequestResolver.RequestResolver<Rpc.Request<Req>, R>,
     headers: Effect.Effect<Headers.Input, E, R2>
   ): RequestResolver.RequestResolver<Rpc.Request<Req>, R | R2>
-} = dual(2, <Req extends Schema.TaggedRequest.Any, R, E, R2>(
+} = dual(2, <Req extends Schema.TaggedRequest.All, R, E, R2>(
   self: RequestResolver.RequestResolver<Rpc.Request<Req>, R>,
@@ -206,2 +208,2 @@ headers: Effect.Effect<Headers.Input, E, R2>
   }
-): Client<R> => ((request: Schema.TaggedRequest.Any) => Rpc.call(request, resolver, options)) as any
+): Client<R> => ((request: Schema.TaggedRequest.All) => Rpc.call(request, resolver, options)) as any

src/ResolverNoStream.ts

@@ -33,3 +33,3 @@ /**
 
-  return RequestResolver.makeBatched((requests: NonEmptyArray<Rpc.Request<Schema.TaggedRequest.Any>>) =>
+  return RequestResolver.makeBatched((requests: NonEmptyArray<Rpc.Request<Schema.TaggedRequest.All>>) =>
     pipe(
@@ -36,0 +36,0 @@ Effect.forEach(requests, (_) =>

src/Router.ts

@@ -43,3 +43,3 @@ /**
  */
-export interface Router<Reqs extends Schema.TaggedRequest.Any, R> extends Pipeable {
+export interface Router<Reqs extends Schema.TaggedRequest.All, R> extends Pipeable {
   readonly [TypeId]: TypeId
@@ -83,3 +83,3 @@ readonly rpcs: ReadonlySet<Rpc.Rpc<Reqs, R>>
     index: number,
-    response: Schema.ExitEncoded<any, any> | ReadonlyArray<Schema.ExitEncoded<any, any>>
+    response: Schema.ExitEncoded<any, any, unknown> | ReadonlyArray<Schema.ExitEncoded<any, any, unknown>>
   ]
@@ -91,6 +91,8 @@
    */
-  export type ResponseEffect = Schema.ExitEncoded<any, any> | ReadonlyArray<Schema.ExitEncoded<any, any>>
+  export type ResponseEffect =
+    | Schema.ExitEncoded<any, any, unknown>
+    | ReadonlyArray<Schema.ExitEncoded<any, any, unknown>>
 }
 
-const fromSet = <Reqs extends Schema.TaggedRequest.Any, R>(
+const fromSet = <Reqs extends Schema.TaggedRequest.All, R>(
   rpcs: ReadonlySet<Rpc.Rpc<Reqs, R>>
@@ -144,4 +146,4 @@ ): Router<Reqs, R> => ({
     effect: Effect.Effect<S, E, R2>
-  ): <Reqs extends Schema.TaggedRequest.Any, R>(self: Router<Reqs, R>) => Router<Reqs, Exclude<R, I> | R2>
-  <Reqs extends Schema.TaggedRequest.Any, R, I, S, E, R2>(
+  ): <Reqs extends Schema.TaggedRequest.All, R>(self: Router<Reqs, R>) => Router<Reqs, Exclude<R, I> | R2>
+  <Reqs extends Schema.TaggedRequest.All, R, I, S, E, R2>(
     self: Router<Reqs, R>,
@@ -151,3 +153,3 @@ tag: Context.Tag<I, S>,
   ): Router<Reqs, Exclude<R, I> | R2>
-} = dual(3, <Reqs extends Schema.TaggedRequest.Any, R, I, S, E, R2>(
+} = dual(3, <Reqs extends Schema.TaggedRequest.All, R, I, S, E, R2>(
   self: Router<Reqs, R>,
@@ -166,4 +168,4 @@ tag: Context.Tag<I, S>,
     service: S
-  ): <Reqs extends Schema.TaggedRequest.Any, R>(self: Router<Reqs, R>) => Router<Reqs, Exclude<R, I>>
-  <Reqs extends Schema.TaggedRequest.Any, R, I, S>(
+  ): <Reqs extends Schema.TaggedRequest.All, R>(self: Router<Reqs, R>) => Router<Reqs, Exclude<R, I>>
+  <Reqs extends Schema.TaggedRequest.All, R, I, S>(
     self: Router<Reqs, R>,
@@ -173,3 +175,3 @@ tag: Context.Tag<I, S>,
   ): Router<Reqs, Exclude<R, I>>
-} = dual(3, <Reqs extends Schema.TaggedRequest.Any, R, I, S>(
+} = dual(3, <Reqs extends Schema.TaggedRequest.All, R, I, S>(
   self: Router<Reqs, R>,
@@ -197,3 +199,4 @@ tag: Context.Tag<I, S>,
   failure: Schema.Never,
-  success: Schema.Never
+  success: Schema.Never,
+  defect: Schema.Defect
 }))(Exit.failCause(Cause.empty))
@@ -380,3 +383,3 @@
   const schema: Schema.Schema<
-    readonly [Schema.TaggedRequest.Any, Rpc.Rpc<any, any>],
+    readonly [Schema.TaggedRequest.All, Rpc.Rpc<any, any>],
     unknown,
@@ -383,0 +386,0 @@ Router.ContextRaw<R>

src/Rpc.ts

@@ -46,3 +46,3 @@ /**
  */
-export type Rpc<Req extends Schema.TaggedRequest.Any, R> = RpcEffect<Req, R> | RpcStream<Req, R>
+export type Rpc<Req extends Schema.TaggedRequest.All, R> = RpcEffect<Req, R> | RpcStream<Req, R>
 
@@ -53,3 +53,3 @@ /**
  */
-export interface RpcEffect<Req extends Schema.TaggedRequest.Any, R> extends Rpc.Proto<Req> {
+export interface RpcEffect<Req extends Schema.TaggedRequest.All, R> extends Rpc.Proto<Req> {
   readonly _tag: "Effect"
@@ -69,3 +69,3 @@ readonly handler: (
  */
-export interface RpcStream<Req extends Schema.TaggedRequest.Any, R> extends Rpc.Proto<Req> {
+export interface RpcStream<Req extends Schema.TaggedRequest.All, R> extends Rpc.Proto<Req> {
   readonly _tag: "Stream"
@@ -90,3 +90,3 @@ readonly handler: (
    */
-  export interface Proto<Req extends Schema.TaggedRequest.Any> extends Pipeable {
+  export interface Proto<Req extends Schema.TaggedRequest.All> extends Pipeable {
     readonly [TypeId]: TypeId
@@ -115,3 +115,3 @@ readonly _tag: string
    */
-  export type Result<A extends Schema.TaggedRequest.Any, R = never> = StreamRequestTypeId extends keyof A ?
+  export type Result<A extends Schema.TaggedRequest.All, R = never> = StreamRequestTypeId extends keyof A ?
     EffectRequest.Request.Success<A> :
@@ -124,3 +124,3 @@ Effect.Effect<EffectRequest.Request.Success<A>, EffectRequest.Request.Error<A>, R>
    */
-  export type ResultUndecoded<A extends Schema.TaggedRequest.Any, R = never> = A extends
+  export type ResultUndecoded<A extends Schema.TaggedRequest.All, R = never> = A extends
     Serializable.WithResult<infer _A, infer I, infer E, infer _EI, infer _R>
@@ -136,3 +136,3 @@ ? StreamRequestTypeId extends keyof A ? Stream.Stream<I, E, R>
  */
-export const effect = <Req extends Schema.TaggedRequest.Any, R>(
+export const effect = <Req extends Schema.TaggedRequest.All, R>(
   schema: Schema.Schema<Req, any, unknown>,
@@ -208,13 +208,15 @@ handler: (request: Req) => Effect.Effect<EffectRequest.Request.Success<Req>, EffectRequest.Request.Error<Req>, R>
   <Self>() =>
-  <Tag extends string, E, IE, RE, A, IA, RA, Fields extends Schema.Struct.Fields>(
+  <Tag extends string, E, IE, RE, A, IA, RA, Payload extends Schema.Struct.Fields>(
     tag: Tag,
-    failure: Schema.Schema<E, IE, RE>,
-    success: Schema.Schema<A, IA, RA>,
-    fields: Fields
+    options: {
+      readonly failure: Schema.Schema<E, IE, RE>
+      readonly success: Schema.Schema<A, IA, RA>
+      readonly payload: Payload
+    }
   ): StreamRequestConstructor<
     Tag,
     Self,
-    Schema.Schema.Context<Fields[keyof Fields]>,
-    Types.Simplify<Schema.Struct.Encoded<Fields>>,
-    Types.Simplify<Schema.Struct.Type<Fields>>,
+    Schema.Schema.Context<Payload[keyof Payload]>,
+    Types.Simplify<Schema.Struct.Encoded<Payload>>,
+    Types.Simplify<Schema.Struct.Type<Payload>>,
     RE | RA,
@@ -226,3 +228,3 @@ IE,
   > => {
-    return class extends (Schema.TaggedRequest<{}>()(tag, failure, success, fields) as any) {
+    return class extends (Schema.TaggedRequest<{}>()(tag, options) as any) {
       constructor(props: any, disableValidation?: boolean) {
@@ -262,3 +264,3 @@ super(props, disableValidation)
  */
-export interface Request<A extends Schema.TaggedRequest.Any> extends
+export interface Request<A extends Schema.TaggedRequest.All> extends
   EffectRequest.Request<
@@ -271,6 +273,6 @@ EffectRequest.Request.Success<A>,
     Serializable.WithResult.Context<A>,
-    Schema.Schema.Encoded<A[typeof Serializable.symbolResult]["Failure"]>,
-    Schema.Schema.Type<A[typeof Serializable.symbolResult]["Failure"]>,
-    Schema.Schema.Encoded<A[typeof Serializable.symbolResult]["Success"]>,
-    Schema.Schema.Type<A[typeof Serializable.symbolResult]["Success"]>
+    Schema.Schema.Encoded<A[typeof Serializable.symbolResult]["failure"]>,
+    Schema.Schema.Type<A[typeof Serializable.symbolResult]["failure"]>,
+    Schema.Schema.Encoded<A[typeof Serializable.symbolResult]["success"]>,
+    Schema.Schema.Type<A[typeof Serializable.symbolResult]["success"]>
   >
@@ -309,3 +311,3 @@ {
     sampled: Schema.Boolean,
-    headers: Schema.Record(Schema.String, Schema.String)
+    headers: Schema.Record({ key: Schema.String, value: Schema.String })
   })
@@ -349,3 +351,3 @@
  */
-export const request = <A extends Schema.TaggedRequest.Any>(
+export const request = <A extends Schema.TaggedRequest.All>(
   request: A,
@@ -378,3 +380,3 @@ options?: {
 export const call = <
-  A extends Schema.TaggedRequest.Any,
+  A extends Schema.TaggedRequest.All,
   R extends
@@ -406,4 +408,4 @@ | RequestResolver.RequestResolver<Request<A>>
     effect: Effect.Effect<S, E, R2>
-  ): <Req extends Schema.TaggedRequest.Any, R>(self: Rpc<Req, R>) => Rpc<Req, Exclude<R, I> | R2>
-  <Req extends Schema.TaggedRequest.Any, R, I, S, E, R2>(
+  ): <Req extends Schema.TaggedRequest.All, R>(self: Rpc<Req, R>) => Rpc<Req, Exclude<R, I> | R2>
+  <Req extends Schema.TaggedRequest.All, R, I, S, E, R2>(
     self: Rpc<Req, R>,
@@ -413,3 +415,3 @@ tag: Context.Tag<I, S>,
   ): Rpc<Req, Exclude<R, I> | R2>
-} = dual(3, <Req extends Schema.TaggedRequest.Any, R, I, S, E, R2>(
+} = dual(3, <Req extends Schema.TaggedRequest.All, R, I, S, E, R2>(
   self: Rpc<Req, R>,
@@ -434,4 +436,4 @@ tag: Context.Tag<I, S>,
     service: S
-  ): <Req extends Schema.TaggedRequest.Any, R>(self: Rpc<Req, R>) => Rpc<Req, Exclude<R, I>>
-  <Req extends Schema.TaggedRequest.Any, R, I, S>(
+  ): <Req extends Schema.TaggedRequest.All, R>(self: Rpc<Req, R>) => Rpc<Req, Exclude<R, I>>
+  <Req extends Schema.TaggedRequest.All, R, I, S>(
     self: Rpc<Req, R>,
@@ -441,3 +443,3 @@ tag: Context.Tag<I, S>,
   ): Rpc<Req, Exclude<R, I>>
-} = dual(3, <Req extends Schema.TaggedRequest.Any, R, I, S>(
+} = dual(3, <Req extends Schema.TaggedRequest.All, R, I, S>(
   self: Rpc<Req, R>,
@@ -444,0 +446,0 @@ tag: Context.Tag<I, S>,

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

200363

increased by0.37%

Lines of code

2734

increased by0.66%

Worsened metrics

Number of lines in readme file

303

decreased by-0.33%

No dependency changes