effect-app 4.0.0-beta.8 → 4.0.0-beta.82

package/src/Schema/numbers.ts

@@ -1,8 +1,9 @@
+import { Effect } from "effect"
 import { extendM } from "effect-app/utils"
 import * as S from "effect/Schema"
 import type { Simplify } from "effect/Types"
 import { fromBrand, nominal } from "./brand.js"
-import { withDefaultConstructor, withDefaultMake } from "./ext.js"
+import { withDefaultMake } from "./ext.js"
 import { type B } from "./schema.js"
 
 export interface PositiveIntBrand
@@ -14,7 +15,7 @@ export const PositiveInt = extendM(
     fromBrand(nominal<PositiveInt>(), { identifier: "PositiveInt", title: "PositiveInt", jsonSchema: {} }),
     withDefaultMake
   ),
-  (s) => ({ withDefault: s.pipe(withDefaultConstructor(() => s(1))) })
+  (s) => ({ withDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => s(1)))) })
 )
 export type PositiveInt = number & PositiveIntBrand
 
@@ -29,20 +30,20 @@ export const NonNegativeInt = extendM(
     }),
     withDefaultMake
   ),
-  (s) => ({ withDefault: s.pipe(withDefaultConstructor(() => s(0))) })
+  (s) => ({ withDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => s(0)))) })
 )
 export type NonNegativeInt = number & NonNegativeIntBrand
 
 export interface IntBrand extends Simplify<B.Brand<"Int">> {}
 export const Int = extendM(
   S.Int.pipe(fromBrand(nominal<Int>(), { identifier: "Int", title: "Int", jsonSchema: {} }), withDefaultMake),
-  (s) => ({ withDefault: s.pipe(withDefaultConstructor(() => s(0))) })
+  (s) => ({ withDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => s(0)))) })
 )
 export type Int = number & IntBrand
 
 export interface PositiveNumberBrand extends Simplify<B.Brand<"PositiveNumber"> & NonNegativeNumberBrand> {}
 export const PositiveNumber = extendM(
-  S.Number.pipe(
+  S.Finite.pipe(
     S.check(S.isGreaterThan(0)),
     fromBrand(nominal<PositiveNumber>(), {
       identifier: "PositiveNumber",
@@ -51,14 +52,14 @@ export const PositiveNumber = extendM(
     }),
     withDefaultMake
   ),
-  (s) => ({ withDefault: s.pipe(withDefaultConstructor(() => s(1))) })
+  (s) => ({ withDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => s(1)))) })
 )
 export type PositiveNumber = number & PositiveNumberBrand
 
 export interface NonNegativeNumberBrand extends Simplify<B.Brand<"NonNegativeNumber">> {}
 export const NonNegativeNumber = extendM(
   S
-    .Number
+    .Finite
     .pipe(
       S.check(S.isGreaterThanOrEqualTo(0)),
       fromBrand(nominal<NonNegativeNumber>(), {
@@ -68,7 +69,7 @@ export const NonNegativeNumber = extendM(
       }),
       withDefaultMake
     ),
-  (s) => ({ withDefault: s.pipe(withDefaultConstructor(() => s(0))) })
+  (s) => ({ withDefault: s.pipe(S.withConstructorDefault(Effect.sync(() => s(0)))) })
 )
 export type NonNegativeNumber = number & NonNegativeNumberBrand
 

package/src/Schema/phoneNumber.ts

@@ -13,12 +13,19 @@ export type PhoneNumber = string & PhoneNumberBrand
 export const PhoneNumber = S
   .String
   .pipe(
+    S.annotate({
+      title: "PhoneNumber",
+      description: "a phone number with at least 7 digits",
+      format: "phone"
+    }),
     S.refine(isValidPhone as Refinement<string, PhoneNumber>, {
       identifier: "PhoneNumber",
       title: "PhoneNumber",
       description: "a phone number with at least 7 digits",
-      arbitrary: () => (fc: any) => Numbers(7, 10)(fc).map((_: any) => _ as PhoneNumber),
       jsonSchema: { format: "phone" }
     }),
+    S.annotate({
+      toArbitrary: () => (fc) => Numbers(7, 10)(fc).map((_) => _ as PhoneNumber)
+    }),
     withDefaultMake
   )

package/src/Schema.ts

@@ -1,22 +1,19 @@
-import { Array, Option, pipe, SchemaAST, type Tracer } from "effect"
+import { SchemaAST, type Tracer } from "effect"
 import * as S from "effect/Schema"
 import type { NonEmptyReadonlyArray } from "./Array.js"
 import { fakerArb } from "./faker.js"
-import { Email as EmailT } from "./Schema/email.js"
+import { Email as EmailT, type Email as EmailType } from "./Schema/email.js"
 import { withDefaultMake } from "./Schema/ext.js"
-import { PhoneNumber as PhoneNumberT } from "./Schema/phoneNumber.js"
-import type { AST } from "./Schema/schema.js"
+import { PhoneNumber as PhoneNumberT, type PhoneNumber as PhoneNumberType } from "./Schema/phoneNumber.js"
 import { extendM } from "./utils.js"
 
 export * from "effect/Schema"
-// v4: TaggedError renamed to TaggedErrorClass
-export { TaggedErrorClass as TaggedError } from "effect/Schema"
 
 export * from "./Schema/Class.js"
 export { Class, TaggedClass } from "./Schema/Class.js"
 
 export { fromBrand, nominal } from "./Schema/brand.js"
-export { Array, Boolean, Date, Literal, Map, NullOr, Number, ReadonlyMap, ReadonlySet } from "./Schema/ext.js"
+export { Array, Boolean, Date, DateFromString, DateValid, Finite, Literals, NullOr, Number, ReadonlyMap, ReadonlySet } from "./Schema/ext.js"
 export { Int, NonNegativeInt } from "./Schema/numbers.js"
 
 export * from "./Schema/email.js"
@@ -25,6 +22,8 @@ export * from "./Schema/moreStrings.js"
 export * from "./Schema/numbers.js"
 export * from "./Schema/phoneNumber.js"
 export * from "./Schema/schema.js"
+export * from "./Schema/SpecialJsonSchema.js"
+export * from "./Schema/SpecialOpenApi.js"
 export * from "./Schema/strings.js"
 export { NonEmptyString } from "./Schema/strings.js"
 
@@ -40,127 +39,104 @@ export interface WithOptionalSpan {
   [SpanId]?: Tracer.Span
 }
 
+const makeEmail = S.decodeSync(EmailT as any) as (value: string) => EmailType
+const makePhoneNumber = S.decodeSync(PhoneNumberT as any) as (value: string) => PhoneNumberType
+
 export const Email = EmailT
   .pipe(
     S.annotate({
       // eslint-disable-next-line @typescript-eslint/unbound-method
-      arbitrary: (): any => (fc: any) => fakerArb((faker) => faker.internet.exampleEmail)(fc).map(Email)
+      toArbitrary: () => (fc) => fakerArb((faker) => faker.internet.exampleEmail)(fc).map(makeEmail)
     }),
     withDefaultMake
   )
 
-export type Email = EmailT
+export type Email = EmailType
 
 export const PhoneNumber = PhoneNumberT
   .pipe(
     S.annotate({
-      arbitrary: (): any => (fc: any) =>
+      toArbitrary: () => (fc) =>
         // eslint-disable-next-line @typescript-eslint/unbound-method
-        fakerArb((faker) => faker.phone.number)(fc).map(PhoneNumber)
+        fakerArb((faker) => faker.phone.number)(fc).map(makePhoneNumber)
     }),
     withDefaultMake
   )
 
-export const makeIs = <A extends { _tag: string }, I, R>(
-  schema: S.Codec<A, I, R>
-) => {
-  // In v4, transformations are stored as encoding on nodes, not as wrapper nodes.
-  // Union member ASTs are directly Objects (TypeLiteral equivalent).
-  if (SchemaAST.isUnion(schema.ast)) {
-    return schema.ast.types.reduce((acc: any, t: AST.AST) => {
-      if (!SchemaAST.isObjects(t)) return acc
-      const tag = Array.findFirst(t.propertySignatures, (_: any) => {
-        if (_.name === "_tag" && SchemaAST.isLiteral(_.type)) {
-          return Option.some(_.type)
-        }
-        return Option.none()
-      })
-      const ast = Option.getOrUndefined(tag)
-      if (!ast) {
-        return acc
-      }
-      return {
-        ...acc,
-        [String((ast as SchemaAST.Literal).literal)]: (x: { _tag: string }) =>
-          x._tag === (ast as SchemaAST.Literal).literal
-      }
-    }, {} as Is<A>)
-  }
-  throw new Error("Unsupported")
-}
+export type PhoneNumber = PhoneNumberType
 
-export const makeIsAnyOf = <A extends { _tag: string }, I, R>(
-  schema: S.Codec<A, I, R>
-): IsAny<A> => {
-  if (SchemaAST.isUnion(schema.ast)) {
-    return <Keys extends A["_tag"][]>(...keys: Keys) => (a: A): a is ExtractUnion<A, ElemType<Keys>> =>
-      keys.includes(a._tag)
-  }
-  throw new Error("Unsupported")
+// Copied from SchemaAST.collectSentinels (marked @internal in effect).
+// Returns all { key, literal } pairs that can discriminate a union member.
+const getTagFromAST = (schema: S.Top): string => {
+  const sentinels = collectSentinelsFromAST(schema.ast)
+  const sentinel = sentinels.find((s) => s.key === "_tag")
+  if (sentinel !== undefined && typeof sentinel.literal === "string") return sentinel.literal
+  throw new Error("No _tag literal found on schema member")
 }
 
-export type ExtractUnion<A extends { _tag: string }, Tags extends A["_tag"]> = Extract<A, Record<"_tag", Tags>>
-export type Is<A extends { _tag: string }> = { [K in A as K["_tag"]]: (a: A) => a is K }
-export type ElemType<A> = A extends Array<infer E> ? E : never
-export interface IsAny<A extends { _tag: string }> {
-  <Keys extends A["_tag"][]>(...keys: Keys): (a: A) => a is ExtractUnion<A, ElemType<Keys>>
+function collectSentinelsFromAST(
+  ast: SchemaAST.AST
+): Array<{ key: PropertyKey; literal: SchemaAST.LiteralValue | symbol }> {
+  switch (ast._tag) {
+    case "Declaration": {
+      const s = ast.annotations?.["~sentinels"]
+      return Array.isArray(s) ? s : []
+    }
+    case "Objects":
+      return ast.propertySignatures.flatMap(
+        (ps): Array<{ key: PropertyKey; literal: SchemaAST.LiteralValue | symbol }> => {
+          const type = ps.type
+          if (!SchemaAST.isOptional(type)) {
+            if (SchemaAST.isLiteral(type)) return [{ key: ps.name, literal: type.literal }]
+            if (SchemaAST.isUniqueSymbol(type)) return [{ key: ps.name, literal: type.symbol }]
+          }
+          return []
+        }
+      )
+    case "Suspend":
+      return collectSentinelsFromAST(ast.thunk())
+    default:
+      return []
+  }
 }
 
-export const taggedUnionMap = <
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Members extends readonly (S.Top & { fields: { _tag: S.tag<string> } })[]
->(
-  self: Members
-) =>
-  self.reduce((acc, key) => {
-    // TODO: v4 migration — PropertySignatureDeclaration removed, need v4 AST traversal
-    const ast = key.fields._tag.ast as any
-    const tag = ((ast.type ?? ast) as SchemaAST.Literal).literal as string // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-    ;(acc as any)[tag] = key as any
-    return acc
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  }, {} as any)
-
 export const tags = <
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Members extends NonEmptyReadonlyArray<(S.Top & { fields: { _tag: S.tag<string> } })>
+  Members extends NonEmptyReadonlyArray<(S.Top & { readonly Type: { readonly _tag: string } })>
 >(
   self: Members
 ) =>
-  S.Literals(self.map((key) => {
-    // TODO: v4 migration — PropertySignatureDeclaration removed, need v4 AST traversal
-    const ast = key.fields._tag.ast as any
-    const tag = ((ast.type ?? ast) as SchemaAST.Literal).literal
-    return tag
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  })) as any
-
-export const ExtendTaggedUnion = <A extends { _tag: string }, I, R>(
-  schema: S.Codec<A, I, R>
-) =>
-  extendM(
-    schema,
-    (_) => ({
-      is: S.is(schema as any),
-      isA: makeIs(_ as any),
-      isAnyOf: makeIsAnyOf(_ as any) /*, map: taggedUnionMap(a) */
-    })
-  )
+  S.Literals(
+    self.map(getTagFromAST) as {
+      [Index in keyof Members]: Members[Index]["Type"]["_tag"]
+    }
+  ) as S.Literals<
+    {
+      [Index in keyof Members]: Members[Index]["Type"]["_tag"]
+    }
+  >
+
+type TaggedUnionMembers = NonEmptyReadonlyArray<
+  S.Top & { readonly Type: { readonly _tag: string } }
+>
+
+type TaggedUnionTags<Members extends TaggedUnionMembers> = S.Literals<
+  {
+    [Index in keyof Members]: Members[Index]["Type"]["_tag"]
+  }
+>
 
-export const TaggedUnion = <
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Members extends readonly (S.Top & { fields: { _tag: S.tag<any> } })[]
->(...a: Members) =>
-  pipe(
-    S.Union(a),
-    (_) =>
-      extendM(_, (_) => ({
-        is: S.is(_ as any),
-        isA: makeIs(_ as any),
-        isAnyOf: makeIsAnyOf(_ as any),
-        tagMap: taggedUnionMap(a),
-        tags: tags(a as any)
-      }))
-  )
+type TaggedUnionWithTags<Members extends TaggedUnionMembers> = S.toTaggedUnion<"_tag", Members> & {
+  readonly tags: TaggedUnionTags<Members>
+}
+
+const extendTaggedUnionWithTags = <Members extends TaggedUnionMembers>(
+  schema: S.Union<Members>
+): TaggedUnionWithTags<Members> => extendM(schema.pipe(S.toTaggedUnion("_tag")), () => ({ tags: tags(schema.members) }))
 
-export type PhoneNumber = PhoneNumberT
+export const ExtendTaggedUnion = <Members extends TaggedUnionMembers>(
+  schema: S.Union<Members>
+): TaggedUnionWithTags<Members> => extendTaggedUnionWithTags(schema)
+
+export const TaggedUnion = <
+  Members extends TaggedUnionMembers
+>(...a: Members): TaggedUnionWithTags<Members> => extendTaggedUnionWithTags(S.Union(a))

package/src/client/apiClientFactory.ts

@@ -1,5 +1,4 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as Config from "effect/Config"
 import { flow } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as ManagedRuntime from "effect/ManagedRuntime"
@@ -7,13 +6,14 @@ import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import * as Struct from "effect/Struct"
 import { Rpc, RpcClient, RpcGroup, RpcSerialization } from "effect/unstable/rpc"
+import * as Config from "../Config.js"
+import * as Context from "../Context.js"
 import * as Effect from "../Effect.js"
 import { HttpClient, HttpClientRequest } from "../http.js"
 import * as Option from "../Option.js"
 import type * as S from "../Schema.js"
-import * as ServiceMap from "../ServiceMap.js"
 import { typedKeysOf, typedValuesOf } from "../utils.js"
-import type { Client, ClientForOptions, Requests, RequestsAny } from "./clientFor.js"
+import type { Client, ClientForOptions, ExtractModuleName, RequestsAny } from "./clientFor.js"
 
 export interface ApiConfig {
   url: string
@@ -37,10 +37,12 @@ export type Req = S.Top & {
   success: S.Top
   error: S.Top
   config?: Record<string, any>
+  readonly id: string
+  readonly moduleName: string
   readonly "~decodingServices"?: unknown
 }
 
-class RequestName extends ServiceMap.Reference("RequestName", {
+class RequestName extends Context.Reference("RequestName", {
   defaultValue: () => ({ requestName: "Unspecified", moduleName: "Error" })
 }) {}
 
@@ -56,10 +58,11 @@ export const HttpClientLayer = (config: ApiConfig) =>
             HttpClientRequest.setHeaders(config.headers.pipe(Option.getOrElse(() => ({}))))
           ),
           HttpClient.mapRequestEffect((req) =>
-            Effect.map(RequestName.asEffect(), ctx => flow(
-              HttpClientRequest.appendUrlParam("action", ctx.requestName),
-              HttpClientRequest.appendUrl("/" + ctx.moduleName)
-            )(req))
+            Effect.map(RequestName.asEffect(), (ctx) =>
+              flow(
+                HttpClientRequest.appendUrlParam("action", ctx.requestName),
+                HttpClientRequest.appendUrl("/" + ctx.moduleName)
+              )(req))
           )
         )
         return client
@@ -75,7 +78,7 @@ export const HttpClientFromConfigLayer = Layer.unwrap(
 
 export const RpcSerializationLayer = (config: ApiConfig) =>
   Layer.mergeAll(
-    RpcSerialization.layerJson,
+    RpcSerialization.layerNdjson,
     HttpClientLayer(config)
   )
 
@@ -83,7 +86,7 @@ type RpcHandlers<M extends RequestsAny> = {
   [K in keyof M]: Rpc.Rpc<M[K]["_tag"], M[K], M[K]["success"], M[K]["error"]>
 }
 
-const getFiltered = <M extends Requests>(resource: M) => {
+const getFiltered = <M extends RequestsAny>(resource: M) => {
   type Filtered = {
     [K in keyof M as M[K] extends Req ? K : never]: M[K] extends Req ? M[K] : never
   }
@@ -101,13 +104,13 @@ const getFiltered = <M extends Requests>(resource: M) => {
   return filtered as unknown as Filtered
 }
 
-export const getMeta = <M extends Requests>(resource: M) => {
-  const meta = (resource as any).meta as { moduleName: string }
-  if (!meta) throw new Error("No meta defined in Resource!")
-  return meta as M["meta"]
+export const getMeta = <M extends RequestsAny>(resource: M): { moduleName: ExtractModuleName<M> } => {
+  const first = typedValuesOf(getFiltered(resource))[0]
+  if (first && "moduleName" in first) return { moduleName: first.moduleName } as any
+  throw new Error("No moduleName on requests!")
 }
 
-export const makeRpcGroupFromRequestsAndModuleName = <M extends Requests, const ModuleName extends string>(
+export const makeRpcGroupFromRequestsAndModuleName = <M extends RequestsAny, const ModuleName extends string>(
   resource: M,
   moduleName: ModuleName
 ) => {
@@ -125,20 +128,13 @@ export const makeRpcGroupFromRequestsAndModuleName = <M extends Requests, const
   return rpcs
 }
 
-export const makeRpcGroup = <
-  M extends Requests,
-  const ModuleName extends string
->(
-  resource: M & { meta: { moduleName: ModuleName } }
-) => makeRpcGroupFromRequestsAndModuleName(resource, resource.meta.moduleName)
-
-const makeRpcTag = <M extends Requests>(resource: M) => {
+const makeRpcTag = <M extends RequestsAny>(resource: M) => {
   const meta = getMeta(resource)
   const rpcs = makeRpcGroupFromRequestsAndModuleName(resource, meta.moduleName)
 
   // Use Object.assign instead of class extension to avoid TS2509 with complex generic return types.
   // The first type arg is `any` because this is a dynamically created tag — its identity is the string key.
-  const TheClient = ServiceMap.Opaque<
+  const TheClient = Context.Opaque<
     any,
     RpcClient.RpcClient<RpcGroup.Rpcs<typeof rpcs>>
   >()(`RpcClient.${meta.moduleName}`)
@@ -152,8 +148,8 @@ const makeRpcTag = <M extends Requests>(resource: M) => {
 
 const makeApiClientFactory = Effect
   .gen(function*() {
-    const ctx = yield* Effect.services<RpcSerialization.RpcSerialization | HttpClient.HttpClient>()
-    const makeClientFor = <M extends Requests>(
+    const ctx = yield* Effect.context<RpcSerialization.RpcSerialization | HttpClient.HttpClient>()
+    const makeClientFor = <M extends RequestsAny>(
       resource: M,
       requestLevelLayers = Layer.empty,
       options?: ClientForOptions
@@ -175,7 +171,7 @@ const makeApiClientFactory = Effect
                 url: "" // why not here set meta.moduleName as root?
               })
               .pipe(
-                Layer.provideMerge(Layer.succeedServices(ctx))
+                Layer.provideMerge(Layer.succeedContext(ctx))
               )
           )
         )
@@ -184,7 +180,7 @@ const makeApiClientFactory = Effect
         const filtered = getFiltered(resource)
         return {
           mr,
-          client: (typedKeysOf(filtered)
+          client: typedKeysOf(filtered)
             .reduce((prev, cur) => {
               const h = filtered[cur]!
 
@@ -211,7 +207,7 @@ const makeApiClientFactory = Effect
               // @ts-expect-error doc
               prev[cur] = Object.keys(fields).length === 0
                 ? {
-                  handler: mr.servicesEffect.pipe(
+                  handler: mr.contextEffect.pipe(
                     Effect.flatMap((svcs) =>
                       TheClient
                         .use((client) => (client as any)[requestAttr]!(new Request()) as Effect.Effect<any, any, never>)
@@ -225,7 +221,7 @@ const makeApiClientFactory = Effect
                 }
                 : {
                   handler: (req: any) =>
-                    mr.servicesEffect.pipe(
+                    mr.contextEffect.pipe(
                       Effect.flatMap((svcs) =>
                         TheClient
                           .use((client) =>
@@ -242,7 +238,7 @@ const makeApiClientFactory = Effect
                 }
 
               return prev
-            }, {} as Client<M, M["meta"]["moduleName"]>))
+            }, {} as Client<M, ExtractModuleName<M>>)
         }
       })
 
@@ -258,9 +254,9 @@ const makeApiClientFactory = Effect
         cacheL.set(requestLevelLayers, cache)
       }
 
-      return <M extends Requests>(
+      return <M extends RequestsAny>(
         models: M
-      ): Effect.Effect<Client<M, M["meta"]["moduleName"]>> =>
+      ): Effect.Effect<Client<M, ExtractModuleName<M>>> =>
         Effect.gen(function*() {
           const found = cache.get(models)
           if (found) {
@@ -280,7 +276,7 @@ const makeApiClientFactory = Effect
  * Used to create clients for resource modules.
  */
 export class ApiClientFactory
-  extends ServiceMap.Opaque<ApiClientFactory, Effect.Success<typeof makeApiClientFactory>>()("ApiClientFactory")
+  extends Context.Opaque<ApiClientFactory, Effect.Success<typeof makeApiClientFactory>>()("ApiClientFactory")
 {
   static readonly layer = (config: ApiConfig) =>
     ApiClientFactory.toLayer(makeApiClientFactory).pipe(Layer.provide(RpcSerializationLayer(config)))
@@ -293,7 +289,7 @@ export class ApiClientFactory
 
   static readonly makeFor =
     (requestLevelLayers: Layer.Layer<never, never, never>, options?: ClientForOptions) =>
-    <M extends Requests>(
+    <M extends RequestsAny>(
       resource: M
     ) =>
       ApiClientFactory.use((apiClientFactory) => {

package/src/client/clientFor.ts

@@ -48,9 +48,14 @@ export function makePathWithBody(
   return path.build(pars, { ignoreSearch: true, ignoreConstraints: true })
 }
 
-export type Requests<ModuleName extends string = string> = { meta: { moduleName: ModuleName } } & RequestsAny
+export type Requests = RequestsAny
 export type RequestsAny = Record<string, any>
 
+export type ExtractModuleName<M extends RequestsAny> =
+  { [K in keyof M]: M[K] extends { moduleName: infer N extends string } ? N : never }[keyof M] extends
+    infer R extends string ? R
+    : string
+
 export type Client<M extends RequestsAny, ModuleName extends string> = RequestHandlers<
   never,
   never,