@effect-app/infra 2.3.5 → 2.4.0

package/src/services/Repository/ext.ts

@@ -1,272 +1,291 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-// Update = Must return updated items
-// Modify = Must `set` updated items, and can return anything.
-import { Array, Effect } from "effect-app"
-import type { NonEmptyArray } from "effect-app"
-import { type FixEnv, runTerm } from "effect-app/Pure"
-import { NotFoundError } from "../../errors.js"
-import type { RepositoryBaseC } from "../RepositoryBase.js"
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+import type { NonEmptyArray, NonEmptyReadonlyArray } from "effect-app"
+import { Array, Effect, Exit, Option, Request, RequestResolver } from "effect-app"
+import type { InvalidStateError, OptimisticConcurrencyException } from "effect-app/client"
+import { NotFoundError } from "effect-app/client"
+import type { FixEnv, PureEnv } from "effect-app/Pure"
+import { runTerm } from "effect-app/Pure"
+import type { Query, QueryEnd, QueryWhere } from "../query.js"
+import * as Q from "../query.js"
 import { AnyPureDSL } from "./dsl.js"
 import type { Repository } from "./service.js"
 
-/**
- * @tsplus fluent Repository get
- */
-export function get<
-  T,
-  Encoded extends { id: string },
-  Evt,
-  ItemType extends string,
-  IdKey extends keyof T
->(
-  self: RepositoryBaseC<T, Encoded, Evt, ItemType, IdKey>,
-  id: T[IdKey]
-) {
-  return self
-    .find(id)
-    .pipe(Effect.flatMap((_) => Effect.mapError(_, () => new NotFoundError<ItemType>({ type: self.itemType, id }))))
-}
+export const extendRepo = <T, Encoded extends { id: string }, Evt, ItemType extends string, IdKey extends keyof T>(
+  repo: Repository<T, Encoded, Evt, ItemType, IdKey>
+) => {
+  const get = (id: T[IdKey]) =>
+    Effect.flatMap(
+      repo.find(id),
+      (_) => Effect.mapError(_, () => new NotFoundError<ItemType>({ type: repo.itemType, id }))
+    )
+  function saveManyWithPure_<
+    R,
+    T,
+    Encoded extends { id: string },
+    A,
+    E,
+    Evt,
+    S1 extends T,
+    S2 extends T,
+    ItemType extends string,
+    IdKey extends keyof T
+  >(
+    self: Repository<T, Encoded, Evt, ItemType, IdKey>,
+    items: Iterable<S1>,
+    pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>
+  ) {
+    return saveAllWithEffectInt(
+      self,
+      runTerm(pure, [...items])
+    )
+  }
 
-/**
- * @tsplus getter Repository log
- */
-export function log<
-  T,
-  Encoded extends { id: string },
-  Evt,
-  ItemType extends string,
-  IdKey extends keyof T
->(_: RepositoryBaseC<T, Encoded, Evt, ItemType, IdKey>) {
-  return (evt: Evt) => AnyPureDSL.log(evt)
-}
+  function saveWithPure_<
+    R,
+    T,
+    Encoded extends { id: string },
+    A,
+    E,
+    Evt,
+    S1 extends T,
+    S2 extends T,
+    ItemType extends string,
+    IdKey extends keyof T
+  >(
+    self: Repository<T, Encoded, Evt, ItemType, IdKey>,
+    item: S1,
+    pure: Effect<A, E, FixEnv<R, Evt, S1, S2>>
+  ) {
+    return saveAllWithEffectInt(
+      self,
+      runTerm(pure, item)
+        .pipe(Effect
+          .map(([item, events, a]) => [[item], events, a]))
+    )
+  }
 
-/**
- * @tsplus fluent Repository byIdAndSaveWithPure
- */
-export function byIdAndSaveWithPure<
-  T,
-  Encoded extends { id: string },
-  Evt,
-  ItemType extends string,
-  IdKey extends keyof T
->(self: RepositoryBaseC<T, Encoded, Evt, ItemType, IdKey>, id: T[IdKey]) {
-  return <R, A, E, S2 extends T>(pure: Effect<A, E, FixEnv<R, Evt, T, S2>>) =>
-    get(self, id).pipe(Effect.flatMap((item) => saveWithPure_(self, item, pure)))
-}
+  function saveAllWithEffectInt<
+    T,
+    Encoded extends { id: string },
+    P extends T,
+    Evt,
+    ItemType extends string,
+    IdKey extends keyof T,
+    R,
+    E,
+    A
+  >(
+    self: Repository<T, Encoded, Evt, ItemType, IdKey>,
+    gen: Effect<readonly [Iterable<P>, Iterable<Evt>, A], E, R>
+  ) {
+    return Effect.flatMap(gen, ([items, events, a]) => self.saveAndPublish(items, events).pipe(Effect.map(() => a)))
+  }
 
-/**
- * NOTE: it's not as composable, only useful when the request is simple, and only this part needs request args.
- * @tsplus getter Repository handleByIdAndSaveWithPure
- */
-export function handleByIdAndSaveWithPure<
-  T,
-  Encoded extends { id: string },
-  Evt,
-  ItemType extends string,
-  IdKey extends keyof T
->(self: RepositoryBaseC<T, Encoded, Evt, ItemType, IdKey>) {
-  return <Req extends { id: T[IdKey] }, Context, R, A, E, S2 extends T>(
-    pure: (req: Req, ctx: Context) => Effect<A, E, FixEnv<R, Evt, T, S2>>
-  ) =>
-  (req: Req, ctx: Context) => byIdAndSaveWithPure(self, req.id)(pure(req, ctx))
-}
+  function saveManyWithPureBatched_<
+    R,
+    T,
+    Encoded extends { id: string },
+    A,
+    E,
+    Evt,
+    S1 extends T,
+    S2 extends T,
+    ItemType extends string,
+    IdKey extends keyof T
+  >(
+    self: Repository<T, Encoded, Evt, ItemType, IdKey>,
+    items: Iterable<S1>,
+    pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>,
+    batchSize = 100
+  ) {
+    return Effect.forEach(
+      Array.chunk_(items, batchSize),
+      (batch) =>
+        saveAllWithEffectInt(
+          self,
+          runTerm(pure, batch)
+        )
+    )
+  }
 
-/**
- * @tsplus fluent Repository saveManyWithPure_
- */
-export function saveManyWithPure_<
-  R,
-  T,
-  Encoded extends { id: string },
-  A,
-  E,
-  Evt,
-  S1 extends T,
-  S2 extends T,
-  ItemType extends string,
-  IdKey extends keyof T
->(
-  self: RepositoryBaseC<T, Encoded, Evt, ItemType, IdKey>,
-  items: Iterable<S1>,
-  pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>
-) {
-  return saveAllWithEffectInt(
-    self,
-    runTerm(pure, [...items])
-  )
-}
+  const queryAndSavePure: {
+    <A, E2, R2, T2 extends T>(
+      q: (
+        q: Query<Encoded>
+      ) => QueryEnd<Encoded, "one">,
+      pure: Effect<A, E2, FixEnv<R2, Evt, T, T2>>
+    ): Effect.Effect<
+      A,
+      InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | E2,
+      Exclude<R2, {
+        env: PureEnv<Evt, T, T2>
+      }>
+    >
+    <A, E2, R2, T2 extends T>(
+      q: (
+        q: Query<Encoded>
+      ) =>
+        | Query<Encoded>
+        | QueryWhere<Encoded>
+        | QueryEnd<Encoded, "many">,
+      pure: Effect<A, E2, FixEnv<R2, Evt, readonly T[], readonly T2[]>>
+    ): Effect.Effect<
+      A,
+      InvalidStateError | OptimisticConcurrencyException | E2,
+      Exclude<R2, {
+        env: PureEnv<Evt, readonly T[], readonly T2[]>
+      }>
+    >
+    <A, E2, R2, T2 extends T>(
+      q: (
+        q: Query<Encoded>
+      ) =>
+        | Query<Encoded>
+        | QueryWhere<Encoded>
+        | QueryEnd<Encoded, "many">,
+      pure: Effect<A, E2, FixEnv<R2, Evt, readonly T[], readonly T2[]>>,
+      batch: "batched" | number
+    ): Effect.Effect<
+      A[],
+      InvalidStateError | OptimisticConcurrencyException | E2,
+      Exclude<R2, {
+        env: PureEnv<Evt, readonly T[], readonly T2[]>
+      }>
+    >
+  } = (q, pure, batch?: "batched" | number) =>
+    repo.query(q).pipe(
+      Effect.andThen((_) =>
+        Array.isArray(_)
+          ? batch === undefined
+            ? saveManyWithPure_(repo, _ as any, pure as any)
+            : saveManyWithPureBatched_(repo, _ as any, pure as any, batch === "batched" ? 100 : batch)
+          : saveWithPure_(repo, _ as any, pure as any)
+      )
+    ) as any
 
-/**
- * @tsplus fluent Repository saveWithPure_
- */
-export function saveWithPure_<
-  R,
-  T,
-  Encoded extends { id: string },
-  A,
-  E,
-  Evt,
-  S1 extends T,
-  S2 extends T,
-  ItemType extends string,
-  IdKey extends keyof T
->(
-  self: RepositoryBaseC<T, Encoded, Evt, ItemType, IdKey>,
-  item: S1,
-  pure: Effect<A, E, FixEnv<R, Evt, S1, S2>>
-) {
-  return saveAllWithEffectInt(
-    self,
-    runTerm(pure, item)
-      .pipe(Effect
-        .map(([item, events, a]) => [[item], events, a]))
-  )
-}
+  const saveManyWithPure: {
+    <R, A, E, S1 extends T, S2 extends T>(
+      items: Iterable<S1>,
+      pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>
+    ): Effect.Effect<
+      A,
+      InvalidStateError | OptimisticConcurrencyException | E,
+      Exclude<R, {
+        env: PureEnv<Evt, readonly S1[], readonly S2[]>
+      }>
+    >
+    <R, A, E, S1 extends T, S2 extends T>(
+      items: Iterable<S1>,
+      pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>,
+      batch: "batched" | number
+    ): Effect.Effect<
+      A[],
+      InvalidStateError | OptimisticConcurrencyException | E,
+      Exclude<R, {
+        env: PureEnv<Evt, readonly S1[], readonly S2[]>
+      }>
+    >
+  } = (items, pure, batch?: "batched" | number) =>
+    batch
+      ? Effect.forEach(
+        Array.chunk_(items, batch === "batched" ? 100 : batch),
+        (batch) =>
+          saveAllWithEffectInt(
+            repo,
+            runTerm(pure, batch)
+          )
+      )
+      : saveAllWithEffectInt(
+        repo,
+        runTerm(pure, [...items])
+      )
 
-export function saveAllWithEffectInt<
-  T,
-  Encoded extends { id: string },
-  P extends T,
-  Evt,
-  ItemType extends string,
-  IdKey extends keyof T,
-  R,
-  E,
-  A
->(
-  self: RepositoryBaseC<T, Encoded, Evt, ItemType, IdKey>,
-  gen: Effect<readonly [Iterable<P>, Iterable<Evt>, A], E, R>
-) {
-  return Effect.flatMap(gen, ([items, events, a]) => self.saveAndPublish(items, events).pipe(Effect.map(() => a)))
-}
+  const byIdAndSaveWithPure: {
+    <R, A, E, S2 extends T>(
+      id: T[IdKey],
+      pure: Effect<A, E, FixEnv<R, Evt, T, S2>>
+    ): Effect<
+      A,
+      InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | E,
+      Exclude<R, {
+        env: PureEnv<Evt, T, S2>
+      }>
+    >
+  } = (id, pure): any => get(id).pipe(Effect.flatMap((item) => saveWithPure_(repo, item, pure)))
 
-/**
- * @tsplus fluent Repository saveManyWithPureBatched
- */
-export function saveManyWithPureBatched<
-  T,
-  Encoded extends { id: string },
-  Evt,
-  ItemType extends string,
-  IdKey extends keyof T
->(self: RepositoryBaseC<T, Encoded, Evt, ItemType, IdKey>, batchSize = 100) {
-  return <R, A, E, S1 extends T, S2 extends T>(pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>) =>
-  (items: Iterable<S1>) => saveManyWithPureBatched_(self, items, pure, batchSize)
-}
+  type Req =
+    & Request.Request<T, NotFoundError<ItemType>>
+    & { _tag: `Get${ItemType}`; id: T[IdKey] }
+  const _request = Request.tagged<Req>(`Get${repo.itemType}`)
 
-/**
- * @tsplus fluent Repository saveManyWithPureBatched_
- */
-export function saveManyWithPureBatched_<
-  R,
-  T,
-  Encoded extends { id: string },
-  A,
-  E,
-  Evt,
-  S1 extends T,
-  S2 extends T,
-  ItemType extends string,
-  IdKey extends keyof T
->(
-  self: RepositoryBaseC<T, Encoded, Evt, ItemType, IdKey>,
-  items: Iterable<S1>,
-  pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>,
-  batchSize = 100
-) {
-  return Effect.forEach(
-    Array.chunk_(items, batchSize),
-    (batch) =>
+  const requestResolver = RequestResolver
+    .makeBatched((
+      requests: NonEmptyReadonlyArray<Req>
+    ) =>
+      (repo.query(Q.where("id", "in", requests.map((_) => _.id)) as any) as Effect<readonly T[], never>)
+        // TODO
+        .pipe(
+          Effect.andThen((items) =>
+            Effect.forEach(requests, (r) =>
+              Request.complete(
+                r,
+                Array
+                  .findFirst(items, (_) => _[repo.idKey] === r.id)
+                  .pipe(Option.match({
+                    onNone: () => Exit.fail(new NotFoundError({ type: repo.itemType, id: r.id })),
+                    onSome: Exit.succeed
+                  }))
+              ), { discard: true })
+          ),
+          Effect
+            .catchAllCause((cause) =>
+              Effect.forEach(requests, Request.complete(Exit.failCause(cause)), { discard: true })
+            )
+        )
+    )
+    .pipe(
+      RequestResolver.batchN(20)
+    )
+
+  const exts = {
+    request: (id: T[IdKey]) => Effect.request(_request({ id }), requestResolver),
+    get,
+    log: (evt: Evt) => AnyPureDSL.log(evt),
+    removeById: (id: T[IdKey]) => Effect.andThen(get(id), (_) => repo.removeAndPublish([_])),
+    save: (...items: NonEmptyArray<T>) => repo.saveAndPublish(items),
+    saveWithEvents: (events: Iterable<Evt>) => (...items: NonEmptyArray<T>) => repo.saveAndPublish(items, events),
+    queryAndSavePure,
+    saveManyWithPure,
+    byIdAndSaveWithPure,
+    saveWithPure: <
+      R,
+      A,
+      E,
+      S1 extends T,
+      S2 extends T
+    >(
+      item: S1,
+      pure: Effect<A, E, FixEnv<R, Evt, S1, S2>>
+    ) =>
       saveAllWithEffectInt(
-        self,
-        runTerm(pure, batch)
+        repo,
+        runTerm(pure, item)
+          .pipe(Effect.map(([item, events, a]) => [[item], events, a]))
       )
-  )
-}
+  }
 
-/**
- * @tsplus getter Repository save
- */
-export function save<
-  T,
-  Encoded extends { id: string },
-  Evt,
-  ItemType extends string,
-  IdKey extends keyof T
->(
-  self: RepositoryBaseC<T, Encoded, Evt, ItemType, IdKey>
-) {
-  return (...items: NonEmptyArray<T>) => self.saveAndPublish(items)
+  return {
+    ...repo,
+    ...exts
+  } as Repository<T, Encoded, Evt, ItemType, IdKey> & typeof exts
 }
 
-/**
- * @tsplus getter Repository saveWithEvents
- */
-export function saveWithEvents<
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface ExtendedRepository<
   T,
   Encoded extends { id: string },
   Evt,
   ItemType extends string,
   IdKey extends keyof T
->(
-  self: RepositoryBaseC<T, Encoded, Evt, ItemType, IdKey>
-) {
-  return (events: Iterable<Evt>) => (...items: NonEmptyArray<T>) => self.saveAndPublish(items, events)
-}
-
-/**
- * @tsplus fluent Repository updateWithEffect
- */
-export function itemUpdateWithEffect<
-  R,
-  E,
-  T extends { id: string },
-  Encoded extends { id: string },
-  Evt,
-  ItemType extends string,
-  IdKey extends keyof T
->(
-  repo: RepositoryBaseC<T, Encoded, Evt, ItemType, IdKey>,
-  id: T[IdKey],
-  mod: (item: T) => Effect<T, E, R>
-) {
-  return get(repo, id).pipe(Effect.andThen(mod), Effect.andThen(save(repo)))
-}
-
-/**
- * @tsplus fluent Repository update
- */
-export function itemUpdate<
-  T extends { id: string },
-  Encoded extends { id: string },
-  Evt,
-  ItemType extends string,
-  IdKey extends keyof T
->(
-  repo: RepositoryBaseC<T, Encoded, Evt, ItemType, IdKey>,
-  id: T[IdKey],
-  mod: (item: T) => T
-) {
-  return itemUpdateWithEffect(
-    repo,
-    id,
-    (item) => Effect.sync(() => mod(item))
-  )
-}
-
-/**
- * only use this as a shortcut if you don't have the item already
- * @tsplus fluent Repository removeById
- */
-export function removeById<
-  T,
-  Encoded extends { id: string },
-  Evt,
-  ItemType extends string,
-  IdKey extends keyof T
->(
-  self: Repository<T, Encoded, Evt, ItemType, IdKey>,
-  id: T[IdKey]
-) {
-  return get(self, id).pipe(Effect.flatMap((_) => self.removeAndPublish([_])))
-}
+> extends ReturnType<typeof extendRepo<T, Encoded, Evt, ItemType, IdKey>> {}