@fncts/query 0.0.1

package/_src/Query/api.ts

@@ -0,0 +1,76 @@
+/**
+ * @tsplus static fncts.query.QueryOps cachingEnabled
+ */
+export const cachingEnabled: FiberRef<boolean> = FiberRef.unsafeMake(true);
+/**
+ * @tsplus static fncts.query.QueryOps currentCache
+ */
+export const currentCache: FiberRef<Cache> = FiberRef.unsafeMake(Cache.unsafeMake());
+
+/**
+ * @tsplus static fncts.query.QueryOps fromIO
+ */
+export function fromIO<R, E, A>(io: Lazy<IO<R, E, A>>): Query<R, E, A> {
+  return new Query(IO.defer(io).matchCause(Result.fail, Result.done));
+}
+
+/**
+ * @tsplus static fncts.query.QueryOps failCause
+ */
+export function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Query<never, E, never> {
+  return new Query(IO.succeed(Result.fail(cause())));
+}
+
+/**
+ * @tsplus static fncts.query.QueryOps failCauseNow
+ */
+export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Query<never, E, never> {
+  return new Query(IO.succeedNow(Result.fail(cause)));
+}
+
+/**
+ * @tsplus static fncts.query.QueryOps fail
+ */
+export function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Query<never, E, never> {
+  return Query.failCause(Cause.fail(e()));
+}
+
+/**
+ * @tsplus static fncts.query.QueryOps failNow
+ */
+export function failNow<E>(e: E, __tsplusTrace?: string): Query<never, E, never> {
+  return Query.failCauseNow(Cause.fail(e));
+}
+
+/**
+ * @tsplus static fncts.query.QueryOps halt
+ */
+export function halt(t: Lazy<unknown>, __tsplusTrace?: string): Query<never, never, never> {
+  return new Query(IO.halt(t));
+}
+
+/**
+ * @tsplus static fncts.query.QueryOps haltNow
+ */
+export function haltNow(t: unknown, __tsplusTrace?: string): Query<never, never, never> {
+  return new Query(IO.haltNow(t));
+}
+
+/**
+ * @tsplus static fncts.query.QueryOps succeed
+ */
+export function succeed<A>(value: Lazy<A>): Query<never, never, A> {
+  return new Query(IO.succeed(Result.done(value())));
+}
+
+/**
+ * @tsplus static fncts.query.QueryOps succeedNow
+ */
+export function succeedNow<A>(value: A): Query<never, never, A> {
+  return new Query(IO.succeedNow(Result.done(value)));
+}
+
+/**
+ * @tsplus static fncts.query.QueryOps unit
+ */
+export const unit: Query<never, never, void> = Query.succeedNow(undefined);

package/_src/Query/definition.ts

@@ -0,0 +1,13 @@
+import type { Result } from "@fncts/query/internal/Result";
+
+export const QueryTypeId = Symbol.for("fncts.query.Query");
+export type QueryTypeId = typeof QueryTypeId;
+
+/**
+ * @tsplus type fncts.query.Query
+ * @tsplus companion fncts.query.QueryOps
+ */
+export class Query<R, E, A> {
+  readonly [QueryTypeId]: QueryTypeId = QueryTypeId;
+  constructor(readonly step: IO<R, never, Result<R, E, A>>) {}
+}

package/_src/Query.ts

@@ -0,0 +1,35 @@
+// codegen:start { preset: barrel, include: ./Query/*.ts }
+export * from "./Query/api.js";
+export * from "./Query/definition.js";
+// codegen:end
+
+// codegen:start { preset: barrel, include: ./Query/api/*.ts }
+export * from "./Query/api/bimap.js";
+export * from "./Query/api/catchAllCause.js";
+export * from "./Query/api/collectAll.js";
+export * from "./Query/api/collectAllBatched.js";
+export * from "./Query/api/collectAllConcurrent.js";
+export * from "./Query/api/defer.js";
+export * from "./Query/api/ensuring.js";
+export * from "./Query/api/environment.js";
+export * from "./Query/api/flatMap.js";
+export * from "./Query/api/foreach.js";
+export * from "./Query/api/foreachBatched.js";
+export * from "./Query/api/foreachConcurrent.js";
+export * from "./Query/api/fromRequest.js";
+export * from "./Query/api/map.js";
+export * from "./Query/api/mapDataSources.js";
+export * from "./Query/api/mapError.js";
+export * from "./Query/api/mapErrorCause.js";
+export * from "./Query/api/mapIO.js";
+export * from "./Query/api/match.js";
+export * from "./Query/api/matchCauseQuery.js";
+export * from "./Query/api/matchQuery.js";
+export * from "./Query/api/orHalt.js";
+export * from "./Query/api/race.js";
+export * from "./Query/api/run.js";
+export * from "./Query/api/timeout.js";
+export * from "./Query/api/zipWith.js";
+export * from "./Query/api/zipWithBatched.js";
+export * from "./Query/api/zipWithConcurrent.js";
+// codegen:end

package/_src/QueryFailure.ts

@@ -0,0 +1,7 @@
+import { show } from "@fncts/base/data/Showable";
+
+export class QueryFailure extends Error {
+  constructor(readonly dataSource: DataSource<any, any>, request: Request<any, any>) {
+    super(`Data source ${dataSource.identifier} did not complete request ${show(request)}.`);
+  }
+}

package/_src/Request.ts

@@ -0,0 +1,52 @@
+import type { ShowComputationExternal } from "@fncts/base/data/Showable";
+
+import { CaseClassTypeId } from "@fncts/base/data/CaseClass";
+import { showComputationComplex, showProperty } from "@fncts/base/data/Showable";
+
+export const RequestTypeId = Symbol.for("fncts.query.Request");
+export type RequestTypeId = typeof RequestTypeId;
+
+export const RequestVariance = Symbol.for("fncts.query.Request.Variance");
+export type RequestVariance = typeof RequestVariance;
+
+export abstract class Request<E, A> {
+  readonly [RequestTypeId]: RequestTypeId = RequestTypeId;
+  declare [RequestVariance]: {
+    readonly _E: (_: never) => E;
+    readonly _A: (_: never) => A;
+  };
+}
+
+const simpleRequestHash = Hashable.string("fncts.query.Request.SimpleRequest");
+
+// @ts-expect-error
+export abstract class SimpleRequest<X extends Record<PropertyKey, any>, E, A> extends CaseClass<X> {
+  readonly [RequestTypeId]: RequestTypeId = RequestTypeId;
+  declare [RequestVariance]: {
+    readonly _E: (_: never) => E;
+    readonly _A: (_: never) => A;
+  };
+
+  get [Symbol.hash](): number {
+    return this[CaseClassTypeId].foldLeft(simpleRequestHash, (acc, k) =>
+      Hashable.combine(acc, Hashable.unknown(this[k])),
+    );
+  }
+
+  [Symbol.equals](that: unknown): boolean {
+    return Hashable.unknown(this) === Hashable.unknown(that);
+  }
+
+  get [Symbol.showable](): ShowComputationExternal {
+    return showComputationComplex({
+      base: Z.succeedNow(`Request (${this.constructor.name})`),
+      braces: ["{", "}"],
+      keys: this[CaseClassTypeId].traverse(Z.Applicative)((key) => showProperty(this, key, 0)).map(Conc.from),
+    });
+  }
+}
+
+export declare namespace Request {
+  type ErrorOf<X> = [X] extends [{ [RequestVariance]: { _E: (_: never) => infer E } }] ? E : never;
+  type ValueOf<X> = [X] extends [{ [RequestVariance]: { _A: (_: never) => infer A } }] ? A : never;
+}

package/_src/global.ts

@@ -0,0 +1,45 @@
+/**
+ * @tsplus global
+ */
+import type {} from "@fncts/base/global";
+/**
+ * @tsplus global
+ */
+import type {} from "@fncts/io/global";
+/**
+ * @tsplus global
+ */
+import type {} from "@fncts/query";
+
+/**
+ * @tsplus global
+ */
+import { Left, Right } from "@fncts/base/data/Either";
+/**
+ * @tsplus global
+ */
+import { Cache } from "@fncts/query/Cache";
+/**
+ * @tsplus global
+ */
+import { DataSource } from "@fncts/query/DataSource";
+/**
+ * @tsplus global
+ */
+import { DataSourceAspect } from "@fncts/query/DataSourceAspect";
+/**
+ * @tsplus global
+ */
+import { Continue } from "@fncts/query/internal/Continue";
+/**
+ * @tsplus global
+ */
+import { Result } from "@fncts/query/internal/Result";
+/**
+ * @tsplus global
+ */
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus global
+ */
+import { Request } from "@fncts/query/Request";

package/_src/index.ts

@@ -0,0 +1,3 @@
+// codegen:start { preset: type-barrel, include: ./*.ts }
+export type {} from "./global.js";
+// codegen:end

package/_src/internal/BlockedRequest.ts

@@ -0,0 +1,24 @@
+export const BlockedRequestTypeId = Symbol.for("fncts.query.BlockedRequest");
+export type BlockedRequestTypeId = typeof BlockedRequestTypeId;
+
+/**
+ * @tsplus type fncts.query.BlockedRequest
+ * @tsplus companion fncts.query.BlockedRequestOps
+ */
+export class BlockedRequest<A> {
+  readonly [BlockedRequestTypeId]: BlockedRequestTypeId = BlockedRequestTypeId;
+  constructor(
+    readonly request: Request<Request.ErrorOf<A>, Request.ValueOf<A>>,
+    readonly result: Ref<Maybe<Either<Request.ErrorOf<A>, Request.ValueOf<A>>>>,
+  ) {}
+}
+
+/**
+ * @tsplus static fncts.query.BlockedRequestOps make
+ */
+export function make<A extends Request<any, any>>(
+  request: A,
+  result: Ref<Maybe<Either<Request.ErrorOf<A>, Request.ValueOf<A>>>>,
+): BlockedRequest<A> {
+  return new BlockedRequest(request, result);
+}

package/_src/internal/BlockedRequests.ts

@@ -0,0 +1,331 @@
+import type { Sequential } from "./Sequential.js";
+import type { DataSource } from "@fncts/query/DataSource";
+import type { Described } from "@fncts/query/Described";
+import type { BlockedRequest } from "@fncts/query/internal/BlockedRequest";
+
+import { Parallel } from "./Parallel.js";
+
+export const BlockedRequestsTypeId = Symbol.for("fncts.query.BlockedRequests");
+export type BlockedRequestsTypeId = typeof BlockedRequestsTypeId;
+
+export const BlockedRequestsVariance = Symbol.for("fncts.query.BlockedRequests.Variance");
+export type BlockedRequestsVariance = typeof BlockedRequestsVariance;
+
+/**
+ * @tsplus type fncts.query.BlockedRequests
+ * @tsplus companion fncts.query.BlockedRequestsOps
+ */
+export abstract class BlockedRequests<R> {
+  readonly [BlockedRequestsTypeId]: BlockedRequestsTypeId = BlockedRequestsTypeId;
+  declare [BlockedRequestsVariance]: {
+    readonly _R: (_: never) => R;
+  };
+}
+
+export const enum BlockedRequestsTag {
+  Empty,
+  Single,
+  Then,
+  Both,
+}
+
+export class Empty extends BlockedRequests<never> {
+  readonly _tag = BlockedRequestsTag.Empty;
+}
+
+export class Single<R, A> extends BlockedRequests<R> {
+  readonly _tag = BlockedRequestsTag.Single;
+  constructor(readonly dataSource: DataSource<R, A>, readonly blockedRequest: BlockedRequest<A>) {
+    super();
+  }
+}
+
+export class Then<R> extends BlockedRequests<R> {
+  readonly _tag = BlockedRequestsTag.Then;
+  constructor(readonly left: BlockedRequests<R>, readonly right: BlockedRequests<R>) {
+    super();
+  }
+}
+
+export class Both<R> extends BlockedRequests<R> {
+  readonly _tag = BlockedRequestsTag.Both;
+  constructor(readonly left: BlockedRequests<R>, readonly right: BlockedRequests<R>) {
+    super();
+  }
+}
+
+const _Empty = new Empty();
+
+/**
+ * @tsplus static fncts.query.BlockedRequestsOps empty
+ */
+export function empty<R>(): BlockedRequests<R> {
+  return _Empty;
+}
+
+/**
+ * @tsplus static fncts.query.BlockedRequestsOps single
+ */
+export function single<R, A>(dataSource: DataSource<R, A>, blockedRequest: BlockedRequest<A>): BlockedRequests<R> {
+  return new Single(dataSource, blockedRequest);
+}
+
+/**
+ * @tsplus static fncts.query.BlockedRequestsOps then
+ */
+export function then<R>(left: BlockedRequests<R>, right: BlockedRequests<R>): BlockedRequests<R> {
+  return new Then(left, right);
+}
+
+/**
+ * @tsplus static fncts.query.BlockedRequestsOps both
+ */
+export function both<R>(left: BlockedRequests<R>, right: BlockedRequests<R>): BlockedRequests<R> {
+  return new Both(left, right);
+}
+
+type Concrete<R> = Empty | Single<R, any> | Then<R> | Both<R>;
+
+function concrete<R>(_: BlockedRequests<R>): asserts _ is Concrete<R> {
+  //
+}
+
+export abstract class BlockedRequestsFolder<R, Z> {
+  abstract readonly emptyCase: Z;
+  abstract singleCase<A>(dataSource: DataSource<R, A>, blockedRequest: BlockedRequest<A>): Z;
+  abstract bothCase(left: Z, right: Z): Z;
+  abstract thenCase(left: Z, right: Z): Z;
+}
+
+/**
+ * @tsplus pipeable fncts.query.BlockedRequests fold
+ */
+export function fold<R, Z>(folder: BlockedRequestsFolder<R, Z>) {
+  return (self: BlockedRequests<R>): Z => {
+    return foldLoop(folder, Cons(self), List.empty()).unsafeHead;
+  };
+}
+
+const enum BlockedRequestsCase {
+  BothCase,
+  ThenCase,
+}
+/**
+ * @tsplus tailRef
+ */
+function foldLoop<R, Z>(
+  folder: BlockedRequestsFolder<R, Z>,
+  inp: List<BlockedRequests<R>>,
+  out: List<Either<BlockedRequestsCase, Z>>,
+): List<Z> {
+  if (inp.isEmpty()) {
+    return out.foldLeft(List.empty(), (acc, r) =>
+      r.match(
+        (c) => {
+          const left            = acc.unsafeHead;
+          const right           = acc.unsafeTail.unsafeHead;
+          const blockedRequests = acc.unsafeTail.unsafeTail;
+          switch (c) {
+            case BlockedRequestsCase.BothCase: {
+              return Cons(folder.bothCase(left, right), blockedRequests);
+            }
+            case BlockedRequestsCase.ThenCase: {
+              return Cons(folder.thenCase(left, right), blockedRequests);
+            }
+          }
+        },
+        (z) => Cons(z, acc),
+      ),
+    );
+  } else {
+    const head = inp.head;
+    concrete(head);
+    switch (head._tag) {
+      case BlockedRequestsTag.Empty: {
+        return foldLoop(folder, inp.tail, Cons(Right(folder.emptyCase), out));
+      }
+      case BlockedRequestsTag.Single: {
+        return foldLoop(folder, inp.tail, Cons(Right(folder.singleCase(head.dataSource, head.blockedRequest)), out));
+      }
+      case BlockedRequestsTag.Both: {
+        return foldLoop(
+          folder,
+          Cons(head.left, Cons(head.right, inp.tail)),
+          Cons(Left(BlockedRequestsCase.BothCase), out),
+        );
+      }
+      case BlockedRequestsTag.Then: {
+        return foldLoop(
+          folder,
+          Cons(head.left, Cons(head.right, inp.tail)),
+          Cons(Left(BlockedRequestsCase.ThenCase), out),
+        );
+      }
+    }
+  }
+}
+
+export class MapDataSources<R> extends BlockedRequestsFolder<R, BlockedRequests<R>> {
+  constructor(readonly f: DataSourceAspect<R>) {
+    super();
+  }
+  emptyCase: BlockedRequests<R> = new Empty();
+  singleCase<A>(dataSource: DataSource<R, A>, blockedRequest: BlockedRequest<A>): BlockedRequests<R> {
+    return new Single(this.f.apply(dataSource), blockedRequest);
+  }
+  bothCase(left: BlockedRequests<R>, right: BlockedRequests<R>): BlockedRequests<R> {
+    return new Both(left, right);
+  }
+  thenCase(left: BlockedRequests<R>, right: BlockedRequests<R>): BlockedRequests<R> {
+    return new Then(left, right);
+  }
+}
+
+/**
+ * @tsplus pipeable fncts.query.BlockedRequests mapDataSources
+ */
+export function mapDataSources<R1>(f: DataSourceAspect<R1>) {
+  return <R>(self: BlockedRequests<R>): BlockedRequests<R | R1> => {
+    return self.fold(new MapDataSources<R | R1>(f));
+  };
+}
+
+export class ContramapEnvironment<R0, R> extends BlockedRequestsFolder<R, BlockedRequests<R0>> {
+  constructor(readonly f: Described<(_: Environment<R0>) => Environment<R>>) {
+    super();
+  }
+  emptyCase: BlockedRequests<R0> = new Empty();
+  singleCase<A>(dataSource: DataSource<R, A>, blockedRequest: BlockedRequest<A>): BlockedRequests<R0> {
+    return new Single(dataSource.contramapEnvironment(this.f), blockedRequest);
+  }
+  bothCase(left: BlockedRequests<R0>, right: BlockedRequests<R0>): BlockedRequests<R0> {
+    return new Both(left, right);
+  }
+  thenCase(left: BlockedRequests<R0>, right: BlockedRequests<R0>): BlockedRequests<R0> {
+    return new Then(left, right);
+  }
+}
+
+/**
+ * @tsplus pipeable fncts.query.BlockedRequests contramapEnvironment
+ */
+export function contramapEnvironment<R0, R>(
+  f: Described<(_: Environment<R0>) => Environment<R>>,
+  __tsplusTrace?: string,
+) {
+  return (self: BlockedRequests<R>): BlockedRequests<R0> => {
+    return self.fold(new ContramapEnvironment(f));
+  };
+}
+
+/**
+ * @tsplus getter fncts.query.BlockedRequests step
+ */
+export function step<R>(c: BlockedRequests<R>): readonly [Parallel<R>, List<BlockedRequests<R>>] {
+  return stepLoop(c, List.empty(), Parallel.empty, List.empty());
+}
+
+/**
+ * @tsplus tailRec
+ */
+function stepLoop<R>(
+  blockedRequests: BlockedRequests<R>,
+  stack: List<BlockedRequests<R>>,
+  parallel: Parallel<R>,
+  sequential: List<BlockedRequests<R>>,
+): readonly [Parallel<R>, List<BlockedRequests<R>>] {
+  concrete(blockedRequests);
+  switch (blockedRequests._tag) {
+    case BlockedRequestsTag.Empty: {
+      if (stack.isEmpty()) return [parallel, sequential];
+      else return stepLoop(stack.head, stack.tail, parallel, sequential);
+    }
+    case BlockedRequestsTag.Then: {
+      concrete(blockedRequests.left);
+      const { left, right } = blockedRequests;
+      switch (left._tag) {
+        case BlockedRequestsTag.Empty:
+          return stepLoop(right, stack, parallel, sequential);
+        case BlockedRequestsTag.Then:
+          return stepLoop(new Then(left.left, new Then(left.right, right)), stack, parallel, sequential);
+        case BlockedRequestsTag.Both:
+          return stepLoop(
+            new Both(new Then(left.left, right), new Then(left.right, right)),
+            stack,
+            parallel,
+            sequential,
+          );
+        case BlockedRequestsTag.Single:
+          return stepLoop(left, stack, parallel, Cons(right, sequential));
+      }
+    }
+    case BlockedRequestsTag.Both: {
+      return stepLoop(blockedRequests.left, Cons(blockedRequests.right, stack), parallel, sequential);
+    }
+    case BlockedRequestsTag.Single: {
+      if (stack.isEmpty())
+        return [parallel.concat(Parallel(blockedRequests.dataSource, blockedRequests.blockedRequest)), sequential];
+      else
+        return stepLoop(
+          stack.head,
+          stack.tail,
+          parallel.concat(Parallel(blockedRequests.dataSource, blockedRequests.blockedRequest)),
+          sequential,
+        );
+    }
+  }
+}
+
+/**
+ * @tsplus getter fncts.query.BlockedRequests flatten
+ */
+export function flatten<R>(blockedRequests: BlockedRequests<R>): List<Sequential<R>> {
+  return flattenLoop(List(blockedRequests), List.empty());
+}
+
+function flattenLoop<R>(
+  blockedRequests: List<BlockedRequests<R>>,
+  flattened: List<Sequential<R>>,
+): List<Sequential<R>> {
+  const [parallel, sequential] = blockedRequests.foldLeft(
+    [Parallel.empty as Parallel<R>, List.empty<BlockedRequests<R>>()] as const,
+    ([parallel, sequential], blockedRequest) => {
+      const [par, seq] = blockedRequest.step;
+      return [parallel.concat(par), sequential.concat(seq)] as const;
+    },
+  );
+  const updated = merge(flattened, parallel);
+  if (sequential.isEmpty()) return updated.reverse;
+  else return flattenLoop(sequential, updated);
+}
+
+function merge<R>(sequential: List<Sequential<R>>, parallel: Parallel<R>): List<Sequential<R>> {
+  if (sequential.isEmpty()) return List(parallel.sequential);
+  else if (parallel.isEmpty) return sequential;
+  else if (sequential.head.keys.size === 1 && parallel.keys.size === 1 && sequential.head.keys == parallel.keys)
+    return Cons(sequential.head.concat(parallel.sequential), sequential.tail);
+  else return Cons(parallel.sequential, sequential);
+}
+
+/**
+ * @tsplus getter fncts.query.BlockedRequests run
+ */
+export function run<R>(self: BlockedRequests<R>, __tsplusTrace?: string): IO<R, never, void> {
+  return Query.currentCache.get.flatMap((cache) =>
+    IO.foreachDiscard(self.flatten, (requestsByDataSource) =>
+      IO.foreachConcurrentDiscard(requestsByDataSource.toIterable, ([dataSource, sequential]) =>
+        Do((Δ) => {
+          const completedRequests = Δ(dataSource.runAll(sequential.map((br) => br.map((r) => r.request))));
+          const blockedRequests   = sequential.flatten;
+          const leftovers         = completedRequests.requests().removeMany(blockedRequests.map((br) => br.request));
+          Δ(IO.foreachDiscard(blockedRequests, (br) => br.result.set(completedRequests.lookup(br.request))));
+          Δ(
+            IO.foreachDiscard(leftovers, (request) =>
+              Ref.make(completedRequests.lookup(request)).flatMap((ref) => cache.put(request, ref)),
+            ),
+          );
+        }),
+      ),
+    ),
+  );
+}