@effect-app/infra 2.6.0 → 2.7.0

package/src/services/Repository/legacy.ts

@@ -2,13 +2,16 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 import type { NonEmptyReadonlyArray, Option, ParseResult, S } from "effect-app"
 import { Context, Effect, Layer } from "effect-app"
-import type { NotFoundError, OptimisticConcurrencyException } from "effect-app/client"
+import type { InvalidStateError, NotFoundError, OptimisticConcurrencyException } from "effect-app/client"
+import type { FixEnv, PureEnv } from "effect-app/Pure"
+import type { NonNegativeInt } from "effect-app/Schema"
+import type { FieldValues } from "../../filter/types.js"
 import * as Q from "../query.js"
 import type { Repos } from "../RepositoryBase.js"
 import { makeRepoInternal } from "../RepositoryBase.js"
 import type { StoreConfig, StoreMaker } from "../Store.js"
 import { type ExtendedRepository, extendRepo } from "./ext.js"
-import type { Repository } from "./service.js"
+import type { RefineTHelper, Repository } from "./service.js"
 
 const names = new Map<string, number>()
 const registerName = (name: string) => {
@@ -23,6 +26,177 @@ const registerName = (name: string) => {
   }
 }
 
+/**
+ * @deprecated
+ */
+export interface RepoFunctions<T, Encoded extends { id: string }, Evt, ItemType, IdKey extends keyof T, Service> {
+  itemType: ItemType
+  T: T
+  all: Effect<readonly T[], never, Service>
+  find: (id: T[IdKey]) => Effect<Option<T>, never, Service>
+  removeById: (id: T[IdKey]) => Effect<void, NotFoundError<ItemType>, Service>
+  saveAndPublish: (
+    items: Iterable<T>,
+    events?: Iterable<Evt>
+  ) => Effect<void, InvalidStateError | OptimisticConcurrencyException, Service>
+  removeAndPublish: (
+    items: Iterable<T>,
+    events?: Iterable<Evt>
+  ) => Effect<void, never, Service>
+  save: (...items: T[]) => Effect<void, InvalidStateError | OptimisticConcurrencyException, Service>
+  get: (id: T[IdKey]) => Effect<T, NotFoundError<ItemType>, Service>
+  queryAndSavePure: {
+    <A, E2, R2, T2 extends T>(
+      q: (
+        q: Q.Query<Encoded>
+      ) => Q.QueryEnd<Encoded, "one">,
+      pure: Effect<A, E2, FixEnv<R2, Evt, T, T2>>
+    ): Effect.Effect<
+      A,
+      InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | E2,
+      | Service
+      | Exclude<R2, {
+        env: PureEnv<Evt, T, T2>
+      }>
+    >
+    <A, E2, R2, T2 extends T>(
+      q: (
+        q: Q.Query<Encoded>
+      ) =>
+        | Q.Query<Encoded>
+        | Q.QueryWhere<Encoded>
+        | Q.QueryEnd<Encoded, "many">,
+      pure: Effect<A, E2, FixEnv<R2, Evt, readonly T[], readonly T2[]>>
+    ): Effect.Effect<
+      A,
+      InvalidStateError | OptimisticConcurrencyException | E2,
+      | Service
+      | Exclude<R2, {
+        env: PureEnv<Evt, readonly T[], readonly T2[]>
+      }>
+    >
+    <A, E2, R2, T2 extends T>(
+      q: (
+        q: Q.Query<Encoded>
+      ) =>
+        | Q.Query<Encoded>
+        | Q.QueryWhere<Encoded>
+        | Q.QueryEnd<Encoded, "many">,
+      pure: Effect<A, E2, FixEnv<R2, Evt, readonly T[], readonly T2[]>>,
+      batch: "batched" | number
+    ): Effect.Effect<
+      A[],
+      InvalidStateError | OptimisticConcurrencyException | E2,
+      | Service
+      | Exclude<R2, {
+        env: PureEnv<Evt, readonly T[], readonly T2[]>
+      }>
+    >
+  }
+  readonly query: {
+    <A, R, From extends FieldValues, TType extends "one" | "many" | "count" = "many">(
+      q: (
+        initial: Q.Query<Encoded>
+      ) => Q.QueryProjection<Encoded extends From ? From : never, A, R, TType>
+    ): Effect.Effect<
+      TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
+      | (TType extends "many" ? never : NotFoundError<ItemType>)
+      | (TType extends "count" ? never : S.ParseResult.ParseError),
+      R | Service
+    >
+    <
+      R = never,
+      TType extends "one" | "many" = "many",
+      EncodedRefined extends Encoded = Encoded
+    >(
+      q: (
+        initial: Q.Query<Encoded>
+      ) => Q.QAll<Encoded, EncodedRefined, RefineTHelper<T, EncodedRefined>, R, TType>
+    ): Effect.Effect<
+      TType extends "many" ? readonly RefineTHelper<T, EncodedRefined>[] : RefineTHelper<T, EncodedRefined>,
+      TType extends "many" ? never : NotFoundError<ItemType>,
+      R | Service
+    >
+  }
+  byIdAndSaveWithPure: {
+    <R, A, E, S2 extends T>(
+      id: T[IdKey],
+      pure: Effect<A, E, FixEnv<R, Evt, T, S2>>
+    ): Effect<
+      A,
+      InvalidStateError | OptimisticConcurrencyException | E | NotFoundError<ItemType>,
+      | Service
+      | Exclude<R, {
+        env: PureEnv<Evt, T, S2>
+      }>
+    >
+  }
+  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[]>
+      }>
+    >
+  }
+  /** @experimental */
+  mapped: MM<Service, Encoded>
+  use: <X>(
+    body: (_: Service) => X
+  ) => X extends Effect<infer A, infer E, infer R> ? Effect<A, E, R | Service> : Effect<X, never, Service>
+}
+
+/**
+ * @deprecated
+ */
+const makeRepoFunctions = (tag: any, itemType: any) => {
+  const { all } = Effect.serviceConstants(tag) as any
+  const {
+    byIdAndSaveWithPure,
+    find,
+    get,
+    query,
+    queryAndSavePure,
+    removeAndPublish,
+    removeById,
+    save,
+    saveAndPublish,
+    saveManyWithPure
+  } = Effect.serviceFunctions(tag) as any
+  const mapped = (s: any) => Effect.map(tag, (_: any) => _.mapped(s))
+  return {
+    itemType,
+    all,
+    byIdAndSaveWithPure,
+    find,
+    removeById,
+    saveAndPublish,
+    removeAndPublish,
+    save,
+    get,
+    query,
+    mapped,
+    queryAndSavePure,
+    saveManyWithPure,
+    use: (body: any) => Effect.andThen(tag, body)
+  }
+}
+
 /** @deprecated use makeRepo/extendRepo */
 export class RepositoryBase<
   T,
@@ -132,6 +306,7 @@ export const RepositoryDefaultImpl2 = <Service, Evt = never>() => {
         impl: Repository<T, Encoded, Evt, ItemType, IdKey, R> & Ext
       ) => RepositoryBase<T, Encoded, Evt, ItemType, Ext, IdKey, R>)
       & Context.Tag<Service, Service>
+      & RepoFunctions<T, Encoded, Evt, ItemType, IdKey, Service>
       & {
         Default: Layer.Layer<
           Service,
@@ -207,6 +382,7 @@ export const RepositoryDefaultImpl2 = <Service, Evt = never>() => {
         impl: Repository<T, Encoded, Evt, ItemType, "id", R> & Ext
       ) => RepositoryBase<T, Encoded, Evt, ItemType, Ext, "id", R>)
       & Context.Tag<Service, Service>
+      & RepoFunctions<T, Encoded, Evt, ItemType, "id", Service>
       & {
         Default: Layer.Layer<
           Service,
@@ -327,7 +503,7 @@ export const RepositoryDefaultImpl2 = <Service, Evt = never>() => {
     Error.stackTraceLimit = limit
     // TODO: actual class name or expect a string identifier - careful with overlapping between modules
     return Context.assignTag<Service>(registerName(itemType + "Repo"), creationError)(
-      Cls
+      Object.assign(Cls, makeRepoFunctions(Cls, itemType))
     ) as any // impl is missing, but its marked protected
   }
 

package/src/services/Repository/service.ts

@@ -1,5 +1,4 @@
-import type { ParseResult } from "effect"
-import type { Effect, Option, PubSub } from "effect-app"
+import type { Effect, Option, PubSub, S } from "effect-app"
 import type { InvalidStateError, NotFoundError, OptimisticConcurrencyException } from "effect-app/client"
 import type { NonNegativeInt } from "effect-app/Schema/numbers"
 import type { FieldValues } from "../../filter/types.js"
@@ -32,24 +31,33 @@ export interface Repository<
   ) => Effect<void, never, R>
 
   readonly query: {
-    <A, R, Encoded2 extends FieldValues, TType extends "one" | "many" | "count" = "many">(
+    <A, R, From extends FieldValues, TType extends "one" | "many" | "count" = "many">(
       q: (
         initial: Query<Encoded>
-      ) => QueryProjection<Encoded extends Encoded2 ? Encoded2 : never, A, R, TType>
+      ) => QueryProjection<Encoded extends From ? From : never, A, R, TType>
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
-      | (TType extends "count" ? never : ParseResult.ParseError),
+      | (TType extends "count" ? never : S.ParseResult.ParseError),
+      R
+    >
+    <
+      R = never,
+      TType extends "one" | "many" = "many",
+      EncodedRefined extends Encoded = Encoded
+    >(
+      q: (initial: Query<Encoded>) => QAll<Encoded, EncodedRefined, RefineTHelper<T, EncodedRefined>, R, TType>
+    ): Effect.Effect<
+      TType extends "many" ? readonly RefineTHelper<T, EncodedRefined>[] : RefineTHelper<T, EncodedRefined>,
+      TType extends "many" ? never : NotFoundError<ItemType>,
       R
     >
-    <R = never, TType extends "one" | "many" = "many">(
-      q: (initial: Query<Encoded>) => QAll<Encoded, T, R, TType>
-    ): Effect.Effect<TType extends "many" ? readonly T[] : T, TType extends "many" ? never : NotFoundError<ItemType>, R>
-    // <R = never>(q: QAll<Encoded, T, R>): Effect.Effect<readonly T[], never, R>
-    // <A, R, Encoded2 extends FieldValues>(
-    //   q: QueryProjection<Encoded extends Encoded2 ? Encoded2 : never, A, R>
-    // ): Effect.Effect<readonly A[], S.ParseResult.ParseError, R>
   }
   /** @deprecated use query */
   readonly mapped: Mapped<Encoded>
 }
+
+export type RefineTHelper<T, EncodedRefined> = EncodedRefined extends { _tag: any }
+  ? T extends { _tag: any } ? Extract<T, { _tag: EncodedRefined["_tag"] }>
+  : T
+  : T

package/src/services/RepositoryBase.ts

@@ -258,8 +258,10 @@ export function makeRepoInternal<
             <A, R, From extends FieldValues>(
               q: QueryProjection<Encoded extends From ? From : never, A, R>
             ): Effect.Effect<readonly A[], S.ParseResult.ParseError, R>
-            <A, R>(q: QAll<NoInfer<Encoded>, A, R>): Effect.Effect<readonly A[], never, R>
-          } = (<A, R>(q: QAll<Encoded, A, R>) => {
+            <A, R, EncodedRefined extends Encoded = Encoded>(
+              q: QAll<NoInfer<Encoded>, NoInfer<EncodedRefined>, A, R>
+            ): Effect.Effect<readonly A[], never, R>
+          } = (<A, R, EncodedRefined extends Encoded = Encoded>(q: QAll<Encoded, EncodedRefined, A, R>) => {
             const a = Q.toFilter(q)
             const eff = a.mode === "project"
               ? filter(a)

package/src/services/Store/service.ts

@@ -3,6 +3,8 @@ import type { UniqueKey } from "@azure/cosmos"
 import { Context, Effect } from "effect-app"
 import type { NonEmptyReadonlyArray, Option, Secret } from "effect-app"
 import type { OptimisticConcurrencyException } from "../../errors.js"
+import type { FieldValues } from "../../filter/types.js"
+import type { FieldPath } from "../../filter/types/path/index.js"
 import type { FilterResult } from "./filterApi/query.js"
 
 export type StoreConfig<E> = {
@@ -34,15 +36,16 @@ export type Where =
 
 export type Filter = readonly FilterResult[]
 
-export interface O<Encoded extends { id: string }> {
-  key: keyof Encoded
+export interface O<TFieldValues extends FieldValues> {
+  key: FieldPath<TFieldValues>
   direction: "ASC" | "DESC"
 }
 
 export interface FilterArgs<Encoded extends { id: string }, U extends keyof Encoded = never> {
+  t: Encoded
   filter?: Filter | undefined
   select?: NonEmptyReadonlyArray<U> | undefined
-  order?: NonEmptyReadonlyArray<O<Encoded>>
+  order?: NonEmptyReadonlyArray<O<NoInfer<Encoded>>>
   limit?: number | undefined
   skip?: number | undefined
 }