@effect-app/infra 2.3.5 → 2.4.1

package/src/services/Repository/legacy.ts

@@ -0,0 +1,351 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* 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 * 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"
+
+const names = new Map<string, number>()
+const registerName = (name: string) => {
+  const existing = names.get(name)
+  if (existing === undefined) {
+    names.set(name, 1)
+    return name
+  } else {
+    const n = existing + 1
+    names.set(name, n)
+    return name + "-" + existing
+  }
+}
+
+/** @deprecated use makeRepo/extendRepo */
+export class RepositoryBase<T, Encoded extends { id: string }, Evt, ItemType extends string, Ext, IdKey extends keyof T>
+  implements ExtendedRepository<T, Encoded, Evt, ItemType, IdKey>
+{
+  constructor(protected readonly impl: ExtendedRepository<T, Encoded, Evt, ItemType, IdKey> & Ext) {
+    this.saveAndPublish = this.impl.saveAndPublish
+    this.removeAndPublish = this.impl.removeAndPublish
+    this.find = this.impl.find
+    this.all = this.impl.all
+    this.changeFeed = this.impl.changeFeed
+    this.mapped = this.impl.mapped
+    this.query = this.impl.query
+    this.get = this.impl.get
+    this.itemType = this.impl.itemType
+    this.idKey = this.impl.idKey
+    this.log = this.impl.log
+    this.removeById = this.impl.removeById
+    this.save = this.impl.save
+    this.saveWithEvents = this.impl.saveWithEvents
+    this.queryAndSavePure = this.impl.queryAndSavePure
+    this.saveManyWithPure = this.impl.saveManyWithPure
+    this.byIdAndSaveWithPure = this.impl.byIdAndSaveWithPure
+    this.saveWithPure = this.impl.saveWithPure
+    this.request = this.impl.request
+  }
+  get: (id: T[IdKey]) => Effect<T, NotFoundError<ItemType>>
+  idKey
+  request
+  itemType
+  saveAndPublish
+  removeAndPublish
+  find
+  all
+  changeFeed
+  mapped
+  query
+  log
+  removeById
+  save
+  saveWithEvents
+  queryAndSavePure
+  saveManyWithPure
+  byIdAndSaveWithPure
+  saveWithPure
+}
+
+export const RepositoryDefaultImpl2 = <Service, Evt = never>() => {
+  const f: {
+    <
+      ItemType extends string,
+      R,
+      Encoded extends { id: string },
+      T,
+      IdKey extends keyof T,
+      E = never,
+      RInitial = never,
+      R2 = never,
+      Layers extends [Layer.Layer.Any, ...Layer.Layer.Any[]] = [Layer.Layer<never>],
+      E1 = never,
+      R1 = never,
+      // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+      Ext = {}
+    >(
+      itemType: ItemType,
+      schema: S.Schema<T, Encoded, R>,
+      options: [Evt] extends [never] ? {
+          dependencies?: Layers
+          idKey: IdKey
+          config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
+            partitionValue?: (a: Encoded) => string
+          }
+          jitM?: (pm: Encoded) => Encoded
+          options?: Effect<
+            {
+              makeInitial?: Effect<readonly T[], E, RInitial>
+              ext?: Ext
+            },
+            E1,
+            R1
+          >
+        }
+        : {
+          dependencies?: Layers
+          idKey: IdKey
+          jitM?: (pm: Encoded) => Encoded
+          config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
+            partitionValue?: (a: Encoded) => string
+          }
+          options?: Effect<
+            {
+              publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<void, never, R2>
+              makeInitial?: Effect<readonly T[], E, RInitial>
+              ext?: Ext
+            },
+            E1,
+            R1
+          >
+        }
+    ):
+      & (abstract new(
+        impl: Repository<T, Encoded, Evt, ItemType, IdKey> & Ext
+      ) => RepositoryBase<T, Encoded, Evt, ItemType, Ext, IdKey>)
+      & Context.Tag<Service, Service>
+      & {
+        Default: Layer.Layer<
+          Service,
+          E1 | Layer.Layer.Error<Layers[number]>,
+          Exclude<
+            R1 | R | StoreMaker,
+            { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]
+          >
+        >
+        DefaultWithoutDependencies: Layer.Layer<
+          Service,
+          E1,
+          R1 | R | StoreMaker
+        >
+      }
+      & Repos<
+        T,
+        Encoded,
+        R,
+        Evt,
+        ItemType,
+        IdKey
+      >
+    <
+      ItemType extends string,
+      R,
+      Encoded extends { id: string },
+      T extends { id: unknown },
+      E = never,
+      RInitial = never,
+      R2 = never,
+      Layers extends [Layer.Layer.Any, ...Layer.Layer.Any[]] = [Layer.Layer<never>],
+      E1 = never,
+      R1 = never,
+      // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+      Ext = {}
+    >(
+      itemType: ItemType,
+      schema: S.Schema<T, Encoded, R>,
+      options: [Evt] extends [never] ? {
+          dependencies?: Layers
+          config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
+            partitionValue?: (a: Encoded) => string
+          }
+          jitM?: (pm: Encoded) => Encoded
+          options?: Effect<
+            {
+              makeInitial?: Effect<readonly T[], E, RInitial>
+              ext?: Ext
+            },
+            E1,
+            R1
+          >
+        }
+        : {
+          dependencies?: Layers
+          jitM?: (pm: Encoded) => Encoded
+          config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
+            partitionValue?: (a: Encoded) => string
+          }
+          options?: Effect<
+            {
+              publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<void, never, R2>
+              makeInitial?: Effect<readonly T[], E, RInitial>
+              ext?: Ext
+            },
+            E1,
+            R1
+          >
+        }
+    ):
+      & (abstract new(
+        impl: Repository<T, Encoded, Evt, ItemType, "id"> & Ext
+      ) => RepositoryBase<T, Encoded, Evt, ItemType, Ext, "id">)
+      & Context.Tag<Service, Service>
+      & {
+        Default: Layer.Layer<
+          Service,
+          E1 | Layer.Layer.Error<Layers[number]>,
+          Exclude<
+            R1 | R | StoreMaker,
+            { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]
+          >
+        >
+        DefaultWithoutDependencies: Layer.Layer<
+          Service,
+          E1,
+          R1 | R | StoreMaker
+        >
+      }
+      & Repos<
+        T,
+        Encoded,
+        R,
+        Evt,
+        ItemType,
+        "id"
+      >
+  } = <
+    ItemType extends string,
+    R,
+    Encoded extends { id: string },
+    T,
+    IdKey extends keyof T,
+    E = never,
+    RInitial = never,
+    R2 = never,
+    Layers extends [Layer.Layer.Any, ...Layer.Layer.Any[]] = [Layer.Layer<never>],
+    E1 = never,
+    R1 = never,
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    Ext = {}
+  >(
+    itemType: ItemType,
+    schema: S.Schema<T, Encoded, R>,
+    options: [Evt] extends [never] ? {
+        dependencies?: Layers
+        idKey?: IdKey
+        config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
+          partitionValue?: (a: Encoded) => string
+        }
+        jitM?: (pm: Encoded) => Encoded
+        options?: Effect<
+          {
+            makeInitial?: Effect<readonly T[], E, RInitial>
+            ext?: Ext
+          },
+          E1,
+          R1
+        >
+      }
+      : {
+        dependencies?: Layers
+        idKey?: IdKey
+        jitM?: (pm: Encoded) => Encoded
+        config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
+          partitionValue?: (a: Encoded) => string
+        }
+        options?: Effect<
+          {
+            publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<void, never, R2>
+            makeInitial?: Effect<readonly T[], E, RInitial>
+            ext?: Ext
+          },
+          E1,
+          R1
+        >
+      }
+  ) => {
+    let layerCache = undefined
+    let layerCache2 = undefined
+    abstract class Cls extends RepositoryBase<
+      T,
+      Encoded,
+      Evt,
+      ItemType,
+      Ext,
+      IdKey
+    > {
+      static readonly Q = Q.make<Encoded>()
+      static get DefaultWithoutDependencies() {
+        const self = this as any
+        return layerCache ??= Effect
+          .gen(function*() {
+            const opts = yield* options.options ?? Effect.succeed({})
+            const mkRepo = makeRepoInternal<Evt>()(
+              itemType,
+              schema,
+              options?.jitM ? (pm) => options.jitM!(pm) : (pm) => pm,
+              (e, _etag) => ({ ...e, _etag }),
+              options.idKey ?? "id" as any
+            )
+            const r = yield* mkRepo.make({ ...options, ...opts } as any)
+            const repo = new self(Object.assign(extendRepo(r), "ext" in opts ? opts.ext : {}))
+            return Layer.succeed(self, repo)
+          })
+          .pipe(Layer.unwrapEffect)
+      }
+      static get Default() {
+        const self = this as any
+        return layerCache2 ??= options.dependencies
+          ? self
+            .DefaultWithoutDependencies
+            .pipe(Layer.provide(options.dependencies as any))
+          : self.DefaultWithoutDependencies
+      }
+      static readonly type: Repository<T, Encoded, Evt, ItemType, IdKey> = undefined as any
+    }
+    const limit = Error.stackTraceLimit
+    Error.stackTraceLimit = 2
+    const creationError = new Error()
+    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
+    ) as any // impl is missing, but its marked protected
+  }
+
+  return f
+}
+
+export interface Mapped1<A, IdKey extends keyof A, R> {
+  all: Effect<A[], ParseResult.ParseError, R>
+  save: (...xes: readonly A[]) => Effect<void, OptimisticConcurrencyException | ParseResult.ParseError, R>
+  find: (id: A[IdKey]) => Effect<Option<A>, ParseResult.ParseError, R>
+}
+
+// TODO: auto use project, and select fields from the From side of schema only
+export interface Mapped2<A, R> {
+  all: Effect<A[], ParseResult.ParseError, R>
+}
+
+export interface Mapped<Encoded extends { id: string }> {
+  <A, R, IdKey extends keyof A>(schema: S.Schema<A, Encoded, R>): Mapped1<A, IdKey, R>
+  // TODO: constrain on Encoded2 having to contain only fields that fit Encoded
+  <A, Encoded2, R>(schema: S.Schema<A, Encoded2, R>): Mapped2<A, R>
+}
+
+export interface MM<Repo, Encoded extends { id: string }> {
+  <A, R, IdKey extends keyof A>(schema: S.Schema<A, Encoded, R>): Effect<Mapped1<A, IdKey, R>, never, Repo>
+  // TODO: constrain on Encoded2 having to contain only fields that fit Encoded
+  <A, Encoded2, R>(schema: S.Schema<A, Encoded2, R>): Effect<Mapped2<A, R>, never, Repo>
+}

package/src/services/Repository/service.ts

@@ -1,4 +1,10 @@
-import type { RepositoryBaseC } from "../RepositoryBase.js"
+import type { ParseResult } from "effect"
+import type { Effect, Option, PubSub } 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"
+import type { QAll, Query, QueryProjection } from "../query.js"
+import type { Mapped } from "./legacy.js"
 
 /**
  * @tsplus type Repository
@@ -9,4 +15,40 @@ export interface Repository<
   Evt,
   ItemType extends string,
   IdKey extends keyof T
-> extends RepositoryBaseC<T, Encoded, Evt, ItemType, IdKey> {}
+> {
+  readonly itemType: ItemType
+  readonly idKey: IdKey
+  readonly find: (id: T[IdKey]) => Effect<Option<T>>
+  readonly all: Effect<T[]>
+  readonly saveAndPublish: (
+    items: Iterable<T>,
+    events?: Iterable<Evt>
+  ) => Effect<void, InvalidStateError | OptimisticConcurrencyException>
+  readonly changeFeed: PubSub.PubSub<[T[], "save" | "remove"]>
+  readonly removeAndPublish: (
+    items: Iterable<T>,
+    events?: Iterable<Evt>
+  ) => Effect<void>
+
+  readonly query: {
+    <A, R, Encoded2 extends FieldValues, TType extends "one" | "many" | "count" = "many">(
+      q: (
+        initial: Query<Encoded>
+      ) => QueryProjection<Encoded extends Encoded2 ? Encoded2 : 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),
+      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>
+}

package/src/services/Repository.ts

@@ -1,3 +1,4 @@
 export * from "./Repository/dsl.js"
 export * from "./Repository/ext.js"
+export * from "./Repository/legacy.js"
 export * from "./Repository/service.js"