@typed/fx 1.17.4 → 1.18.0

package/src/Form.ts

@@ -0,0 +1,373 @@
+/**
+ * @since 1.18.0
+ */
+import { AST } from "@effect/schema"
+import type { ParseOptions } from "@effect/schema/AST"
+import { from } from "@effect/schema/Equivalence"
+import type { ParseError } from "@effect/schema/ParseResult"
+import * as S from "@effect/schema/Schema"
+import type { Scope } from "effect"
+import { Effect } from "effect"
+import { Computed } from "./Computed"
+import type * as Filtered from "./Filtered"
+import * as FormEntry from "./FormEntry"
+import type { Fx } from "./Fx"
+import * as core from "./internal/core"
+import { FxEffectBase } from "./internal/protos"
+import { hold } from "./internal/share"
+import type { RefSubject } from "./RefSubject"
+import { ComputedTypeId, FilteredTypeId, RefSubjectTypeId, TypeId } from "./TypeId"
+import type * as Versioned from "./Versioned"
+
+/**
+ * @since 1.18.0
+ */
+export const FormTypeId = Symbol.for("./Form")
+/**
+ * @since 1.18.0
+ */
+export type FormTypeId = typeof FormTypeId
+
+type AnyObject = Readonly<Record<PropertyKey, any>>
+type AnyObjectWithKeys<K extends PropertyKey> = Readonly<Record<K, any>>
+
+/**
+ * @since 1.18.0
+ */
+export interface Form<Entries extends Form.AnyEntries> extends
+  Form.Base<
+    Form.Error<Entries[keyof Entries]>,
+    Form.Input<Entries>,
+    Form.Output<Entries>,
+    Entries
+  >
+{}
+
+/**
+ * @since 1.18.0
+ */
+export namespace Form {
+  /**
+   * Base interface is to improve type-checking performance by memoizing the derived R, E, I, and O values.
+   */
+  /**
+   * @since 1.18.0
+   */
+  export interface Base<E, I, O, Entries extends Form.AnyEntries>
+    extends Versioned.Versioned<never, never, never, E | ParseError, I, never, E | ParseError, I>
+  {
+    readonly [FormTypeId]: FormTypeId
+
+    readonly entries: Entries
+
+    readonly schema: S.Schema<
+      I,
+      O
+    >
+
+    readonly get: <K extends keyof Entries>(key: K) => Entries[K]
+
+    readonly decoded: Computed<
+      never,
+      E | ParseError,
+      O
+    >
+  }
+
+  /**
+   * @since 1.18.0
+   */
+  export type AnyEntry =
+    | FormEntry.FormEntry<any, any, any>
+    | FormEntry.FormEntry<never, any, any>
+    | FormEntry.FormEntry<any, never, any>
+    | FormEntry.FormEntry<never, never, any>
+    | Base<any, any, any, any>
+
+  /**
+   * @since 1.18.0
+   */
+  export type AnyEntries = Readonly<Record<PropertyKey, AnyEntry>>
+
+  /**
+   * @since 1.18.0
+   */
+  export type Error<T> = [T] extends [FormEntry.FormEntry<infer E, infer _I, infer _>] ? E :
+    [T] extends [Base<infer _E, infer _I, infer _O, infer _Entries>] ? _E :
+    never
+
+  /**
+   * @since 1.18.0
+   */
+  export type Input<T> = [T] extends [FormEntry.FormEntry<infer _E, infer I, infer _>] ? I :
+    T extends Form<infer Entries> ? {
+        readonly [K in keyof Entries]: Input<Entries[K]>
+      } :
+    T extends AnyEntries ? {
+        readonly [K in keyof T]: Input<T[K]>
+      } :
+    never
+
+  /**
+   * @since 1.18.0
+   */
+  export type Output<T> = [T] extends [FormEntry.FormEntry<infer _E, infer _I, infer O>] ? O :
+    T extends Form<infer Entries> ? {
+        readonly [K in keyof Entries]: Output<Entries[K]>
+      } :
+    T extends AnyEntries ? {
+        readonly [K in keyof T]: Output<T[K]>
+      } :
+    never
+
+  /**
+   * @since 1.18.0
+   */
+  export interface Derived<R, Entries extends AnyEntries> extends Form<Entries> {
+    readonly persist: Effect.Effect<
+      R,
+      Error<Entries>,
+      Output<Entries>
+    >
+  }
+}
+
+/**
+ * @since 1.18.0
+ */
+export function Form<Entries extends Form.AnyEntries>(entries: Entries): Form<Entries> {
+  return new FormImpl(entries) as any
+}
+
+/**
+ * @since 1.18.0
+ */
+export type MakeForm<
+  I extends AnyObject,
+  O extends AnyObjectWithKeys<keyof I>
+> = {
+  <R, E>(fx: RefSubject<R, E, O>): Effect.Effect<
+    R | Scope.Scope,
+    never,
+    [DerivedFromIO<R, E, I, O>] extends [Form.Derived<infer R, infer R2>] ? Form.Derived<R, R2> : never
+  >
+
+  <R, E>(fx: Fx<R, E, O>): Effect.Effect<
+    R | Scope.Scope,
+    never,
+    [FormFromIO<E, I, O>] extends [Form<infer R>] ? Form<R> : never
+  >
+
+  <R, E>(effect: Effect.Effect<R, E, O>): Effect.Effect<
+    R,
+    never,
+    [FormFromIO<E, I, O>] extends [Form<infer R>] ? Form<R> : never
+  >
+}
+
+/**
+ * @since 1.18.0
+ */
+export type FormFromIO<
+  E,
+  I extends AnyObject,
+  O extends AnyObjectWithKeys<keyof I>
+> = Form<
+  [FormEntriesFromIO<E, I, O>] extends [infer R] ? { readonly [K in keyof R]: R[K] } : never
+>
+
+/**
+ * @since 1.18.0
+ */
+export type FormEntriesFromIO<
+  E,
+  I extends AnyObject,
+  O extends AnyObjectWithKeys<keyof I>
+> = {
+  readonly [K in keyof I]-?: [I[K], O[K]] extends [AnyObject, AnyObjectWithKeys<keyof I[K]>] ? Form<
+      [FormEntriesFromIO<E, I[K], O[K]>] extends [infer R] ? { readonly [K in keyof R]: R[K] } : never
+    > :
+    FormEntry.FormEntry<E, I[K], O[K]>
+}
+
+/**
+ * @since 1.18.0
+ */
+export type DerivedFromIO<
+  R,
+  E,
+  I extends Readonly<Record<PropertyKey, any>>,
+  O extends Readonly<Record<keyof I, any>>
+> = Form.Derived<
+  R,
+  {
+    readonly [K in keyof I]-?: FormEntry.FormEntry<E, I[K], O[K]>
+  }
+>
+
+/**
+ * @since 1.18.0
+ */
+export function make<
+  I extends Partial<Readonly<Record<PropertyKey, any>>>,
+  O extends Partial<AnyObjectWithKeys<keyof I>>
+>(schema: S.Schema<I, O>): MakeForm<I, O> {
+  return (input) =>
+    Effect.map(deriveMakeEntries(input, schema.ast), (entries) => {
+      const form = (Form as any)(entries)
+
+      if (RefSubjectTypeId in input) {
+        return Object.assign(form, {
+          persist: Effect.matchCauseEffect(form.decoded, input)
+        })
+      }
+
+      return form
+    })
+}
+
+const parseOptions: ParseOptions = { errors: "all", onExcessProperty: "ignore" }
+
+// @ts-expect-error
+class FormImpl<Entries extends Form.AnyEntries> extends FxEffectBase<
+  never,
+  never,
+  Form.Error<Entries> | ParseError,
+  Form.Input<Entries>,
+  never,
+  Form.Error<Entries> | ParseError,
+  Form.Input<Entries>
+> implements Form<Entries> {
+  readonly [FormTypeId]: FormTypeId = FormTypeId
+
+  constructor(readonly entries: Entries) {
+    super()
+
+    this.schema = buildSchema(entries)
+    this.version = Effect.map(
+      // @ts-ignore Infinite type instantiation
+      Effect.all(Object.values(entries).map((e) => e.version)) as Effect.Effect<
+        never,
+        never,
+        ReadonlyArray<number>
+      >,
+      (versions) => versions.reduce((a, b) => a + b, 0)
+    )
+  }
+
+  get: Form<Entries>["get"] = (k) => this.entries[k]
+
+  schema: Form<Entries>["schema"]
+
+  version: Form<Entries>["version"]
+
+  toFx(): Fx<
+    never,
+    Form.Error<Entries> | ParseError,
+    Form.Input<Entries>
+  > {
+    return hold(core.skipRepeatsWith(core.struct(this.entries as any) as any, from(this.schema))) as any
+  }
+
+  toEffect(): Effect.Effect<
+    never,
+    Form.Error<Entries> | ParseError,
+    Form.Input<Entries>
+  > {
+    return (
+      Effect.all(this.entries as any, { concurrency: "unbounded" }) as any
+    )
+  }
+
+  decoded: Form<Entries>["decoded"] = Computed(
+    this as any as Form<Entries>,
+    (i) => S.decode(this.schema)(i, parseOptions)
+  )
+}
+
+function buildSchema<Entries extends Form.AnyEntries>(
+  entries: Entries
+): S.Schema<Form.Input<Entries>, Form.Output<Entries>> {
+  const schemas: any = {}
+
+  for (const key of Reflect.ownKeys(entries)) {
+    const entry = entries[key]
+
+    if (FormTypeId in entry) {
+      schemas[key] = buildSchema(entry.entries)
+    } else {
+      schemas[key] = entry.schema
+    }
+  }
+
+  return S.struct(schemas) as any
+}
+
+type DeriveEntries<E, I extends Readonly<Record<PropertyKey, any>>, O extends Readonly<Record<keyof I, any>>> = {
+  readonly [K in keyof I]: I[K] extends Readonly<Record<PropertyKey, any>> ? DeriveEntries<E, I[K], O[K]>
+    : FormEntry.FormEntry<E, I[K], O[K]>
+}
+
+const deriveMakeEntries = <
+  R,
+  E,
+  I extends Readonly<Record<PropertyKey, any>>,
+  O extends Readonly<Record<keyof I, any>>
+>(
+  input: RefSubject<R, E, O> | Fx<R, E, O> | Effect.Effect<R, E, O>,
+  ast: AST.AST
+): Effect.Effect<R | Scope.Scope, never, DeriveEntries<E, I, O>> =>
+  Effect.suspend(() => {
+    switch (ast._tag) {
+      case "TypeLiteral": {
+        const propertySignatures = ast.propertySignatures
+
+        return Effect.gen(function*(_) {
+          const entries: any = {}
+
+          for (const prop of propertySignatures) {
+            const nested = propOf(input, prop.name)
+            const ast = prop.isOptional ? AST.createUnion([prop.type, AST.undefinedKeyword]) : prop.type
+
+            if (prop.type._tag === "TypeLiteral") {
+              entries[prop.name] = Form(
+                (yield* _(
+                  deriveMakeEntries(
+                    nested,
+                    ast
+                  )
+                )) as any
+              )
+            } else {
+              entries[prop.name] = yield* _(
+                FormEntry.make<any, any>({
+                  name: prop.name,
+                  schema: S.make(ast)
+                })(nested as Fx<R, E, any>)
+              )
+            }
+          }
+
+          return entries
+        })
+      }
+      default: {
+        return Effect.die(new TypeError("Form.deriveMakeEntries only supports TypeLiteral schemas."))
+      }
+    }
+  })
+
+const propOf = <R, E, O>(
+  input:
+    | RefSubject<R, E, O>
+    | Computed<R, E, O>
+    | Filtered.Filtered<R, E, O>
+    | Fx<R, E, O>
+    | Effect.Effect<R, E, O>,
+  key: keyof O
+) => {
+  if (RefSubjectTypeId in input || ComputedTypeId in input || FilteredTypeId in input) {
+    return input.map((o) => o[key])
+  } else if (TypeId in input) return core.map(input, (o) => o[key])
+  else return Effect.map(input, (o) => o[key])
+}

package/src/FormEntry.ts

@@ -0,0 +1,174 @@
+/**
+ * @since 1.18.0
+ */
+import { Schema } from "@effect/schema"
+import type { ParseOptions } from "@effect/schema/AST"
+import * as schemaEquivalence from "@effect/schema/Equivalence"
+import { type ParseError } from "@effect/schema/ParseResult"
+import { Deferred, Effect, Exit, Ref } from "effect"
+import type { Scope } from "effect"
+import * as Option from "effect/Option"
+import type { Computed } from "./Computed"
+import { type Fx, run } from "./Fx"
+import { RefSubjectImpl } from "./internal/core-ref-subject"
+import { makeHoldSubject } from "./internal/core-subject"
+import { DeferredRef } from "./internal/deferred-ref"
+import type { RefSubject } from "./RefSubject"
+import { Sink } from "./Sink"
+import { RefSubjectTypeId, TypeId } from "./TypeId"
+
+/**
+ * @since 1.18.0
+ */
+export interface FormEntry<in out E, in out I, in out O> extends RefSubject<never, E | ParseError, I> {
+  readonly name: PropertyKey
+  readonly schema: Schema.Schema<I, O>
+  readonly decoded: Computed<never, E | ParseError, O>
+}
+
+/**
+ * @since 1.18.0
+ */
+export namespace FormEntry {
+  /**
+   * @since 1.18.0
+   */
+  export interface Derived<R, E, I, O> extends FormEntry<E, I, O> {
+    readonly persist: Effect.Effect<R, E | ParseError, O>
+  }
+}
+
+/**
+ * @since 1.18.0
+ */
+export interface FormEntryOptions<I, O> {
+  readonly name: PropertyKey
+  readonly schema: Schema.Schema<I, O>
+}
+
+/**
+ * MakeRefSubject is a RefSubject factory function dervied from a Schema.
+ * @since 1.18.0
+ */
+/**
+ * @since 1.18.0
+ */
+export type MakeFormEntry<I, O> = {
+  <R, E>(
+    ref: RefSubject<R, E, O>
+  ): Effect.Effect<R | Scope.Scope, never, FormEntry.Derived<R, E, I, O>>
+  <R, E>(fx: Fx<R, E, O>): Effect.Effect<R | Scope.Scope, never, FormEntry<E, I, O>>
+  <R, E>(effect: Effect.Effect<R, E, O>): Effect.Effect<R, never, FormEntry<E, I, O>>
+}
+
+/**
+ * @since 1.18.0
+ */
+export function make<I, O>(options: FormEntryOptions<I, O>): MakeFormEntry<I, O> {
+  return (<R, E>(input: RefSubject<R, E, O> | Fx<R, E, O> | Effect.Effect<R, E, O>) => {
+    if (RefSubjectTypeId in input) {
+      return makeDerivedFormEntry(input, options)
+    } else if (TypeId in input) {
+      return makeFxFormEntry(input, options)
+    } else {
+      return makeEffectFormEntry(input, options)
+    }
+  }) as MakeFormEntry<I, O>
+}
+
+const parseOptions: ParseOptions = {
+  errors: "all",
+  onExcessProperty: "ignore"
+}
+
+function makeEffectFormEntry<R, E, I, O>(
+  input: Effect.Effect<R, E, O>,
+  options: FormEntryOptions<I, O>
+): Effect.Effect<R, never, FormEntry<E, I, O>> {
+  return Effect.contextWith((ctx) =>
+    FormEntryImpl.formEntry(
+      Effect.provide(Effect.flatMap(input, (i) => Schema.encode(options.schema)(i, parseOptions)), ctx),
+      options.name,
+      options.schema
+    )
+  )
+}
+
+function makeFxFormEntry<R, E, I, O>(
+  input: Fx<R, E, O>,
+  options: FormEntryOptions<I, O>
+): Effect.Effect<R | Scope.Scope, never, FormEntry<E, I, O>> {
+  const encode_ = Schema.encode(options.schema)
+
+  return Effect.gen(function*(_) {
+    const deferred = new DeferredRef(yield* _(Deferred.make<E | ParseError, I>()))
+    const entry = FormEntryImpl.formEntry(
+      deferred,
+      options.name,
+      options.schema
+    )
+
+    const done = (exit: Exit.Exit<E, O>) =>
+      Effect.flatMap(
+        Effect.exit(Effect.flatMap(exit, encode_)),
+        (exit) =>
+          Effect.flatMap(deferred.done(exit), (closed) => {
+            if (closed) return Effect.unit
+
+            return Exit.match(exit, entry)
+          })
+      )
+
+    yield* _(Effect.forkScoped(run(
+      input,
+      Sink(
+        (e) => done(Exit.failCause(e)),
+        (a) => done(Exit.succeed(a))
+      )
+    )))
+
+    return entry
+  })
+}
+
+function makeDerivedFormEntry<R, E, I, O>(
+  input: RefSubject<R, E, O>,
+  options: FormEntryOptions<I, O>
+): Effect.Effect<R | Scope.Scope, never, FormEntry.Derived<R, E, I, O>> {
+  const decode_ = Schema.decode(options.schema)
+
+  return Effect.map(makeFxFormEntry(input, options), (entry) =>
+    Object.assign(
+      entry,
+      {
+        persist: input.updateEffect(() => Effect.flatMap(entry, decode_))
+      } as const
+    ) satisfies FormEntry.Derived<R, E, I, O>)
+}
+
+class FormEntryImpl<E, I, O> extends RefSubjectImpl<never, E | ParseError, I> implements FormEntry<E, I, O> {
+  constructor(
+    initial: Effect.Effect<never, E, I>,
+    readonly name: PropertyKey,
+    readonly schema: Schema.Schema<I, O>,
+    readonly parseOptions?: ParseOptions
+  ) {
+    super(
+      initial,
+      schemaEquivalence.from(schema),
+      Ref.unsafeMake(Option.none()),
+      Effect.unsafeMakeSemaphore(1),
+      makeHoldSubject()
+    )
+  }
+
+  decoded = this.mapEffect((i) => Schema.decode(this.schema)(i, this.parseOptions))
+
+  static formEntry<E, I, O>(
+    initial: Effect.Effect<never, E | ParseError, I>,
+    name: PropertyKey,
+    schema: Schema.Schema<I, O>
+  ): FormEntry<E, I, O> {
+    return new FormEntryImpl(initial, name, schema, parseOptions) as any
+  }
+}