@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.2

package/src/internal/data.ts

@@ -0,0 +1,36 @@
+import * as Equal from "../Equal.js"
+import * as Hash from "../Hash.js"
+import type * as Types from "../Types.js"
+import { StructuralPrototype } from "./effectable.js"
+
+/** @internal */
+export const ArrayProto: Equal.Equal = Object.assign(Object.create(Array.prototype), {
+  [Hash.symbol](this: Array<any>) {
+    return Hash.cached(this, Hash.array(this))
+  },
+  [Equal.symbol](this: Array<any>, that: Equal.Equal) {
+    if (Array.isArray(that) && this.length === that.length) {
+      return this.every((v, i) => Equal.equals(v, (that as Array<any>)[i]))
+    } else {
+      return false
+    }
+  }
+})
+
+/** @internal */
+export const Structural: new<A>(
+  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
+    : { readonly [P in keyof A as P extends keyof Equal.Equal ? never : P]: A[P] }
+) => {} = (function() {
+  function Structural(this: any, args: any) {
+    if (args) {
+      Object.assign(this, args)
+    }
+  }
+  Structural.prototype = StructuralPrototype
+  return Structural as any
+})()
+
+/** @internal */
+export const struct = <As extends Readonly<Record<string, any>>>(as: As): As =>
+  Object.assign(Object.create(StructuralPrototype), as)

package/src/internal/dataSource.ts

@@ -0,0 +1,327 @@
+import * as RA from "../Array.js"
+import * as Cause from "../Cause.js"
+import * as Chunk from "../Chunk.js"
+import type * as Context from "../Context.js"
+import * as Effect from "../Effect.js"
+import type * as Either from "../Either.js"
+import { dual, pipe } from "../Function.js"
+import type * as Request from "../Request.js"
+import type * as RequestResolver from "../RequestResolver.js"
+import type { NoInfer } from "../Types.js"
+import * as core from "./core.js"
+import { invokeWithInterrupt, zipWithOptions } from "./fiberRuntime.js"
+import { complete } from "./request.js"
+
+/** @internal */
+export const make = <A, R>(
+  runAll: (requests: Array<Array<A>>) => Effect.Effect<void, never, R>
+): RequestResolver.RequestResolver<A, R> =>
+  new core.RequestResolverImpl((requests) => runAll(requests.map((_) => _.map((_) => _.request))))
+
+/** @internal */
+export const makeWithEntry = <A, R>(
+  runAll: (requests: Array<Array<Request.Entry<A>>>) => Effect.Effect<void, never, R>
+): RequestResolver.RequestResolver<A, R> => new core.RequestResolverImpl((requests) => runAll(requests))
+
+/** @internal */
+export const makeBatched = <A extends Request.Request<any, any>, R>(
+  run: (requests: RA.NonEmptyArray<A>) => Effect.Effect<void, never, R>
+): RequestResolver.RequestResolver<A, R> =>
+  new core.RequestResolverImpl<A, R>(
+    (requests) => {
+      if (requests.length > 1) {
+        return core.forEachSequentialDiscard(requests, (block) => {
+          const filtered = block.filter((_) => !_.state.completed).map((_) => _.request)
+          if (!RA.isNonEmptyArray(filtered)) {
+            return core.void
+          }
+          return invokeWithInterrupt(run(filtered), block)
+        })
+      } else if (requests.length === 1) {
+        const filtered = requests[0].filter((_) => !_.state.completed).map((_) => _.request)
+        if (!RA.isNonEmptyArray(filtered)) {
+          return core.void
+        }
+        return run(filtered)
+      }
+      return core.void
+    }
+  )
+
+/** @internal */
+export const around = dual<
+  <A2, R2, X, R3>(
+    before: Effect.Effect<A2, never, R2>,
+    after: (a: A2) => Effect.Effect<X, never, R3>
+  ) => <A, R>(
+    self: RequestResolver.RequestResolver<A, R>
+  ) => RequestResolver.RequestResolver<A, R | R2 | R3>,
+  <A, R, A2, R2, X, R3>(
+    self: RequestResolver.RequestResolver<A, R>,
+    before: Effect.Effect<A2, never, R2>,
+    after: (a: A2) => Effect.Effect<X, never, R3>
+  ) => RequestResolver.RequestResolver<A, R | R2 | R3>
+>(3, (self, before, after) =>
+  new core.RequestResolverImpl(
+    (requests) =>
+      core.acquireUseRelease(
+        before,
+        () => self.runAll(requests),
+        after
+      ),
+    Chunk.make("Around", self, before, after)
+  ))
+
+/** @internal */
+export const aroundRequests = dual<
+  <A, A2, R2, X, R3>(
+    before: (requests: ReadonlyArray<NoInfer<A>>) => Effect.Effect<A2, never, R2>,
+    after: (requests: ReadonlyArray<NoInfer<A>>, _: A2) => Effect.Effect<X, never, R3>
+  ) => <R>(
+    self: RequestResolver.RequestResolver<A, R>
+  ) => RequestResolver.RequestResolver<A, R | R2 | R3>,
+  <A, R, A2, R2, X, R3>(
+    self: RequestResolver.RequestResolver<A, R>,
+    before: (requests: ReadonlyArray<NoInfer<A>>) => Effect.Effect<A2, never, R2>,
+    after: (requests: ReadonlyArray<NoInfer<A>>, _: A2) => Effect.Effect<X, never, R3>
+  ) => RequestResolver.RequestResolver<A, R | R2 | R3>
+>(3, (self, before, after) =>
+  new core.RequestResolverImpl(
+    (requests) => {
+      const flatRequests = requests.flatMap((chunk) => chunk.map((entry) => entry.request))
+      return core.acquireUseRelease(
+        before(flatRequests),
+        () => self.runAll(requests),
+        (a2) => after(flatRequests, a2)
+      )
+    },
+    Chunk.make("AroundRequests", self, before, after)
+  ))
+
+/** @internal */
+export const batchN = dual<
+  (n: number) => <A, R>(
+    self: RequestResolver.RequestResolver<A, R>
+  ) => RequestResolver.RequestResolver<A, R>,
+  <A, R>(
+    self: RequestResolver.RequestResolver<A, R>,
+    n: number
+  ) => RequestResolver.RequestResolver<A, R>
+>(2, <A, R>(
+  self: RequestResolver.RequestResolver<A, R>,
+  n: number
+): RequestResolver.RequestResolver<A, R> =>
+  new core.RequestResolverImpl(
+    (requests) => {
+      return n < 1
+        ? core.die(new Cause.IllegalArgumentException("RequestResolver.batchN: n must be at least 1"))
+        : self.runAll(
+          Array.from(Chunk.map(
+            RA.reduce(
+              requests,
+              Chunk.empty<Chunk.Chunk<Request.Entry<A>>>(),
+              (acc, chunk) => Chunk.appendAll(acc, Chunk.chunksOf(Chunk.unsafeFromArray(chunk), n))
+            ),
+            (chunk) => Array.from(chunk)
+          ))
+        )
+    },
+    Chunk.make("BatchN", self, n)
+  ))
+
+/** @internal */
+export const mapInputContext = dual<
+  <R0, R>(
+    f: (context: Context.Context<R0>) => Context.Context<R>
+  ) => <A extends Request.Request<any, any>>(
+    self: RequestResolver.RequestResolver<A, R>
+  ) => RequestResolver.RequestResolver<A, R0>,
+  <R, A extends Request.Request<any, any>, R0>(
+    self: RequestResolver.RequestResolver<A, R>,
+    f: (context: Context.Context<R0>) => Context.Context<R>
+  ) => RequestResolver.RequestResolver<A, R0>
+>(2, <R, A extends Request.Request<any, any>, R0>(
+  self: RequestResolver.RequestResolver<A, R>,
+  f: (context: Context.Context<R0>) => Context.Context<R>
+) =>
+  new core.RequestResolverImpl<A, R0>(
+    (requests) =>
+      core.mapInputContext(
+        self.runAll(requests),
+        (context: Context.Context<R0>) => f(context)
+      ),
+    Chunk.make("MapInputContext", self, f)
+  ))
+
+/** @internal */
+export const eitherWith = dual<
+  <
+    A extends Request.Request<any, any>,
+    R2,
+    B extends Request.Request<any, any>,
+    C extends Request.Request<any, any>
+  >(
+    that: RequestResolver.RequestResolver<B, R2>,
+    f: (_: Request.Entry<C>) => Either.Either<Request.Entry<B>, Request.Entry<A>>
+  ) => <R>(
+    self: RequestResolver.RequestResolver<A, R>
+  ) => RequestResolver.RequestResolver<C, R | R2>,
+  <
+    R,
+    A extends Request.Request<any, any>,
+    R2,
+    B extends Request.Request<any, any>,
+    C extends Request.Request<any, any>
+  >(
+    self: RequestResolver.RequestResolver<A, R>,
+    that: RequestResolver.RequestResolver<B, R2>,
+    f: (_: Request.Entry<C>) => Either.Either<Request.Entry<B>, Request.Entry<A>>
+  ) => RequestResolver.RequestResolver<C, R | R2>
+>(3, <
+  R,
+  A extends Request.Request<any, any>,
+  R2,
+  B extends Request.Request<any, any>,
+  C extends Request.Request<any, any>
+>(
+  self: RequestResolver.RequestResolver<A, R>,
+  that: RequestResolver.RequestResolver<B, R2>,
+  f: (_: Request.Entry<C>) => Either.Either<Request.Entry<B>, Request.Entry<A>>
+) =>
+  new core.RequestResolverImpl<C, R | R2>(
+    (batch) =>
+      core.forEachSequential(batch, (requests) => {
+        const [as, bs] = pipe(
+          requests,
+          RA.partitionMap(f)
+        )
+        return zipWithOptions(
+          self.runAll(Array.of(as)),
+          that.runAll(Array.of(bs)),
+          () => void 0,
+          { concurrent: true }
+        )
+      }),
+    Chunk.make("EitherWith", self, that, f)
+  ))
+
+/** @internal */
+export const fromFunction = <A extends Request.Request<any>>(
+  f: (request: A) => Request.Request.Success<A>
+): RequestResolver.RequestResolver<A> =>
+  makeBatched((requests: RA.NonEmptyArray<A>) =>
+    core.forEachSequentialDiscard(
+      requests,
+      (request) => complete(request, core.exitSucceed(f(request)) as any)
+    )
+  ).identified("FromFunction", f)
+
+/** @internal */
+export const fromFunctionBatched = <A extends Request.Request<any>>(
+  f: (chunk: RA.NonEmptyArray<A>) => Iterable<Request.Request.Success<A>>
+): RequestResolver.RequestResolver<A> =>
+  makeBatched((as: RA.NonEmptyArray<A>) =>
+    Effect.forEach(
+      f(as),
+      (res, i) => complete(as[i], core.exitSucceed(res) as any),
+      { discard: true }
+    )
+  ).identified("FromFunctionBatched", f)
+
+/** @internal */
+export const fromEffect = <R, A extends Request.Request<any, any>>(
+  f: (a: A) => Effect.Effect<Request.Request.Success<A>, Request.Request.Error<A>, R>
+): RequestResolver.RequestResolver<A, R> =>
+  makeBatched((requests: RA.NonEmptyArray<A>) =>
+    Effect.forEach(
+      requests,
+      (a) => Effect.flatMap(Effect.exit(f(a)), (e) => complete(a, e as any)),
+      { concurrency: "unbounded", discard: true }
+    )
+  ).identified("FromEffect", f)
+
+/** @internal */
+export const fromEffectTagged = <
+  A extends Request.Request<any, any> & {
+    readonly _tag: string
+  }
+>() =>
+<
+  Fns extends {
+    readonly [Tag in A["_tag"]]: [Extract<A, { readonly _tag: Tag }>] extends [infer Req] ?
+      Req extends Request.Request<infer ReqA, infer ReqE> ?
+        (requests: Array<Req>) => Effect.Effect<Iterable<ReqA>, ReqE, any>
+      : never
+      : never
+  }
+>(
+  fns: Fns
+): RequestResolver.RequestResolver<
+  A,
+  ReturnType<Fns[keyof Fns]> extends Effect.Effect<infer _A, infer _E, infer R> ? R : never
+> =>
+  makeBatched<A, any>((requests: RA.NonEmptyArray<A>) => {
+    const grouped: Record<string, Array<A>> = {}
+    const tags: Array<A["_tag"]> = []
+    for (let i = 0, len = requests.length; i < len; i++) {
+      if (tags.includes(requests[i]._tag)) {
+        grouped[requests[i]._tag].push(requests[i])
+      } else {
+        grouped[requests[i]._tag] = [requests[i]]
+        tags.push(requests[i]._tag)
+      }
+    }
+    return Effect.forEach(
+      tags,
+      (tag) =>
+        Effect.matchCauseEffect((fns[tag] as any)(grouped[tag]) as Effect.Effect<Array<any>, unknown, unknown>, {
+          onFailure: (cause) =>
+            Effect.forEach(grouped[tag], (req) => complete(req, core.exitFail(cause) as any), { discard: true }),
+          onSuccess: (res) =>
+            Effect.forEach(grouped[tag], (req, i) => complete(req, core.exitSucceed(res[i]) as any), { discard: true })
+        }),
+      { concurrency: "unbounded", discard: true }
+    )
+  }).identified("FromEffectTagged", fns)
+
+/** @internal */
+export const never: RequestResolver.RequestResolver<never> = make(() => Effect.never).identified("Never")
+
+/** @internal */
+export const provideContext = dual<
+  <R>(
+    context: Context.Context<R>
+  ) => <A extends Request.Request<any, any>>(
+    self: RequestResolver.RequestResolver<A, R>
+  ) => RequestResolver.RequestResolver<A>,
+  <R, A extends Request.Request<any, any>>(
+    self: RequestResolver.RequestResolver<A, R>,
+    context: Context.Context<R>
+  ) => RequestResolver.RequestResolver<A>
+>(2, (self, context) =>
+  mapInputContext(
+    self,
+    (_: Context.Context<never>) => context
+  ).identified("ProvideContext", self, context))
+
+/** @internal */
+export const race = dual<
+  <A2 extends Request.Request<any, any>, R2>(
+    that: RequestResolver.RequestResolver<A2, R2>
+  ) => <A extends Request.Request<any, any>, R>(
+    self: RequestResolver.RequestResolver<A, R>
+  ) => RequestResolver.RequestResolver<A | A2, R | R2>,
+  <A extends Request.Request<any, any>, R, A2 extends Request.Request<any, any>, R2>(
+    self: RequestResolver.RequestResolver<A, R>,
+    that: RequestResolver.RequestResolver<A2, R2>
+  ) => RequestResolver.RequestResolver<A | A2, R | R2>
+>(2, <A, R, A2, R2>(
+  self: RequestResolver.RequestResolver<A, R>,
+  that: RequestResolver.RequestResolver<A2, R2>
+) =>
+  new core.RequestResolverImpl((requests) =>
+    Effect.race(
+      self.runAll(requests as Array<Array<Request.Entry<A>>>),
+      that.runAll(requests as Array<Array<Request.Entry<A2>>>)
+    )
+  ).identified("Race", self, that))