effect-app 4.0.0-beta.17 → 4.0.0-beta.170

package/src/rpc/MiddlewareMaker.ts

@@ -1,11 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Layer, type Schema, Schema as S, type Scope, ServiceMap } from "effect"
+import { Effect, Layer, type Schema, Schema as S, type Scope } from "effect"
 import { type NonEmptyArray, type NonEmptyReadonlyArray } from "effect/Array"
 import { type Simplify } from "effect/Types"
 import { Rpc, type RpcGroup, type RpcSchema } from "effect/unstable/rpc"
 import { type HandlersFrom } from "effect/unstable/rpc/RpcGroup"
-import { type RequestId } from "effect/unstable/rpc/RpcMessage"
-import { type HttpHeaders } from "../http.js"
+import * as Context from "../Context.js"
 import { PreludeLogger } from "../logger.js"
 import { type TypeTestId } from "../TypeTest.js"
 import { typedValuesOf } from "../utils.js"
@@ -61,13 +60,13 @@ export interface MiddlewareMaker<
     }
   >
 {
-  readonly layer: Layer.Layer<Self, never, ServiceMap.Service.Identifier<MiddlewareProviders[number]>>
+  readonly layer: Layer.Layer<Self, never, Context.Service.Identifier<MiddlewareProviders[number]>>
   readonly requestContext: RequestContextTag<RequestContextMap>
   readonly requestContextMap: RequestContextMap
 }
 
 export interface RequestContextTag<RequestContextMap extends Record<string, RpcContextMap.Any>>
-  extends ServiceMap.Service<"RequestContextConfig", GetContextConfig<RequestContextMap>>
+  extends Context.Service<"RequestContextConfig", GetContextConfig<RequestContextMap>>
 {}
 
 export namespace MiddlewareMaker {
@@ -258,10 +257,10 @@ export type MiddlewaresBuilder<
     : { new(_: never): {} }
     : { new(_: never): {} })
 
-const middlewareMaker = <
+const middlewareMaker = Effect.fnUntraced(function*<
   MiddlewareProviders extends ReadonlyArray<MiddlewareMaker.Any>
->(middlewares: MiddlewareProviders): Effect.Effect<
-  RpcMiddlewareV4<
+>(middlewares: MiddlewareProviders) {
+  type Middleware = RpcMiddlewareV4<
     MiddlewareMaker.ManyProvided<MiddlewareProviders>,
     MiddlewareMaker.ManyErrors<MiddlewareProviders>,
     Exclude<
@@ -270,42 +269,32 @@ const middlewareMaker = <
     > extends never ? never
       : Exclude<MiddlewareMaker.ManyRequired<MiddlewareProviders>, MiddlewareMaker.ManyProvided<MiddlewareProviders>>
   >
-> => {
+  type Next = Parameters<Middleware>[0]
+  type Options = Parameters<Middleware>[1]
+
   // we want to run them in reverse order because latter middlewares will provide context to former ones
-  middlewares = middlewares.toReversed() as any
-
-  return Effect.gen(function*() {
-    const context = yield* Effect.services()
-
-    // returns a Effect/RpcMiddlewareV4 with Scope.Scope in requirements
-    // v4: wrap middleware takes (effect, options) as two params instead of a single options bag
-    return (
-      next: Effect.Effect<any, any, any>,
-      options: {
-        readonly clientId: number
-        readonly requestId: RequestId
-        readonly rpc: Rpc.AnyWithProps
-        readonly payload: unknown
-        readonly headers: HttpHeaders.Headers
-      }
-    ) => {
-      // we start with the actual handler
-      let handler = next
-
-      // inspired from Effect/RpcMiddleware
-      for (const tag of middlewares) {
-        // use the tag to get the middleware from context
-        const middleware = ServiceMap.getUnsafe(context, tag)
-
-        // wrap the current handler, allowing the middleware to run before and after it
-        handler = PreludeLogger.logDebug("Applying middleware wrap " + tag.key).pipe(
-          Effect.andThen(middleware(handler, options))
-        ) as any
-      }
-      return handler
+  const reversed = middlewares.toReversed()
+  const context = yield* Effect.context()
+
+  // returns a Effect/RpcMiddlewareV4 with Scope.Scope in requirements
+  // v4: wrap middleware takes (effect, options) as two params instead of a single options bag
+  return (next: Next, options: Options) => {
+    // we start with the actual handler
+    let handler = next
+
+    // inspired from Effect/RpcMiddleware
+    for (const tag of reversed) {
+      // use the tag to get the middleware from context
+      const middleware = Context.getUnsafe(context, tag)
+
+      // wrap the current handler, allowing the middleware to run before and after it
+      handler = PreludeLogger.logDebug("Applying middleware wrap " + tag.key).pipe(
+        Effect.andThen(middleware(handler, options))
+      ) as any
     }
-  }) as any
-}
+    return handler
+  }
+})
 
 const makeMiddlewareBasic = <Self>() =>
 // by setting RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
@@ -321,7 +310,7 @@ const makeMiddlewareBasic = <Self>() =>
   // reverse middlewares and wrap one after the other
   const middleware = middlewareMaker(make)
 
-  const failures = make.map((_) => _.error).filter(Boolean)
+  const failures = make.flatMap((_) => _.error ? [_.error] : [])
   const provides = make.flatMap((_) => !_.provides ? [] : Array.isArray(_.provides) ? _.provides : [_.provides])
   const requires = make
     .flatMap((_) => !_.requires ? [] : Array.isArray(_.requires) ? _.requires : [_.requires])
@@ -367,7 +356,7 @@ const makeMiddlewareBasic = <Self>() =>
   return Object.assign(MiddlewareMaker, {
     layer,
     // tag to be used to retrieve the RequestContextConfig from Rpc annotations
-    requestContext: ServiceMap.Service<"RequestContextConfig", GetContextConfig<RequestContextMap>>(
+    requestContext: Context.Service<"RequestContextConfig", GetContextConfig<RequestContextMap>>(
       "RequestContextConfig"
     ),
     requestContextMap: rcm
@@ -379,8 +368,8 @@ export const Tag = <Self>() =>
   const Id extends string,
   RequestContextMap extends RequestContextMapTagAny
 >(id: Id, rcm: RequestContextMap): MiddlewaresBuilder<Self, Id, RequestContextMap["config"]> => {
-  let allMiddleware: MiddlewareMaker.Any[] = []
-  const requestContext = ServiceMap.Service<"RequestContextConfig", GetContextConfig<RequestContextMap["config"]>>(
+  const allMiddleware: MiddlewareMaker.Any[] = []
+  const requestContext = Context.Service<"RequestContextConfig", GetContextConfig<RequestContextMap["config"]>>(
     "RequestContextConfig"
   )
   const it = {
@@ -437,7 +426,7 @@ export const Tag = <Self>() =>
     middleware: (...middlewares: any[]) => {
       for (const mw of middlewares) {
         // recall that we run middlewares in reverse order
-        allMiddleware = [mw, ...allMiddleware]
+        allMiddleware.unshift(mw)
       }
       return allMiddleware.filter((m) => !!m.dynamic).length !== Object.keys(rcm.config).length
         // for sure, until all the dynamic middlewares are provided it's non sensical to call makeMiddlewareBasic

package/src/rpc/README.md

@@ -3,7 +3,7 @@
 The extensions use V4 format of RPC middleware:
 
 - supports `requires` besides `provides`
-- `requires` and `provides`  should be set as second generic argument: `Tag<Self, Config>`.
+- `requires` and `provides` should be set as second generic argument: `Tag<Self, Config>`.
 - `wrap: true` is the default, there is no classic `provides: Tag`
 
 ## Features
@@ -34,7 +34,7 @@ NOTE: perhaps not as useful anymore if support for dynamic middleware gets integ
 
 ## Examples
 
-See  [tests](../../../infra/test/rpc-multi-middleware.test.ts)
+See [tests](../../../infra/test/rpc-multi-middleware.test.ts)
 
 ## Future
 

package/src/rpc/RpcContextMap.ts

@@ -2,14 +2,15 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { type Schema as S, ServiceMap } from "effect"
+import { type Schema as S } from "effect"
 import { type AnyWithProps } from "effect/unstable/rpc/Rpc"
+import * as Context from "../Context.js"
 import { type RpcDynamic } from "./RpcMiddleware.js"
 
 type Values<T extends Record<any, any>> = T[keyof T]
 
 /**
- * Middleware is inactivate by default, the Key is optional in route context, and the service is optionally provided as Effect ServiceMap.
+ * Middleware is inactivate by default, the Key is optional in route context, and the service is optionally provided as Effect Context.
  * Unless explicitly configured as `true`.
  */
 export type RpcContextMap<Service, E> = {
@@ -22,7 +23,7 @@ export type RpcContextMap<Service, E> = {
 
 export declare namespace RpcContextMap {
   /**
-   * Middleware is active by default, and provides the Service at Key in route context, and the Service is provided as Effect ServiceMap.
+   * Middleware is active by default, and provides the Service at Key in route context, and the Service is provided as Effect Context.
    * Unless explicitly omitted.
    */
   export type Inverted<Service, E> = {
@@ -97,7 +98,7 @@ export type GetEffectError<RequestContextMap extends Record<string, RpcContextMa
   }
 >
 
-const tag = ServiceMap.Service("RequestContextConfig")
+const tag = Context.Service("RequestContextConfig")
 
 export const makeMap = <const Config extends Record<string, RpcContextMap.Any>>(config: Config) => {
   const cls = class {
@@ -109,7 +110,7 @@ export const makeMap = <const Config extends Record<string, RpcContextMap.Any>>(
   return Object.assign(cls, {
     config, /** Retrieves RequestContextConfig out of the Rpc annotations */
     getConfig: (rpc: AnyWithProps): GetContextConfig<Config> => {
-      return ServiceMap.getOrElse(rpc.annotations, tag as any, () => ({}))
+      return Context.getOrElse(rpc.annotations, tag as any, () => ({}))
     },
     /** Adapter used when setting the dynamic prop on a middleware implementation */
     get: <

package/src/rpc/RpcMiddleware.ts

@@ -1,10 +1,11 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { type Effect, type Schema, type Schema as S, type Scope, type ServiceMap, type Stream } from "effect"
+import { type Effect, type Schema, type Schema as S, type Scope, type Stream } from "effect"
 import { type NonEmptyReadonlyArray } from "effect/Array"
 import { type Rpc, RpcMiddleware } from "effect/unstable/rpc"
 import { type TypeId } from "effect/unstable/rpc/RpcMiddleware"
+import type * as Context from "../Context.js"
 import { type GetEffectContext, type RpcContextMap } from "./RpcContextMap.js"
 
 export type RpcMiddlewareV4<Provides, E, Requires> = RpcMiddleware.RpcMiddleware<Provides, E, Requires>
@@ -102,8 +103,8 @@ export declare namespace TagClass {
       requires?: any
       provides?: any
     }
-  > extends ServiceMap.Service<Self, Service> {
-    new(_: never): ServiceMap.ServiceClass.Shape<Name, Service>
+  > extends Context.Service<Self, Service> {
+    new(_: never): Context.ServiceClass.Shape<Name, Service>
     readonly [TypeId]: TypeId
     readonly optional: Optional<Options>
     readonly error: FailureSchema<Options>
@@ -226,7 +227,7 @@ export type ExtractProvides<R extends Rpc.Any, Tag extends string> = R extends
   Rpc.Rpc<Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware, infer _Requires> ? _Middleware extends {
     readonly provides: infer _P
   } ? [_P] extends [never] ? never
-    : _P /*_P extends ServiceMap.Service<infer _I, infer _S> ? _I
+    : _P /*_P extends Context.Service<infer _I, infer _S> ? _I
     : never */
   : never
   : never

package/src/rpc.ts

@@ -1,4 +1,3 @@
-export * as RpcX from "./rpc.js"
 export * as MiddlewareMaker from "./rpc/MiddlewareMaker.js"
 export * as RpcContextMap from "./rpc/RpcContextMap.js"
 export * as RpcMiddleware from "./rpc/RpcMiddleware.js"

package/src/transform.ts

@@ -51,8 +51,8 @@ const encodeOptsAsNullable_ = (value: any, cacheMap: Map<any, any>): any => {
 
   if (
     value instanceof Date
-    || value instanceof Function
-    || value instanceof Promise
+    || typeof value === "function"
+    || (typeof value === "object" && value !== null && "then" in value && typeof value.then === "function")
   ) {
     return value
   }

package/src/utils/gen.ts

@@ -15,7 +15,7 @@ export namespace EffectGenUtils {
     : EG extends (..._: infer _3) => Generator<Yieldable<any, infer _, infer E, infer _R>, infer _A, infer _2> ? E
     : never
 
-  export type ServiceMap<EG> = EG extends Effect<infer _A, infer _E, infer R> ? R
+  export type Context<EG> = EG extends Effect<infer _A, infer _E, infer R> ? R
     // there could be a case where the generator function does not yield anything, so we need to handle that
     : EG extends (..._: infer _3) => Generator<never, infer _A, infer _2> ? never
     // v4: generators can yield Yieldable (Effect, Service, etc.), all have asEffect()

package/src/utils/logger.ts

@@ -2,11 +2,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { Effect, type LogLevel } from "effect"
-import * as ServiceMap from "../ServiceMap.js"
+import * as Context from "../Context.js"
 
 type Levels = "info" | "debug" | "warn" | "error"
 
-export class LogLevels extends ServiceMap.Reference("LogLevels", {
+export class LogLevels extends Context.Reference("LogLevels", {
   defaultValue: () => new Map<string, Levels>()
 }) {}
 

package/src/utils.ts

@@ -269,7 +269,7 @@ export type EnforceNonEmptyRecord<R> = keyof R extends never ? never : R
 export function intersect<AS extends unknown[] & { 0: unknown }>(
   ...as: AS
 ): UnionToIntersection<{ [k in keyof AS]: AS[k] }[number]> {
-  return as.reduce((a: any, b: any) => ({ ...a, ...b })) as any
+  return as.reduce((a: any, b: any) => Object.assign(a, b), {}) as any
 }
 
 export type IsEqualTo<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
@@ -280,8 +280,7 @@ export type IsEqualTo<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
 export const unifyIndex = Symbol()
 export type unifyIndex = typeof unifyIndex
 
-// @ts-expect-error abc
-export interface UnifiableIndexed<X> {}
+export interface UnifiableIndexed<_X> {}
 export type UnifiableIndexedURI = keyof UnifiableIndexed<any>
 
 export interface Unifiable<X> {
@@ -313,9 +312,7 @@ function decorateNew(
   if (out.descriptor) {
     out.descriptor = Object.assign({}, out.descriptor)
   }
-  const actualDesc: PropertyDescriptor = <any> (
-    out.descriptor || /* istanbul ignore next */ out
-  )
+  const actualDesc: PropertyDescriptor = out.descriptor || /* istanbul ignore next */ out
 
   const originalMethod = validateAndExtractMethodFromDescriptor(actualDesc)
   const isStatic = inp.placement === "static"
@@ -684,7 +681,7 @@ export type OptPromise<T extends () => any> = (
 ) => Promise<ReturnType<T>> | ReturnType<T>
 
 export function access<T extends string, T2>(t: Record<T, T2>) {
-  return (key: T) => t[key] as T2
+  return (key: T) => t[key]
 }
 
 export function todayAtUTCNoon() {
@@ -736,25 +733,64 @@ export const copy = dual<
   }
 >(2, <A>(self: A, f: Partial<A> | ((a: A) => Partial<A>)) => clone(self, { ...self, ...(isFunction(f) ? f(self) : f) }))
 
-type CopyOriginU<U, Ctor extends new(...args: any[]) => any> =
+export type CopyOriginU<U, Ctor extends new(...args: any[]) => any> =
   & {
     [K in keyof U & keyof InstanceType<Ctor>]?: U[K]
   }
   & {}
 
-type CopyOriginRet<A, U> =
+export type CopyOriginRet<A, U> =
   & {
     [K in keyof A | keyof U]: K extends keyof U ? U[K] : A[K & keyof A]
   }
   & {}
 
-type CopyOriginSelf<A, U> = Equals<{}, U> extends true
+export type CopyOriginSelf<A, U> = Equals<{}, U> extends true
   ? Equals<keyof {}, keyof U> extends true ? `updates argument is empty or contains only extra properties`
   : A
   : A
 
+export interface StructuralCopyOrigin<Self extends object> {
+  <A extends Self, U extends Partial<Self>>(
+    f: (a: A) =>
+      & {
+        [K in keyof U & keyof Self]?: U[K]
+      }
+      & {}
+  ): (self: CopyOriginSelf<A, U>) => CopyOriginRet<A, U>
+  <A extends Self, U extends Partial<Self>>(
+    updates:
+      & {
+        [K in keyof U & keyof Self]?: U[K]
+      }
+      & {}
+  ): (self: CopyOriginSelf<A, U>) => CopyOriginRet<A, U>
+  <A extends Self, U extends Partial<Self>>(
+    self: CopyOriginSelf<A, U>,
+    f: (a: A) =>
+      & {
+        [K in keyof U & keyof Self]?: U[K]
+      }
+      & {}
+  ): CopyOriginRet<A, U>
+  <A extends Self, U extends Partial<Self>>(
+    self: CopyOriginSelf<A, U>,
+    updates:
+      & {
+        [K in keyof U & keyof Self]?: U[K]
+      }
+      & {}
+  ): CopyOriginRet<A, U>
+}
+
 // just one input param: the convention is that the ctor takes an object
-// containing the properties of the class (I can't put object there as type because of contravariance)
+// containing the properties of the value (I can't put object there as type because of contravariance)
+/**
+ * By design this does not return `Self` directly.
+ *
+ * The return type is computed from `Self` and the update payload so callers can
+ * expose an explicit structural return type that remains assignable to `Self`.
+ */
 export const copyOrigin = <Ctor extends new(_: any) => any>(ctor: Ctor) =>
   dual<
     {

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

@@ -1 +1 @@
-{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACrF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIL,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}
+{"version":3,"file":"rpc.test.d.ts","sourceRoot":"","sources":["../rpc.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAiB,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAErF,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAE7C,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKL,qBAAa,KAAM,SAAQ,UAQzB;CAAG"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"secretURL.test.d.ts","sourceRoot":"","sources":["../secretURL.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1 @@
+{"version":3,"file":"special.test.d.ts","sourceRoot":"","sources":["../special.test.ts"],"names":[],"mappings":""}

package/test/rpc.test.ts

@@ -1,4 +1,7 @@
+import { type Effect, type Option } from "effect"
+import { expect, test } from "vitest"
 import { makeRpcClient, NotLoggedInError, UnauthorizedError } from "../src/client.js"
+import { ForceVoid } from "../src/client/makeClient.js"
 import { S } from "../src/index.js"
 import { RpcContextMap } from "../src/rpc.js"
 
@@ -8,16 +11,45 @@ export class RequestContextMap extends RpcContextMap.makeMap({
   test: RpcContextMap.make()(S.Never)
 }) {}
 
-const { TaggedRequest } = makeRpcClient(RequestContextMap)
+const { TaggedRequestFor } = makeRpcClient(RequestContextMap)
+const TaggedRequest = TaggedRequestFor("Test").Query
 
 export class Stats extends TaggedRequest<Stats>()("Stats", {}, {
   allowedRoles: ["manager"],
   success: {
-    usersActive24Hours: S.Number,
-    usersActiveLastWeek: S.Number,
-    newUsersLast24Hours: S.Number,
-    newUsersLastWeek: S.Number
+    usersActive24Hours: S.Finite,
+    usersActiveLastWeek: S.Finite,
+    newUsersLast24Hours: S.Finite,
+    newUsersLastWeek: S.Finite
   }
 }) {}
 
-declare const _stats: typeof Stats.success.Type
+declare const _stats: typeof Stats.Type
+declare const _statsSuccess: typeof Stats.success.Type
+declare const _statsError: typeof Stats.error.Type
+declare const _statsRequestType: typeof Stats.type
+
+test("ForceVoid decodes and encodes as void", () => {
+  const statsFromMake = Stats.make({})
+  const statsFromMakeOption = Stats.makeOption({})
+  const statsFromMakeEffect = Stats.makeEffect({})
+
+  expect(S.decodeUnknownSync(ForceVoid)(undefined)).toBe(undefined)
+  expect(S.is(ForceVoid)(undefined)).toBe(true)
+  expect(S.decodeUnknownSync(ForceVoid)("test")).toBe(undefined)
+  expect(S.is(ForceVoid)("test")).toBe(true)
+  expect(S.encodeUnknownSync(ForceVoid)("test")).toBe(undefined)
+  expect(S.encodeUnknownSync(S.toCodecJson(ForceVoid))("test")).toBe(null)
+  expectTypeOf<typeof _stats>().toEqualTypeOf<Stats>()
+  expectTypeOf<typeof _statsSuccess>().toEqualTypeOf<{
+    readonly usersActive24Hours: number
+    readonly usersActiveLastWeek: number
+    readonly newUsersLast24Hours: number
+    readonly newUsersLastWeek: number
+  }>()
+  expectTypeOf<typeof _statsError>().toEqualTypeOf<NotLoggedInError | UnauthorizedError>()
+  expectTypeOf<typeof _statsRequestType>().toEqualTypeOf<"query">()
+  expectTypeOf(statsFromMake).toEqualTypeOf<Stats>()
+  expectTypeOf(statsFromMakeOption).toEqualTypeOf<Option.Option<Stats>>()
+  expectTypeOf(statsFromMakeEffect).toEqualTypeOf<Effect.Effect<Stats, S.SchemaError>>()
+})