@effect-app/infra 4.0.0-beta.4 → 4.0.0-beta.40

package/src/QueueMaker/sbqueue.ts

@@ -1,12 +1,11 @@
 import { Tracer } from "effect"
-import { Cause, Effect, flow, S } from "effect-app"
+import { Cause, Effect, flow, type NonEmptyReadonlyArray, S } from "effect-app"
 import type { StringId } from "effect-app/Schema"
 import { pretty } from "effect-app/utils"
 import { Receiver, Sender } from "../adapters/ServiceBus.js"
 import { getRequestContext, setupRequestContextWithCustomSpan } from "../api/setupRequest.js"
 import { InfraLogger } from "../logger.js"
 import { reportNonInterruptedFailure, reportNonInterruptedFailureCause, reportQueueError } from "./errors.js"
-import type { NonEmptyReadonlyArray } from "effect-app"
 import { type QueueBase, QueueMeta } from "./service.js"
 
 export function makeServiceBusQueue<
@@ -22,8 +21,11 @@ export function makeServiceBusQueue<
     body: schema,
     meta: QueueMeta
   })
+  const wireSchemaJson = S.fromJsonString(wireSchema)
+  const encodePublish = S.encodeEffect(wireSchemaJson)
   const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
-  const parseDrain = flow(S.decodeUnknownEffect(drainW), Effect.orDie)
+  const drainWJson = S.fromJsonString(drainW)
+  const parseDrain = flow(S.decodeUnknownEffect(drainWJson), Effect.orDie)
 
   return Effect.gen(function*() {
     const sender = yield* Sender
@@ -40,55 +42,51 @@ export function makeServiceBusQueue<
         handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
         sessionId?: string
       ) => {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        function processMessage(messageBody: any) {
-          return Effect
-            .sync(() => JSON.parse(messageBody))
-            .pipe(
-              Effect.flatMap((x) => parseDrain(x)),
-              Effect.orDie,
-              Effect
-                .flatMap(({ body, meta }) => {
-                  let effect = InfraLogger
-                    .logDebug(`[${receiver.name}] Processing incoming message`)
-                    .pipe(
-                      Effect.annotateLogs({
-                        body: pretty(body),
-                        meta: pretty(meta)
-                      }),
-                      Effect.andThen(handleEvent(body)),
-                      Effect.orDie
-                    )
-                    // we silenceAndReportError here, so that the error is reported, and moves into the Exit.
-                    .pipe(
-                      silenceAndReportError,
-                      (_) =>
-                        setupRequestContextWithCustomSpan(
-                          _,
-                          meta,
-                          `queue.drain: ${receiver.name}${sessionId ? `#${sessionId}` : ""}.${body._tag}`,
-                          {
-                            captureStackTrace: false,
-                            kind: "consumer",
-                            attributes: {
-                              "queue.name": receiver.name,
-                              "queue.sessionId": sessionId,
-                              "queue.input": body
-                            }
+        function processMessage(messageBody: unknown) {
+          return parseDrain(messageBody).pipe(
+            Effect.orDie,
+            Effect
+              .flatMap(({ body, meta }) => {
+                let effect = InfraLogger
+                  .logDebug(`[${receiver.name}] Processing incoming message`)
+                  .pipe(
+                    Effect.annotateLogs({
+                      body: pretty(body),
+                      meta: pretty(meta)
+                    }),
+                    Effect.andThen(handleEvent(body)),
+                    Effect.orDie
+                  )
+                  // we silenceAndReportError here, so that the error is reported, and moves into the Exit.
+                  .pipe(
+                    silenceAndReportError,
+                    (_) =>
+                      setupRequestContextWithCustomSpan(
+                        _,
+                        meta,
+                        `queue.drain: ${receiver.name}${sessionId ? `#${sessionId}` : ""}.${body._tag}`,
+                        {
+                          captureStackTrace: false,
+                          kind: "consumer",
+                          attributes: {
+                            "queue.name": receiver.name,
+                            "queue.sessionId": sessionId,
+                            "queue.input": body
                           }
-                        )
-                    )
-                  if (meta.span) {
-                    effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
-                  }
-                  return effect
-                }),
-              Effect
-                // we reportError here, so that we report the error only, and keep flowing
-                .tapCause(reportError),
-              // we still need to flatten the Exit.
-              Effect.flatMap((_) => _)
-            )
+                        }
+                      )
+                  )
+                if (meta.span) {
+                  effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
+                }
+                return effect
+              }),
+            Effect
+              // we reportError here, so that we report the error only, and keep flowing
+              .tapCause(reportError),
+            // we still need to flatten the Exit.
+            Effect.flatMap((_) => _)
+          )
         }
 
         return receiver
@@ -111,17 +109,22 @@ export function makeServiceBusQueue<
         getRequestContext
           .pipe(
             Effect.flatMap((requestContext) =>
-              Effect.forEach(messages, (m) =>
-                S.encodeEffect(wireSchema)({
-                  body: m,
-                  meta: requestContext
-                }).pipe(Effect.orDie, Effect.map((encoded) => ({
-                  body: JSON.stringify(encoded),
-                  messageId: m.id, /* correllationid: requestId */
-                  contentType: "application/json",
-                  sessionId: "sessionId" in m ? m.sessionId as string : undefined as unknown as string // TODO: optional
-                }))))
-              .pipe(Effect.flatMap((msgs) => sender.sendMessages(msgs)))
+              Effect
+                .forEach(messages, (m) =>
+                  encodePublish({
+                    body: m,
+                    meta: requestContext
+                  })
+                    .pipe(
+                      Effect.orDie,
+                      Effect.map((body) => ({
+                        body,
+                        messageId: m.id, /* correllationid: requestId */
+                        contentType: "application/json",
+                        sessionId: "sessionId" in m ? m.sessionId as string : undefined as unknown as string // TODO: optional
+                      }))
+                    ))
+                .pipe(Effect.flatMap((msgs) => sender.sendMessages(msgs)))
             ),
             Effect.withSpan("queue.publish: " + sender.name, {
               kind: "producer",

package/src/RequestFiberSet.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Fiber, FiberSet, Layer, ServiceMap, type Tracer } from "effect-app"
+import { Effect, Fiber, FiberSet, Layer, Option, ServiceMap, type Tracer } from "effect-app"
 import { reportRequestError, reportUnknownRequestError } from "./api/reportError.js"
 import { InfraLogger } from "./logger.js"
 
@@ -8,8 +8,8 @@ const getRootParentSpan = Effect.gen(function*() {
     Effect.catchTag("NoSuchElementError", () => Effect.succeed(null))
   )
   if (!span) return span
-  while (span._tag === "Span" && span.parent !== undefined) {
-    span = span.parent
+  while (span._tag === "Span" && Option.isSome(span.parent)) {
+    span = span.parent.value
   }
   return span
 })

package/src/Store/Cosmos.ts

@@ -328,15 +328,13 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                             .query<M>(q, { partitionKey: mainPartitionKey })
                             .fetchAll()
                             .then(({ resources }) =>
-                              resources.map((_) =>
-                                ({
-                                  ...pipe(
-                                    defaultValues,
-                                    Struct.pick(f.select!.filter((_) => typeof _ === "string"))
-                                  ),
-                                  ...mapReverseId(_ as any)
-                                }) as any
-                              )
+                              resources.map((_) => ({
+                                ...pipe(
+                                  defaultValues,
+                                  Struct.pick(f.select!.filter((_) => typeof _ === "string") as never[])
+                                ),
+                                ...mapReverseId(_ as any)
+                              }))
                             )
                           : container
                             .items
@@ -404,7 +402,9 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                   Effect
                     .flatMap((x) => {
                       if (x.statusCode === 412 || x.statusCode === 404 || x.statusCode === 409) {
-                        return Effect.fail(new OptimisticConcurrencyException({ type: name, id: e[idKey], code: x.statusCode }))
+                        return Effect.fail(
+                          new OptimisticConcurrencyException({ type: name, id: e[idKey], code: x.statusCode })
+                        )
                       }
                       if (x.statusCode > 299 || x.statusCode < 200) {
                         return Effect.die(

package/src/Store/Memory.ts

@@ -24,7 +24,7 @@ export function memFilter<T extends FieldValues, U extends keyof T = never>(f: F
         )
         const n = Struct.pick(i, keys)
         subKeys.forEach((subKey) => {
-          n[subKey.key] = i[subKey.key]!.map(Struct.pick(subKey.subKeys))
+          n[subKey.key] = i[subKey.key]!.map(Struct.pick(subKey.subKeys as never[]))
         })
         return n as M
       }) as any
@@ -72,9 +72,7 @@ export function memFilter<T extends FieldValues, U extends keyof T = never>(f: F
 }
 
 const defaultNs: NonEmptyString255 = NonEmptyString255("primary")
-export class storeId
-  extends ServiceMap.Reference("StoreId", { defaultValue: (): NonEmptyString255 => defaultNs })
-{}
+export class storeId extends ServiceMap.Reference("StoreId", { defaultValue: (): NonEmptyString255 => defaultNs }) {}
 
 function logQuery(f: FilterArgs<any, any>, defaultValues?: any) {
   return InfraLogger

package/src/adapters/SQL/Model.ts

@@ -7,10 +7,6 @@
 /**
  * @since 1.0.0
  */
-import * as VariantSchema from "effect/unstable/schema/VariantSchema"
-import { SqlClient } from "effect/unstable/sql/SqlClient"
-import * as SqlResolver from "effect/unstable/sql/SqlResolver"
-import * as SqlSchema from "effect/unstable/sql/SqlSchema"
 import crypto from "crypto" // TODO
 import type { Brand } from "effect/Brand"
 import * as DateTime from "effect/DateTime"
@@ -24,6 +20,10 @@ import * as Schema from "effect/Schema"
 import * as Getter from "effect/SchemaGetter"
 import * as Transformation from "effect/SchemaTransformation"
 import type { Scope } from "effect/Scope"
+import * as VariantSchema from "effect/unstable/schema/VariantSchema"
+import { SqlClient } from "effect/unstable/sql/SqlClient"
+import * as SqlResolver from "effect/unstable/sql/SqlResolver"
+import * as SqlSchema from "effect/unstable/sql/SqlSchema"
 
 const {
   Class,
@@ -190,14 +190,13 @@ export const Generated = <S extends Schema.Top>(
  * @since 1.0.0
  * @category generated
  */
-export interface GeneratedByApp<S extends Schema.Top>
-  extends
-    VariantSchema.Field<{
-      readonly select: S
-      readonly insert: S
-      readonly update: S
-      readonly json: S
-    }>
+export interface GeneratedByApp<S extends Schema.Top> extends
+  VariantSchema.Field<{
+    readonly select: S
+    readonly insert: S
+    readonly update: S
+    readonly json: S
+  }>
 {}
 
 /**
@@ -303,8 +302,7 @@ export const FieldOption: <Field extends VariantSchema.Field<any> | Schema.Top>(
 ) => Field extends Schema.Top ? FieldOption<Field>
   : Field extends VariantSchema.Field<infer S> ? VariantSchema.Field<
       {
-        readonly [K in keyof S]: S[K] extends Schema.Top
-          ? K extends VariantsDatabase ? Schema.OptionFromNullOr<S[K]>
+        readonly [K in keyof S]: S[K] extends Schema.Top ? K extends VariantsDatabase ? Schema.OptionFromNullOr<S[K]>
           : optionalOption<S[K]>
           : never
       }
@@ -545,16 +543,15 @@ export const DateTimeUpdateFromNumber: DateTimeUpdateFromNumber = Field({
  * @since 1.0.0
  * @category json
  */
-export interface JsonFromString<S extends Schema.Top>
-  extends
-    VariantSchema.Field<{
-      readonly select: Schema.fromJsonString<S>
-      readonly insert: Schema.fromJsonString<S>
-      readonly update: Schema.fromJsonString<S>
-      readonly json: S
-      readonly jsonCreate: S
-      readonly jsonUpdate: S
-    }>
+export interface JsonFromString<S extends Schema.Top> extends
+  VariantSchema.Field<{
+    readonly select: Schema.fromJsonString<S>
+    readonly insert: Schema.fromJsonString<S>
+    readonly update: Schema.fromJsonString<S>
+    readonly json: S
+    readonly jsonCreate: S
+    readonly jsonUpdate: S
+  }>
 {}
 
 /**
@@ -825,26 +822,28 @@ export const makeDataLoaders = <
     const idColumn = options.idColumn as string
     const setMaxBatchSize = options.maxBatchSize ? RequestResolver.batchN(options.maxBatchSize) : identity
 
-    const insertResolver = SqlResolver.ordered({
-      Request: Model.insert,
-      Result: Model,
-      execute: (request: any) =>
-        sql.onDialectOrElse({
-          mysql: () =>
-            Effect.forEach(request, (request: any) =>
-              sql`insert into ${sql(options.tableName)} ${sql.insert(request)};
+    const insertResolver = SqlResolver
+      .ordered({
+        Request: Model.insert,
+        Result: Model,
+        execute: (request: any) =>
+          sql.onDialectOrElse({
+            mysql: () =>
+              Effect.forEach(request, (request: any) =>
+                sql`insert into ${sql(options.tableName)} ${sql.insert(request)};
 select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID();`
-                .unprepared
-                .pipe(
-                  Effect.map(([, results]) => results![0] as any)
-                ), { concurrency: 10 }),
-          orElse: () => sql`insert into ${sql(options.tableName)} ${sql.insert(request).returning("*")}`
-        })
-    }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
-      RequestResolver.withSpan(`${options.spanPrefix}.insertResolver`)
-    )
+                  .unprepared
+                  .pipe(
+                    Effect.map(([, results]) => results![0] as any)
+                  ), { concurrency: 10 }),
+            orElse: () => sql`insert into ${sql(options.tableName)} ${sql.insert(request).returning("*")}`
+          })
+      })
+      .pipe(
+        RequestResolver.setDelay(options.window),
+        setMaxBatchSize,
+        RequestResolver.withSpan(`${options.spanPrefix}.insertResolver`)
+      )
     const insertExecute = SqlResolver.request(insertResolver)
     const insert = (
       insert: S["insert"]["Type"]
@@ -860,14 +859,16 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
         })
       ) as any
 
-    const insertVoidResolver = SqlResolver.void({
-      Request: Model.insert,
-      execute: (request: any) => sql`insert into ${sql(options.tableName)} ${sql.insert(request)}`
-    }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
-      RequestResolver.withSpan(`${options.spanPrefix}.insertVoidResolver`)
-    )
+    const insertVoidResolver = SqlResolver
+      .void({
+        Request: Model.insert,
+        execute: (request: any) => sql`insert into ${sql(options.tableName)} ${sql.insert(request)}`
+      })
+      .pipe(
+        RequestResolver.setDelay(options.window),
+        setMaxBatchSize,
+        RequestResolver.withSpan(`${options.spanPrefix}.insertVoidResolver`)
+      )
     const insertVoidExecute = SqlResolver.request(insertVoidResolver)
     const insertVoid = (
       insert: S["insert"]["Type"]
@@ -878,18 +879,20 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
         })
       ) as any
 
-    const findByIdResolver = SqlResolver.findById({
-      Id: idSchema,
-      Result: Model,
-      ResultId(request: any) {
-        return request[idColumn]
-      },
-      execute: (ids: any) => sql`select * from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
-    }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
-      RequestResolver.withSpan(`${options.spanPrefix}.findByIdResolver`)
-    )
+    const findByIdResolver = SqlResolver
+      .findById({
+        Id: idSchema,
+        Result: Model,
+        ResultId(request: any) {
+          return request[idColumn]
+        },
+        execute: (ids: any) => sql`select * from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
+      })
+      .pipe(
+        RequestResolver.setDelay(options.window),
+        setMaxBatchSize,
+        RequestResolver.withSpan(`${options.spanPrefix}.findByIdResolver`)
+      )
     const findByIdExecute = SqlResolver.request(findByIdResolver)
     const findById = (
       id: S["fields"][Id]["Type"]
@@ -904,14 +907,16 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
         })
       ) as any
 
-    const deleteResolver = SqlResolver.void({
-      Request: idSchema,
-      execute: (ids: any) => sql`delete from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
-    }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
-      RequestResolver.withSpan(`${options.spanPrefix}.deleteResolver`)
-    )
+    const deleteResolver = SqlResolver
+      .void({
+        Request: idSchema,
+        execute: (ids: any) => sql`delete from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
+      })
+      .pipe(
+        RequestResolver.setDelay(options.window),
+        setMaxBatchSize,
+        RequestResolver.withSpan(`${options.spanPrefix}.deleteResolver`)
+      )
     const deleteExecute = SqlResolver.request(deleteResolver)
     const delete_ = (
       id: S["fields"][Id]["Type"]

package/src/adapters/ServiceBus.ts

@@ -66,7 +66,7 @@ export const SenderTag = <Id>() => <Key extends string>(queueName: Key) => {
   return Object.assign(tag, {
     layer: Layer.effect(
       tag,
-      Sender.make(queueName).pipe(Effect.map((_) => Sender.of(_)))
+      Sender.make(queueName).pipe(Effect.map(Sender.of))
     )
   })
 }
@@ -185,7 +185,7 @@ export const ReceiverTag = <Id>() => <Key extends string>(queueName: Key) => {
   return Object.assign(tag, {
     layer: Layer.effect(
       tag,
-      makeReceiver(queueName).pipe(Effect.map((_) => Receiver.of(_)))
+      makeReceiver(queueName).pipe(Effect.map(Receiver.of))
     )
   })
 }

package/src/api/internal/events.ts

@@ -28,19 +28,20 @@ export const makeSSE = <A extends { id: any }, SI, SR>(
 
             const enc = new TextEncoder()
 
-            const encode = S.encodeEffect(schema)
+            const encode = S.encodeEffect(S.fromJsonString(schema))
 
             const eventStream = Stream.mapEffect(
               events,
               (_) =>
                 encode(_.evt)
-                  .pipe(Effect.map((evt) => `id: ${_.evt.id}\ndata: ${JSON.stringify(evt)}`))
+                  .pipe(Effect.map((data) => `id: ${_.evt.id}\ndata: ${data}`))
             )
 
             const stream = pipe(
               setRetry,
               Stream.merge(keepAlive),
-              Stream.merge(eventStream, { haltStrategy: "either" }),
+              // Keep this unary so pipe receives a function, not a Stream value.
+              (self) => Stream.merge(self, eventStream, { haltStrategy: "either" }),
               Stream.tapCause((cause) => Effect.logError("SSE error", cause)),
               Stream.map((_) => enc.encode(_ + "\n\n"))
             )

package/src/api/routing/schema/jwt.ts

@@ -15,8 +15,7 @@ export const parseJwt = <Sch extends S.Top>(
       (s, _options) =>
         Effect.try({
           try: () => jwtDecode(s, options),
-          catch: (e: any) =>
-            new S.SchemaIssue.InvalidValue(Option.some(s), { message: e?.message })
+          catch: (e: any) => new S.SchemaIssue.InvalidValue(Option.some(s), { message: e?.message })
         })
     )
-    .pipe(S.decodeTo(schema) as any) as any as S.decodeTo<Sch, S.String>
+    .pipe(S.decodeTo(schema) as any)

package/src/api/routing.ts

@@ -194,7 +194,8 @@ export const makeRouter = <
     > = (
       req: S.Schema.Type<Action>
     ) => Generator<
-      Yieldable<any,
+      Yieldable<
+        any,
         any,
         S.Schema.Type<GetFailure<Action>> | S.SchemaError,
         // the actual implementation of the handler may just require the dynamic context provided by the middleware
@@ -247,7 +248,7 @@ export const makeRouter = <
 
     type RequestModules = FilterRequestModules<Resource>
     const requestModules = typedKeysOf(rsc).reduce((acc, cur) => {
-      if (Predicate.isObject(rsc[cur]) && rsc[cur]["success"]) {
+      if (Predicate.isObjectKeyword(rsc[cur]) && rsc[cur]["success"]) {
         acc[cur as keyof RequestModules] = rsc[cur] as RequestModules[keyof RequestModules]
       }
       return acc
@@ -319,7 +320,7 @@ export const makeRouter = <
               ? Impl[K]["raw"] extends (...args: any[]) => Effect.Effect<any, any, infer R> ? R
               : Impl[K]["raw"] extends Effect.Effect<any, any, infer R> ? R
               : Impl[K]["raw"] extends (...args: any[]) => Generator<
-                Yieldable<any,any, any, infer R>,
+                Yieldable<any, any, any, infer R>,
                 any,
                 any
               > ? R
@@ -327,7 +328,7 @@ export const makeRouter = <
               : Impl[K] extends (...args: any[]) => Effect.Effect<any, any, infer R> ? R
               : Impl[K] extends Effect.Effect<any, any, infer R> ? R
               : Impl[K] extends (...args: any[]) => Generator<
-                Yieldable<any,any, any, infer R>,
+                Yieldable<any, any, any, infer R>,
                 any,
                 any
               > ? R

package/src/errorReporter.ts

@@ -1,5 +1,5 @@
 import * as Sentry from "@sentry/node"
-import { Cause, Effect, LogLevel } from "effect-app"
+import { Cause, Effect, type LogLevel } from "effect-app"
 import { dropUndefined, LogLevelToSentry } from "effect-app/utils"
 import { getRC } from "./api/setupRequest.js"
 import { CauseException, tryToJson, tryToReport } from "./errors.js"

package/src/fileUtil.ts

@@ -119,7 +119,8 @@ export function withFileLock<A, E, R>(
       // ensure lock is released
       yield* Effect.addFinalizer(() =>
         Effect
-          .tryPromise(release)
+          // we have to make sure we use a thunk, or the library will cause problems because effect passes abortsignal as first argument
+          .tryPromise(() => release())
           .pipe(Effect.orDie)
       )
 

package/src/rateLimit.ts

@@ -56,7 +56,7 @@ export function batchPar<R, E, A, R2, E2, A2, T>(
       (_, i) =>
         Effect
           .forEach(_, (_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
-          .pipe(Effect.flatMap((_) => forEachBatch(_ as NonEmptyArray<A>, i))),
+          .pipe(Effect.flatMap((_) => forEachBatch(_, i))),
       { concurrency: "inherit" }
     )
 }
@@ -72,7 +72,7 @@ export function batch<R, E, A, R2, E2, A2, T>(
       (_, i) =>
         Effect
           .forEach(_, (_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
-          .pipe(Effect.flatMap((_) => forEachBatch(_ as NonEmptyArray<A>, i)))
+          .pipe(Effect.flatMap((_) => forEachBatch(_, i)))
     )
 }
 

package/test/controller.test.ts

@@ -205,7 +205,9 @@ export const middleware3 = MiddlewareMaker
 export const { TaggedRequest: Req } = makeRpcClient(RequestContextMap)
 
 export class Eff extends Req<Eff>()("Eff", {}, { success: S.Void }) {}
-export class Gen extends Req<Gen>()("Gen", {}, { success: S.Void }) {}
+export class Gen extends Req<Gen>()("Gen", {}) {}
+
+expectTypeOf(Eff.error).toEqualTypeOf<typeof Gen.error>()
 
 export class DoSomething extends Req<DoSomething>()("DoSomething", {
   id: S.String
@@ -231,7 +233,7 @@ export class GetSomething extends Req<GetSomething>()("GetSomething", {
 
 export class GetSomething2 extends Req<GetSomething2>()("GetSomething2", {
   id: S.String
-}, { success: S.NumberFromString }) {}
+}, { success: S.FiniteFromString }) {}
 
 const Something = { Eff, Gen, DoSomething, GetSomething, GetSomething2, meta: { moduleName: "Something" as const } }
 

package/test/dist/controller.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAc,MAAM,+BAA+B,CAAA;AAE7F,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAChE,OAAO,EAAoC,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAEvF,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAGtC,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAG3D,OAAO,EAAE,cAAc,EAAsB,YAAY,EAAqB,YAAY,EAAoB,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAY,MAAM,eAAe,CAAA;;cAuE/G,QAAQ;;AADzE,cAAM,kBACJ,SAAQ,uBAA0F;IAElG,MAAM,CAAC,OAAO,uDAUZ;CACH;;AAID,cAAM,GAAI,SAAQ,QAAuC;CAAG;;;;;AAE5D,qBAAa,eAAgB,SAAQ,oBAA4D;IAC/F,MAAM,CAAC,OAAO,2CAUZ;CACH;AAkFD,eAAO,MAAM,WAAW;;;;;;;;;;YAKM,CAAA;AAE9B,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;;;;;;;;;;;;;;;;;;;;AAEtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;AAEtE,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;;;;;;;;;;;;;AAgB1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;;;;AAOtC,qBAAa,gBAAiB,SAAQ,qBASrC;IACC,MAAM,CAAC,OAAO,8CAAgC;CAC/C;;;;;;;;AASD,qBAAa,aAAc,SAAQ,kBASlC;IACC,MAAM,CAAC,OAAO,2CAA8E;CAC7F;;;;;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAOtC;IACC,MAAM,CAAC,OAAO,+CAAgC;CAC/C;AAED,eAAO,MAAQ,MAAM;;;;;SA7KX,CADL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8KkB,QAAQ;;0FAE9B,CAAA;AAED,eAAO,MAAM,EAAE;;;;;;;;;aAjLL,CADL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoLJ,CAAA"}
+{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAc,MAAM,+BAA+B,CAAA;AAE7F,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAChE,OAAO,EAAoC,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAEvF,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAGtC,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAG3D,OAAO,EAAE,cAAc,EAAsB,YAAY,EAAqB,YAAY,EAAoB,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAY,MAAM,eAAe,CAAA;;cAuE/G,QAAQ;;AADzE,cAAM,kBACJ,SAAQ,uBAA0F;IAElG,MAAM,CAAC,OAAO,uDAUZ;CACH;;AAID,cAAM,GAAI,SAAQ,QAAuC;CAAG;;;;;AAE5D,qBAAa,eAAgB,SAAQ,oBAA4D;IAC/F,MAAM,CAAC,OAAO,2CAUZ;CACH;AAkFD,eAAO,MAAM,WAAW;;;;;;;;;;YAKM,CAAA;AAE9B,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;;;;;;;;;;;;;;;;;AAEtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAAqB;CAAG;;;;;;;;;;;;;;;;;;;AAIjD,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;;;;;;;;AAgB1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;;;;AAOtC,qBAAa,gBAAiB,SAAQ,qBASrC;IACC,MAAM,CAAC,OAAO,8CAAgC;CAC/C;;;;;;;;AASD,qBAAa,aAAc,SAAQ,kBASlC;IACC,MAAM,CAAC,OAAO,2CAA8E;CAC7F;;;;;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAOtC;IACC,MAAM,CAAC,OAAO,+CAAgC;CAC/C;AAED,eAAO,MAAQ,MAAM;;;;;SA/KX,CADL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgLkB,QAAQ;;0FAE9B,CAAA;AAED,eAAO,MAAM,EAAE;;;;;;;;;aAnLL,CADL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsLJ,CAAA"}

package/test/dist/rpc-multi-middleware.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc-multi-middleware.test.d.ts","sourceRoot":"","sources":["../rpc-multi-middleware.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,KAAK,EAAU,MAAM,QAAQ,CAAA;AACvD,OAAO,EAAE,CAAC,EAAE,MAAM,YAAY,CAAA;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAGpD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAGhD,OAAO,EAAE,SAAS,EAAkD,MAAM,qBAAqB,CAAA;AAG/F,OAAO,EAAE,cAAc,EAAyC,YAAY,EAA0B,kBAAkB,EAA0B,cAAc,EAAmC,IAAI,EAAY,WAAW,EAAE,MAAM,eAAe,CAAA;AAErP,QAAA,MAAM,UAAU;;;;;;;;;;oCAGmB,CAAA;AAGnC,qBAAa,oBAAqB,SAAQ,UAAU;CAAG;;;;;;;;;;;;AAEvD,cAAM,UAAW,SAAQ,eAKkB;CACzC;AAsCF,eAAO,MAAM,OAAO,+FAMhB,CAAA;AAgBJ,eAAO,MAAM,YAAY,uLAItB,CAAA;AAEH,eAAO,MAAM,YAAY,yIAgByB,CAAA"}
+{"version":3,"file":"rpc-multi-middleware.test.d.ts","sourceRoot":"","sources":["../rpc-multi-middleware.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,KAAK,EAAU,MAAM,QAAQ,CAAA;AACvD,OAAO,EAAE,CAAC,EAAE,MAAM,YAAY,CAAA;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAGpD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAGhD,OAAO,EAAE,SAAS,EAAkD,MAAM,qBAAqB,CAAA;AAG/F,OAAO,EAAE,cAAc,EAAyC,YAAY,EAA0B,kBAAkB,EAA0B,cAAc,EAAmC,IAAI,EAAY,WAAW,EAAE,MAAM,eAAe,CAAA;AAErP,QAAA,MAAM,UAAU;;;;;;;;;;oCAGmB,CAAA;AAGnC,qBAAa,oBAAqB,SAAQ,UAAU;CAAG;;;;;;;;;;;;AAEvD,cAAM,UAAW,SAAQ,eAKkB;CACzC;AAsCF,eAAO,MAAM,OAAO,+FAMhB,CAAA;AAgBJ,eAAO,MAAM,YAAY,uLAItB,CAAA;AAEH,eAAO,MAAM,YAAY,yIAgB2B,CAAA"}

package/test/query.test.ts

@@ -11,7 +11,7 @@ import { memFilter, MemoryStoreLive } from "../src/Store/Memory.js"
 import { SomeService } from "./fixtures.js"
 
 const str = S.Struct({ _tag: S.Literal("string"), value: S.String })
-const num = S.Struct({ _tag: S.Literal("number"), value: S.Number })
+const num = S.Struct({ _tag: S.Literal("number"), value: S.Finite })
 const someUnion = S.Union([str, num])
 
 export class Something extends S.Class<Something>("Something")({
@@ -156,8 +156,6 @@ it("works with repo", () =>
 
       expectTypeOf(smtArr).toEqualTypeOf<readonly Something[]>()
 
-      console.log(" $$$$$$")
-      console.log(Struct.pick(["id", "displayName"]))
       expect(q1).toEqual(items.slice(0, 2).toReversed().map(Struct.pick(["id", "displayName"])))
       expect(q2).toEqual(items.slice(0, 2).toReversed().map(Struct.pick(["displayName"])))
     })
@@ -674,7 +672,7 @@ it("remove null from one constituent of a tagged union", () =>
 
       class BB extends S.Class<BB>("BB")({
         id: S.Literal("BB"),
-        b: S.NullOr(S.Number)
+        b: S.NullOr(S.Finite)
       }) {}
 
       type Union = AA | BB