@effect-app/infra 0.211.1 → 0.211.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/infra",
-  "version": "0.211.1",
+  "version": "0.211.2",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -19,10 +19,10 @@
     "pure-rand": "6.0.4",
     "redlock": "^4.2.0",
     "@effect-app/core": "0.150.5",
-    "@effect-app/schema": "0.203.4",
-    "@effect-app/infra-adapters": "0.137.19",
+    "effect-app": "0.181.8",
     "@effect-app/fluent-extensions": "0.143.4",
-    "effect-app": "0.181.8"
+    "@effect-app/infra-adapters": "0.137.19",
+    "@effect-app/schema": "0.203.4"
   },
   "devDependencies": {
     "@babel/cli": "^7.23.9",

package/src/services/Repository/ext.ts

@@ -1,17 +1,14 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 // Update = Must return updated items
 // Modify = Must `set` updated items, and can return anything.
-import { toNonEmptyArray } from "@effect-app/core/Array"
-import { NonNegativeInt } from "@effect-app/schema"
 import { Effect, ReadonlyArray } from "effect-app"
-import type { NonEmptyArray, NonEmptyReadonlyArray, Option } from "effect-app"
-import { type FixEnv, type PureEnv, runTerm } from "effect-app/Pure"
-import type { InvalidStateError, OptimisticConcurrencyException } from "../../errors.js"
+import type { NonEmptyArray } from "effect-app"
+import { type FixEnv, runTerm } from "effect-app/Pure"
 import { NotFoundError } from "../../errors.js"
-import type { Filter, PersistenceModelType } from "../../services/Store.js"
+import type { PersistenceModelType } from "../../services/Store.js"
 import type { RepositoryBaseC } from "../RepositoryBase.js"
-import type { QueryBuilder } from "../Store/filterApi/query.js"
 import { AnyPureDSL } from "./dsl.js"
+import type { Repository } from "./service.js"
 
 /**
  * @tsplus fluent Repository get
@@ -42,435 +39,6 @@ export function log<
   return (evt: Evt) => AnyPureDSL.log(evt)
 }
 
-/**
- * TODO: project inside the db.
- * @tsplus fluent Repository projectEffect
- */
-export function projectEffect<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  R,
-  E,
-  S = PM
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  map: Effect<
-    {
-      filter?: Filter<PM> | undefined
-      collect?: ((t: PM) => Option<S>) | undefined
-      limit?: number | undefined
-      skip?: number | undefined
-    },
-    E,
-    R
-  >
-): Effect<S[], E, R>
-export function projectEffect<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  R,
-  E,
-  U extends keyof PM,
-  S = PM
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  map: Effect<
-    {
-      filter?: QueryBuilder<PM> | undefined
-      collect?: ((t: PM) => Option<S>) | undefined
-      limit?: number | undefined
-      skip?: number | undefined
-    },
-    E,
-    R
-  >
-): Effect<Pick<PM, U>[], E, R>
-export function projectEffect<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  R,
-  E,
-  U extends keyof PM,
-  S = Pick<PM, U>
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  map: Effect<
-    {
-      filter?: Filter<PM> | undefined
-      select?: NonEmptyReadonlyArray<U> | undefined
-      collect?: ((t: PM) => Option<S>) | undefined
-      limit?: number | undefined
-      skip?: number | undefined
-    },
-    E,
-    R
-  >
-): Effect<S[], E, R> {
-  // TODO: a projection that gets sent to the db instead.
-  return Effect.flatMap(map, (f) =>
-    self
-      .utils
-      .filter(f)
-      .pipe(Effect.map((_) => f.collect ? ReadonlyArray.filterMap(_, f.collect) : _ as unknown as S[])))
-}
-
-/**
- * TODO: project inside the db.
- * @tsplus fluent Repository project
- */
-export function project<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  S = PM
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  map: {
-    filter?: Filter<PM>
-    collect?: (t: PM) => Option<S>
-    limit?: number
-    skip?: number
-  }
-): Effect<S[]>
-export function project<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  U extends keyof PM
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  map: {
-    filter?: QueryBuilder<PM>
-    select: NonEmptyReadonlyArray<U>
-    limit?: number
-    skip?: number
-  }
-): Effect<Pick<PM, U>[]>
-export function project<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  U extends keyof PM,
-  S = Pick<PM, U>
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  map: {
-    filter?: Filter<PM>
-    select?: NonEmptyReadonlyArray<U>
-    collect?: (t: Pick<PM, U>) => Option<S>
-    limit?: number
-    skip?: number
-  }
-): Effect<S[]> {
-  return projectEffect(self, Effect.sync(() => map))
-}
-
-/**
- * TODO: count inside the db.
- * @tsplus fluent Repository project
- */
-export function count<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  filter?: Filter<PM>
-) {
-  return projectEffect(self, Effect.sync(() => ({ filter })))
-    .pipe(Effect.map((_) => NonNegativeInt(_.length)))
-}
-
-/**
- * @tsplus fluent Repository queryEffect
- */
-export function queryEffect<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  R,
-  E,
-  S = T
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  // TODO: think about collectPM, collectE, and collect(Parsed)
-  map: Effect<{ filter?: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }, E, R>
-) {
-  return Effect.flatMap(map, (f) =>
-    (f.filter ? self.utils.filter(f) : self.utils.all)
-      .pipe(
-        Effect.flatMap((_) => self.utils.parseMany(_)),
-        Effect.map((_) => f.collect ? ReadonlyArray.filterMap(_, f.collect) : _ as unknown[] as S[])
-      ))
-}
-
-/**
- * @tsplus fluent Repository queryOneEffect
- */
-export function queryOneEffect<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  R,
-  E
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  // TODO: think about collectPM, collectE, and collect(Parsed)
-  map: Effect<{ filter?: Filter<PM> }, E, R>
-): Effect<T, E | NotFoundError<ItemType>, R>
-export function queryOneEffect<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  R,
-  E,
-  S = T
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  // TODO: think about collectPM, collectE, and collect(Parsed)
-  map: Effect<{ filter?: Filter<PM>; collect: (t: T) => Option<S> }, E, R>
-): Effect<S, E | NotFoundError<ItemType>, R>
-export function queryOneEffect<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  R,
-  E,
-  S = T
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  // TODO: think about collectPM, collectE, and collect(Parsed)
-  map: Effect<{ filter?: Filter<PM>; collect?: (t: T) => Option<S> }, E, R>
-): Effect<S, E | NotFoundError<ItemType>, R> {
-  return Effect.flatMap(map, (f) =>
-    (f.filter ? self.utils.filter({ filter: f.filter, limit: 1 }) : self.utils.all)
-      .pipe(
-        Effect.flatMap((_) => self.utils.parseMany(_)),
-        Effect
-          .flatMap((_) =>
-            toNonEmptyArray(
-              f.collect
-                ? ReadonlyArray.filterMap(_, f.collect)
-                : _ as unknown[] as S[]
-            )
-              .pipe(
-                Effect.mapError(() => new NotFoundError<ItemType>({ type: self.itemType, id: f.filter })),
-                Effect
-                  .map((_) => _[0])
-              )
-          )
-      ))
-}
-
-/**
- * @tsplus fluent Repository query
- */
-export function query<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  S = T
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  // TODO: think about collectPM, collectE, and collect(Parsed)
-  map: { filter?: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }
-) {
-  return queryEffect(self, Effect.sync(() => map))
-}
-
-/**
- * @tsplus fluent Repository queryOne
- */
-export function queryOne<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  S = T
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  map: { filter?: Filter<PM>; collect: (t: T) => Option<S> }
-): Effect<S, NotFoundError<ItemType>>
-export function queryOne<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  map: { filter?: Filter<PM> }
-): Effect<T, NotFoundError<ItemType>>
-export function queryOne<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  S = T
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  map: { filter?: Filter<PM>; collect?: (t: T) => Option<S> }
-) {
-  return queryOneEffect(self, Effect.sync(() => map))
-}
-
-/**
- * @tsplus fluent Repository queryAndSaveOnePureEffect
- */
-export function queryAndSaveOnePureEffect<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  R,
-  E,
-  S extends T = T
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  map: Effect<{ filter: Filter<PM>; collect: (t: T) => Option<S>; limit?: number; skip?: number }, E, R>
-): <R2, A, E2, S2 extends T>(
-  pure: Effect<A, E2, FixEnv<R2, Evt, S, S2>>
-) => Effect<
-  A,
-  InvalidStateError | OptimisticConcurrencyException | E | E2 | NotFoundError<ItemType>,
-  | R
-  | Exclude<R2, {
-    env: PureEnv<Evt, S, S2>
-  }>
->
-export function queryAndSaveOnePureEffect<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  R,
-  E
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  map: Effect<{ filter: Filter<PM> }, E, R>
-): <R2, A, E2, T2 extends T>(
-  pure: Effect<A, E2, FixEnv<R2, Evt, T, T2>>
-) => Effect<
-  A,
-  InvalidStateError | OptimisticConcurrencyException | E | E2 | NotFoundError<ItemType>,
-  | R
-  | Exclude<R2, {
-    env: PureEnv<Evt, T, T2>
-  }>
->
-export function queryAndSaveOnePureEffect(
-  self: any,
-  map: any
-) {
-  return (pure: any) =>
-    queryOneEffect(self, map)
-      .pipe(Effect.flatMap((_) => saveWithPure_(self, _, pure)))
-}
-
-/**
- * @tsplus fluent Repository queryAndSaveOnePure
- */
-export function queryAndSaveOnePure<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  S extends T = T
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  map: { filter: Filter<PM>; collect: (t: T) => Option<S>; limit?: number; skip?: number }
-): <R2, A, E2, S2>(pure: Effect<A, E2, FixEnv<R2, Evt, S, S2>>) => Effect<
-  A,
-  InvalidStateError | OptimisticConcurrencyException | E2 | NotFoundError<ItemType>,
-  Exclude<R2, {
-    env: PureEnv<Evt, S, S2>
-  }>
->
-export function queryAndSaveOnePure<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  map: { filter: Filter<PM> }
-): <R2, A, E2, T2>(pure: Effect<A, E2, FixEnv<R2, Evt, T, T2>>) => Effect<
-  A,
-  InvalidStateError | OptimisticConcurrencyException | E2 | NotFoundError<ItemType>,
-  Exclude<R2, {
-    env: PureEnv<Evt, T, T2>
-  }>
->
-export function queryAndSaveOnePure(
-  self: any,
-  map: { filter: Filter<any>; collect?: any }
-) {
-  return queryAndSaveOnePureEffect(self, Effect.sync(() => map))
-}
-
-/**
- * @tsplus fluent Repository queryAndSavePureEffect
- */
-export function queryAndSavePureEffect<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  R,
-  E,
-  S extends T = T
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  map: Effect<{ filter: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }, E, R>
-) {
-  return <R2, A, E2, S2 extends T>(pure: Effect<A, E2, FixEnv<R2, Evt, readonly S[], readonly S2[]>>) =>
-    queryEffect(self, map)
-      .pipe(Effect.flatMap((_) => saveManyWithPure_(self, _, pure)))
-}
-
-/**
- * @tsplus fluent Repository queryAndSavePure
- */
-export function queryAndSavePure<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  S extends T = T
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  map: { filter: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }
-) {
-  return queryAndSavePureEffect(self, Effect.sync(() => map))
-}
-
-/**
- * @tsplus getter Repository saveManyWithPure
- */
-export function saveManyWithPure<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string
->(self: RepositoryBaseC<T, PM, Evt, ItemType>) {
-  return <R, A, E, S1 extends T, S2 extends T>(pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>) =>
-  (items: Iterable<S1>) => saveManyWithPure_(self, items, pure)
-}
-
 /**
  * @tsplus fluent Repository byIdAndSaveWithPure
  */
@@ -566,46 +134,6 @@ export function saveAllWithEffectInt<
   return Effect.flatMap(gen, ([items, events, a]) => self.saveAndPublish(items, events).pipe(Effect.map(() => a)))
 }
 
-/**
- * @tsplus fluent Repository queryAndSavePureEffectBatched
- */
-export function queryAndSavePureEffectBatched<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  R,
-  E,
-  S extends T = T
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  // TODO: think about collectPM, collectE, and collect(Parsed)
-  map: Effect<{ filter: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }, E, R>,
-  batchSize = 100
-) {
-  return <R2, A, E2, S2 extends T>(pure: Effect<A, E2, FixEnv<R2, Evt, readonly S[], readonly S2[]>>) =>
-    queryEffect(self, map)
-      .pipe(Effect.flatMap((_) => saveManyWithPureBatched_(self, _, pure, batchSize)))
-}
-
-/**
- * @tsplus fluent Repository queryAndSavePureBatched
- */
-export function queryAndSavePureBatched<
-  T extends { id: unknown },
-  PM extends PersistenceModelType<string>,
-  Evt,
-  ItemType extends string,
-  S extends T = T
->(
-  self: RepositoryBaseC<T, PM, Evt, ItemType>,
-  // TODO: think about collectPM, collectE, and collect(Parsed)
-  map: { filter: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number },
-  batchSize = 100
-) {
-  return queryAndSavePureEffectBatched(self, Effect.sync(() => map), batchSize)
-}
-
 /**
  * @tsplus fluent Repository saveManyWithPureBatched
  */
@@ -713,3 +241,19 @@ export function itemUpdate<
     (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 extends { id: unknown },
+  PM extends PersistenceModelType<string>,
+  Evt,
+  ItemType extends string
+>(
+  self: Repository<T, PM, Evt, ItemType>,
+  id: T["id"]
+) {
+  return get(self, id).pipe(Effect.flatMap((_) => self.removeAndPublish([_])))
+}