effect-app 4.0.0-beta.320 → 4.0.0-beta.322

package/src/Model/query/new-kid-interpreter.ts

@@ -1,7 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import { identity, pipe } from "effect/Function"
-import * as Match from "effect/Match"
+import { identity } from "effect/Function"
 import * as Array from "../../Array.ts"
 import { toNonEmptyArray } from "../../Array.ts"
 import * as Option from "../../Option.ts"
@@ -192,197 +191,204 @@ const interpret = <
       ? { ..._, path: `${path}.-1.${_.path}` }
       : { ..._, result: _.result.map(applyPath(path)) }
 
-  pipe(
-    a,
-    Match.valueTags({
-      value: () => {
-        // data.filter.push(value)
-      },
-      where: ({ current, operation, relation, subPath }) => {
-        upd(interpret(current))
-        if (typeof operation === "function") {
-          data.filter.push(
-            {
-              t: "where-scope",
-              result: interpret(operation(make())).filter.map(subPath ? applyPath(subPath) : identity),
-              relation
-            }
-          )
-        } else {
-          data.filter.push(
-            {
-              t: "where",
-              path: operation[0],
-              op: operation.length === 2 ? "eq" : operation[1],
-              value: operation.length === 2 ? operation[1] : operation[2]
-            }
-          )
-        }
-      },
-      and: ({ current, operation, relation }) => {
-        upd(interpret(current))
-        if (typeof operation === "function") {
-          data.filter.push(
-            { t: "and-scope", result: interpret(operation(make())).filter, relation }
-          )
-        } else {
-          data.filter.push(
-            {
-              t: "and",
-              path: operation[0],
-              op: operation.length === 2 ? "eq" : operation[1],
-              value: operation.length === 2 ? operation[1] : operation[2]
-            }
-          )
-        }
-      },
-      or: ({ current, operation, relation }) => {
-        upd(interpret(current))
-        if (typeof operation === "function") {
-          data.filter.push(
-            { t: "or-scope", result: interpret(operation(make())).filter, relation }
-          )
-        } else {
-          data.filter.push(
-            {
-              t: "or",
-              path: operation[0],
-              op: operation.length === 2 ? "eq" : operation[1],
-              value: operation.length === 2 ? operation[1] : operation[2]
-            }
-          )
-        }
-      },
-      one: ({ current }) => {
-        upd(interpret(current))
-        data.limit = 1
-        data.ttype = "one"
-      },
-      count: ({ current }) => {
-        upd(interpret(current))
-        data.ttype = "count"
-        data.schema = S.Struct({ id: S.String }) as any
-      },
-      order: ({ current, direction, field }) => {
-        upd(interpret(current))
-        data.order.push({ key: field, direction })
-      },
-      page: (v) => {
-        upd(interpret(v.current))
-        data.limit = v.take
-        data.skip = v.skip
-      },
-      project: (v) => {
-        upd(interpret(v.current))
-        if (v.mode === "aggregate" && v.aggregateMap) {
-          data.schema = v.schema
-          data.mode = "aggregate"
-          data.aggregateMap = Object.fromEntries(
-            Object.entries(v.aggregateMap).map(([key, expression]) => {
-              switch (expression._tag) {
-                case "agg-field":
-                  return [key, { _tag: "agg-field" as const, path: expression.path }]
-                case "agg-count":
-                  return [key, { _tag: "agg-count" as const }]
-                case "agg-count-when": {
-                  const filter = interpret(expression.operation(make())).filter
-                  return [key, { _tag: "agg-count-when" as const, filter }]
-                }
-                case "agg-sum":
-                  return [key, { _tag: "agg-sum" as const, field: expression.field }]
-                case "agg-min":
-                  return [key, { _tag: "agg-min" as const, field: expression.field }]
-                case "agg-max":
-                  return [key, { _tag: "agg-max" as const, field: expression.field }]
-              }
-            })
-          )
-          return
-        }
-        if (v.computed && v.mode === "transform") {
-          throw new Error("Computed projections require mode 'project' or 'collect', not 'transform'")
-        }
-        data.schema = v.schema
-        data.mode = v.computed
-          ? v.mode === "collect" ? "collect" : "project"
-          : v.mode
-        data.computed = v.computed
-          ? Object.fromEntries(
-            Object.entries(v.computed).map(([key, expression]) => {
-              const e = expression
-              const op = "operation" in e ? e.operation : undefined
-              const filter = op ? interpret(op(make())).filter.map(applyPath(e.path)) : []
-              switch (e._tag) {
-                case "relation-count":
-                case "relation-any":
-                case "relation-every":
-                  return [key, { _tag: e._tag, path: e.path, filter }]
-                case "relation-distinct-count":
-                case "relation-sum":
-                  return [
-                    key,
-                    { _tag: e._tag, path: e.path, field: e.field, filter }
-                  ]
-                case "relation-sum-expr":
-                  return [
-                    key,
-                    { _tag: e._tag, path: e.path, expression: e.expression, filter }
-                  ]
-                case "relation-sum-expr-by":
-                  return [
-                    key,
-                    {
-                      _tag: e._tag,
-                      path: e.path,
-                      expression: e.expression,
-                      unit: e.unit,
-                      filter
-                    }
-                  ]
-                case "relation-sum-expr-normalized":
-                  return [
-                    key,
-                    {
-                      _tag: e._tag,
-                      path: e.path,
-                      expression: e.expression,
-                      unit: e.unit,
-                      toBase: e.toBase,
-                      factors: e.factors,
-                      filter
-                    }
-                  ]
-                case "relation-collect":
-                  return [
-                    key,
-                    {
-                      _tag: e._tag,
-                      path: e.path,
-                      field: e.field,
-                      distinct: e.distinct,
-                      filter
-                    }
-                  ]
-                case "relation-collect-fields":
-                  return [
-                    key,
-                    {
-                      _tag: e._tag,
-                      path: e.path,
-                      fields: e.fields,
-                      distinct: e.distinct,
-                      filter
-                    }
-                  ]
-                case "relation-length":
-                  return [key, { _tag: e._tag, path: e.path }]
+  switch (a._tag) {
+    case "value":
+      break
+    case "where": {
+      const { current, operation, relation, subPath } = a
+      upd(interpret(current))
+      if (typeof operation === "function") {
+        data.filter.push(
+          {
+            t: "where-scope",
+            result: interpret(operation(make())).filter.map(subPath ? applyPath(subPath) : identity),
+            relation
+          }
+        )
+      } else {
+        data.filter.push(
+          {
+            t: "where",
+            path: operation[0],
+            op: operation.length === 2 ? "eq" : operation[1],
+            value: operation.length === 2 ? operation[1] : operation[2]
+          }
+        )
+      }
+      break
+    }
+    case "and": {
+      const { current, operation, relation } = a
+      upd(interpret(current))
+      if (typeof operation === "function") {
+        data.filter.push(
+          { t: "and-scope", result: interpret(operation(make())).filter, relation }
+        )
+      } else {
+        data.filter.push(
+          {
+            t: "and",
+            path: operation[0],
+            op: operation.length === 2 ? "eq" : operation[1],
+            value: operation.length === 2 ? operation[1] : operation[2]
+          }
+        )
+      }
+      break
+    }
+    case "or": {
+      const { current, operation, relation } = a
+      upd(interpret(current))
+      if (typeof operation === "function") {
+        data.filter.push(
+          { t: "or-scope", result: interpret(operation(make())).filter, relation }
+        )
+      } else {
+        data.filter.push(
+          {
+            t: "or",
+            path: operation[0],
+            op: operation.length === 2 ? "eq" : operation[1],
+            value: operation.length === 2 ? operation[1] : operation[2]
+          }
+        )
+      }
+      break
+    }
+    case "one": {
+      upd(interpret(a.current))
+      data.limit = 1
+      data.ttype = "one"
+      break
+    }
+    case "count": {
+      upd(interpret(a.current))
+      data.ttype = "count"
+      data.schema = S.Struct({ id: S.String }) as any
+      break
+    }
+    case "order": {
+      upd(interpret(a.current))
+      data.order.push({ key: a.field, direction: a.direction })
+      break
+    }
+    case "page": {
+      upd(interpret(a.current))
+      data.limit = a.take
+      data.skip = a.skip
+      break
+    }
+    case "project": {
+      upd(interpret(a.current))
+      if (a.mode === "aggregate" && a.aggregateMap) {
+        data.schema = a.schema
+        data.mode = "aggregate"
+        data.aggregateMap = Object.fromEntries(
+          Object.entries(a.aggregateMap).map(([key, expression]) => {
+            switch (expression._tag) {
+              case "agg-field":
+                return [key, { _tag: "agg-field" as const, path: expression.path }]
+              case "agg-count":
+                return [key, { _tag: "agg-count" as const }]
+              case "agg-count-when": {
+                const filter = interpret(expression.operation(make())).filter
+                return [key, { _tag: "agg-count-when" as const, filter }]
               }
-            })
-          )
-          : undefined
+              case "agg-sum":
+                return [key, { _tag: "agg-sum" as const, field: expression.field }]
+              case "agg-min":
+                return [key, { _tag: "agg-min" as const, field: expression.field }]
+              case "agg-max":
+                return [key, { _tag: "agg-max" as const, field: expression.field }]
+            }
+          })
+        )
+        break
       }
-    })
-  )
+      if (a.computed && a.mode === "transform") {
+        throw new Error("Computed projections require mode 'project' or 'collect', not 'transform'")
+      }
+      data.schema = a.schema
+      data.mode = a.computed
+        ? a.mode === "collect" ? "collect" : "project"
+        : a.mode
+      data.computed = a.computed
+        ? Object.fromEntries(
+          Object.entries(a.computed).map(([key, expression]) => {
+            const e = expression
+            const op = "operation" in e ? e.operation : undefined
+            const filter = op ? interpret(op(make())).filter.map(applyPath(e.path)) : []
+            switch (e._tag) {
+              case "relation-count":
+              case "relation-any":
+              case "relation-every":
+                return [key, { _tag: e._tag, path: e.path, filter }]
+              case "relation-distinct-count":
+              case "relation-sum":
+                return [
+                  key,
+                  { _tag: e._tag, path: e.path, field: e.field, filter }
+                ]
+              case "relation-sum-expr":
+                return [
+                  key,
+                  { _tag: e._tag, path: e.path, expression: e.expression, filter }
+                ]
+              case "relation-sum-expr-by":
+                return [
+                  key,
+                  {
+                    _tag: e._tag,
+                    path: e.path,
+                    expression: e.expression,
+                    unit: e.unit,
+                    filter
+                  }
+                ]
+              case "relation-sum-expr-normalized":
+                return [
+                  key,
+                  {
+                    _tag: e._tag,
+                    path: e.path,
+                    expression: e.expression,
+                    unit: e.unit,
+                    toBase: e.toBase,
+                    factors: e.factors,
+                    filter
+                  }
+                ]
+              case "relation-collect":
+                return [
+                  key,
+                  {
+                    _tag: e._tag,
+                    path: e.path,
+                    field: e.field,
+                    distinct: e.distinct,
+                    filter
+                  }
+                ]
+              case "relation-collect-fields":
+                return [
+                  key,
+                  {
+                    _tag: e._tag,
+                    path: e.path,
+                    fields: e.fields,
+                    distinct: e.distinct,
+                    filter
+                  }
+                ]
+              case "relation-length":
+                return [key, { _tag: e._tag, path: e.path }]
+            }
+          })
+        )
+        : undefined
+      break
+    }
+  }
 
   return data
 }

package/src/Schema/brand.ts

@@ -28,12 +28,7 @@ export interface Constructor<in out A extends B.Brand<any>> {
   is(a: Unbranded<A>): a is Unbranded<A> & A
 }
 
-type BrandAnnotations<C extends B.Brand<any>> =
-  & S.Annotations.Filter
-  & (
-    C extends string ? { readonly toArbitrary?: S.Annotations.ToArbitrary.Declaration<C, readonly []> }
-      : {}
-  )
+type BrandAnnotations = S.Annotations.Filter
 
 export interface BrandedSchema<S extends S.Top, C extends B.Brand<any>> extends
   S.Bottom<
@@ -57,7 +52,7 @@ export interface BrandedSchema<S extends S.Top, C extends B.Brand<any>> extends
 
 export const fromBrand = <C extends B.Brand<any>>(
   constructor: Constructor<C>,
-  options?: BrandAnnotations<C>
+  options?: BrandAnnotations
 ) =>
 <Self extends S.Top>(self: Self): BrandedSchema<Self, C> => {
   const branded = S.fromBrand(options?.identifier ?? "Brand", constructor as any)(self as any)

package/src/Schema/email.ts

@@ -22,8 +22,5 @@ export const Email = S
       identifier: "Email",
       description: "an email according to RFC 5322",
       jsonSchema: { format: "email", minLength: 3, maxLength: 998 }
-    }),
-    S.annotate({
-      toArbitrary: () => (fc) => fc.emailAddress().map((_) => _ as Email)
     })
   )

package/src/Schema/ext.ts

@@ -54,8 +54,8 @@ type ProvidedCodec<Self extends S.Top, R> = S.Codec<
 
 const concurrencySetting = Effect.runSync(
   Config
-    .literal("unbounded", "SCHEMA_CONCURRENCY")
-    .pipe(Config.orElse(() => Config.number("SCHEMA_CONCURRENCY")), Config.option)
+    .Literal("unbounded", "SCHEMA_CONCURRENCY")
+    .pipe(Config.orElse(() => Config.Number("SCHEMA_CONCURRENCY")), Config.option)
 )
 
 export const DefaultParseOptions: SchemaAST.ParseOptions = {
@@ -611,7 +611,7 @@ export const transformTo = <To extends S.Top, From extends S.Top>(
   from.pipe(
     S.decodeTo(
       to,
-      SchemaTransformation.transformOrFail({
+      SchemaTransformation.transformEffect({
         decode: (input: any, options: any) => Effect.sync(() => decode(input, options)),
         encode: (i: any) =>
           Effect.fail(
@@ -624,7 +624,7 @@ export const transformTo = <To extends S.Top, From extends S.Top>(
     )
   )
 
-/** A version of transformOrFail which is only a one way mapping of From->To */
+/** A version of transformEffect which is only a one way mapping of From->To */
 export const transformToOrFail = <To extends S.Top, From extends S.Top, RD>(
   from: From,
   to: To,
@@ -636,7 +636,7 @@ export const transformToOrFail = <To extends S.Top, From extends S.Top, RD>(
   from.pipe(
     S.decodeTo(
       to,
-      SchemaTransformation.transformOrFail({
+      SchemaTransformation.transformEffect({
         decode,
         encode: (i: any) =>
           Effect.fail(

package/src/Schema/moreStrings.ts

@@ -15,7 +15,7 @@ import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 import * as S from "effect/Schema"
 import type { Simplify } from "effect/Types"
-import { customRandom, nanoid, urlAlphabet } from "nanoid"
+import { nanoid } from "nanoid"
 import validator from "validator"
 import type * as SchemaAST from "../SchemaAST.ts"
 import { type BrandedSchema, fromBrand, nominal } from "./brand.ts"
@@ -164,23 +164,16 @@ export type StringId = string & StringIdBrand
 
 const minLength = 6
 const maxLength = 50
-const size = 21
-const length = 10 * size
 const StringIdSchemaBase = pipe(
   S.String,
   S.check(S.isMinLength(minLength), S.isMaxLength(maxLength)),
   fromBrand<StringId>(nominal<StringId>(), {
     identifier: "StringId",
-    toArbitrary: () => (fc) => StringIdArb()(fc),
     jsonSchema: {}
   })
 )
 const makeStringId = (s?: string): StringId =>
   s !== undefined ? S.decodeSync(StringIdSchemaBase)(s) : nanoid() as unknown as StringId
-const StringIdArb = (): S.Arbitrary<StringId> => (fc) =>
-  fc
-    .uint8Array({ minLength: length, maxLength: length })
-    .map((_) => customRandom(urlAlphabet, size, (size) => _.subarray(0, size))() as StringId)
 /**
  * A string that is at least 6 characters long and a maximum of 50.
  *
@@ -226,18 +219,11 @@ export function prefixedStringId<Type extends StringId>() {
   ) => {
     type FullPrefix = `${Prefix}${Separator}`
     const pref = `${prefix}${separator ?? "-"}` as FullPrefix
-    const arb = (): S.Arbitrary<Type> => (fc) =>
-      StringIdArb()(fc).map(
-        (x) => (pref + x.substring(0, 50 - pref.length)) as Type
-      )
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const s = StringIdSchemaBase
       .pipe(
         S.refine((x: string): x is Type => x.startsWith(pref), {
           identifier: name
-        }),
-        S.annotate({
-          toArbitrary: () => (fc) => arb()(fc)
         })
       )
     const schema = s.pipe(withDefaultMake)
@@ -331,8 +317,5 @@ export const Url: UrlSchema = S
       identifier: "Url",
       jsonSchema: { format: "uri" }
     }),
-    S.annotate({
-      toArbitrary: () => (fc) => fc.webUrl().map((_) => _ as Url)
-    }),
     withDefaultMake
   )

package/src/Schema/phoneNumber.ts

@@ -3,7 +3,6 @@ import { isValidPhone } from "effect-app/validation"
 import * as S from "effect/Schema"
 import type { Simplify } from "effect/Types"
 import { withDefaultMake } from "./ext.ts"
-import { Numbers } from "./FastCheck.ts"
 import type { B } from "./schema.ts"
 import type { NonEmptyStringBrand } from "./strings.ts"
 
@@ -23,8 +22,5 @@ export const PhoneNumber = S
       description: "a phone number with at least 7 digits",
       jsonSchema: { format: "phone" }
     }),
-    S.annotate({
-      toArbitrary: () => (fc) => Numbers(7, 10)(fc).map((_) => _ as PhoneNumber)
-    }),
     withDefaultMake
   )

package/src/Schema.ts

@@ -2,10 +2,11 @@ import * as S from "effect/Schema"
 import { type Simplify } from "effect/Struct"
 import type * as Tracer from "effect/Tracer"
 import type { RequiredKeys } from "effect/Types"
+import type { Arbitrary as FastCheckArbitrary } from "fast-check"
 import type { NonEmptyReadonlyArray } from "./Array.ts"
-import { fakerArb } from "./faker.ts"
 import { Email as EmailT, type Email as EmailType } from "./Schema/email.ts"
 import { concurrencyUnbounded, withDefaultMake, withDefaultParseOptions } from "./Schema/ext.ts"
+import type { FC } from "./Schema/FastCheck.ts"
 import { PhoneNumber as PhoneNumberT, type PhoneNumber as PhoneNumberType } from "./Schema/phoneNumber.ts"
 import { type AST } from "./Schema/schema.ts"
 import * as SchemaAST from "./SchemaAST.ts"
@@ -129,6 +130,9 @@ export { NonEmptyString } from "./Schema/strings.ts"
 
 export * as SchemaIssue from "effect/SchemaIssue"
 
+/** Fast-check generator factory previously exported as `Schema.Arbitrary`. */
+export type Arbitrary<T> = (fc: FC) => FastCheckArbitrary<T>
+
 export const decodeEffectConcurrently: typeof S.decodeEffect = withDefaultParseOptions(S.decodeEffect)
 export const decodeUnknownEffectConcurrently: typeof S.decodeUnknownEffect = withDefaultParseOptions(
   S.decodeUnknownEffect
@@ -347,29 +351,11 @@ 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
-      toArbitrary: () => (fc) => fakerArb((faker) => faker.internet.exampleEmail)(fc).map(makeEmail)
-    }),
-    withDefaultMake
-  )
+export const Email = EmailT.pipe(withDefaultMake)
 
 export type Email = EmailType
 
-export const PhoneNumber = PhoneNumberT
-  .pipe(
-    S.annotate({
-      toArbitrary: () => (fc) =>
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        fakerArb((faker) => faker.phone.number)(fc).map(makePhoneNumber)
-    }),
-    withDefaultMake
-  )
+export const PhoneNumber = PhoneNumberT.pipe(withDefaultMake)
 
 export type PhoneNumber = PhoneNumberType
 

package/src/client/apiClientFactory.ts

@@ -25,13 +25,8 @@ export interface ApiConfig {
 }
 
 export const DefaultApiConfig = Config.all({
-  url: Config.string("apiUrl").pipe(Config.withDefault("/api")),
-  headers: Config
-    .schema(
-      Config.Record(Schema.String, Schema.String),
-      "headers"
-    )
-    .pipe(Config.option)
+  url: Config.String("apiUrl").pipe(Config.withDefault("/api")),
+  headers: Config.Record(Schema.String, Schema.String, "headers").pipe(Config.option)
 })
 
 export type Req = S.Top & {

package/src/runtime.ts

@@ -9,8 +9,9 @@ import * as Layer from "./Layer.ts"
 
 export const makeAppRuntime = Effect.fnUntraced(function*<A, E>(layer: Layer.Layer<A, E>) {
   const l = layer.pipe(
-    Layer.provide(Logger.layer([Logger.consolePretty()]))
-  ) as Layer.Layer<A>
+    Layer.provide(Logger.layer([Logger.consolePretty()])),
+    Layer.orDie
+  )
   const mrt = ManagedRuntime.make(l)
   yield* mrt.contextEffect
   return Object.assign(mrt, {

package/test/moreStrings.test.ts

@@ -1,5 +1,4 @@
 import * as S from "effect-app/Schema"
-import * as fc from "fast-check"
 import { urlAlphabet } from "nanoid"
 import { test } from "vitest"
 
@@ -7,11 +6,10 @@ const nanoidAlphabet = new Set(urlAlphabet)
 
 const isNanoId = (value: string) => value.length === 21 && Array.from(value).every((char) => nanoidAlphabet.has(char))
 
-test("StringId arbitrary generates nanoid-shaped values", () => {
-  fc.assert(
-    fc.property(S.toArbitrary(S.StringId)(fc), (value) => {
-      expect(isNanoId(value)).toBe(true)
-      expect(S.is(S.StringId)(value)).toBe(true)
-    })
-  )
+test("StringId make generates nanoid-shaped values", () => {
+  for (let i = 0; i < 20; i++) {
+    const value = S.StringId.make()
+    expect(isNanoId(value)).toBe(true)
+    expect(S.is(S.StringId)(value)).toBe(true)
+  }
 })