effect-app 4.0.0-beta.33 → 4.0.0-beta.331

package/src/Model/Repository/legacy.ts

@@ -0,0 +1,29 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import type { DatabaseError, OptimisticConcurrencyException } from "../../client/errors.ts"
+import type * as Effect from "../../Effect.ts"
+import type * as Option from "../../Option.ts"
+import type * as S from "../../Schema.ts"
+
+export interface Mapped1<A, IdKey extends keyof A, R> {
+  all: Effect.Effect<A[], S.SchemaError | DatabaseError, R>
+  save: (...xes: readonly A[]) => Effect.Effect<void, OptimisticConcurrencyException | S.SchemaError | DatabaseError, R>
+  find: (id: A[IdKey]) => Effect.Effect<Option.Option<A>, S.SchemaError | DatabaseError, R>
+}
+
+// TODO: auto use project, and select fields from the From side of schema only
+export interface Mapped2<A, R> {
+  all: Effect.Effect<A[], S.SchemaError | DatabaseError, R>
+}
+
+export interface Mapped<Encoded> {
+  <A, R, IdKey extends keyof A>(schema: S.Codec<A, Encoded, R>): Mapped1<A, IdKey, R>
+  // TODO: constrain on Encoded2 having to contain only fields that fit Encoded
+  <A, Encoded2, R>(schema: S.Codec<A, Encoded2, R>): Mapped2<A, R>
+}
+
+export interface MM<Repo, Encoded> {
+  <A, R, IdKey extends keyof A>(schema: S.Codec<A, Encoded, R>): Effect.Effect<Mapped1<A, IdKey, R>, never, Repo>
+  // TODO: constrain on Encoded2 having to contain only fields that fit Encoded
+  <A, Encoded2, R>(schema: S.Codec<A, Encoded2, R>): Effect.Effect<Mapped2<A, R>, never, Repo>
+}

package/src/Model/Repository/makeRepo.ts

@@ -0,0 +1,168 @@
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+// import type { ParserEnv } from "../../Schema/custom/Parser.ts"
+
+import type * as Scope from "effect/Scope"
+import type { NonEmptyReadonlyArray } from "../../Array.ts"
+import type * as Context from "../../Context.ts"
+import type * as DataDependencies from "../../DataDependencies.ts"
+import * as Effect from "../../Effect.ts"
+import type * as S from "../../Schema.ts"
+import type { JsonRecord, StoreConfig, StoreMaker } from "../../Store.ts"
+import type { FieldValues } from "../filter/types.ts"
+import { type ExtendedRepository, extendRepo } from "./ext.ts"
+import { makeRepoInternal } from "./internal/internal.ts"
+import { RepositoryRegistry } from "./Registry.ts"
+import type { Repository } from "./service.ts"
+
+export interface RepositoryOptions<
+  IdKey extends keyof T & keyof Encoded,
+  Encoded extends FieldValues,
+  T,
+  ItemType extends string,
+  Evt = never,
+  RPublish = never,
+  E = never,
+  RInitial = never,
+  RCtx = never,
+  RSchema = never
+> {
+  /**
+   * Specify the idKey of the Type side, if it's different from the default "id".
+   * Does not change the Encoded side, which is always "id" to support database drivers.
+   * At this time as queries are operating on the Encoded side, the queries must still specify "id" regardless.
+   */
+  idKey: IdKey
+  /**
+   * just in time Migration: for complex migrations that aren't just default simple values
+   * use the config.defaultValues instead for simple default values
+   *
+   * Runs at the **store boundary** on the raw JSON document, after
+   * `config.defaultValues` have been merged in and *before* the JSON→Encoded
+   * decode. It sees the document as stored - a `Date` field as an ISO string,
+   * a `ReadonlyMap` as an array of pairs, an explicit `null` as `null` - and
+   * must return JSON again, not native Encoded values.
+   *
+   * @see StoreConfig.jitM
+   */
+  jitM?: (json: JsonRecord) => JsonRecord
+  config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
+    partitionValue?: (e?: Encoded) => string
+  }
+  /**
+   * Optional handler to be able to publish events after successfull save.
+   */
+  publishEvents?: (evt: NonEmptyReadonlyArray<Evt>) => Effect.Effect<void, never, RPublish>
+  /**
+   * Optional creator for initial data in the table when it's created for the first itme.
+   */
+  makeInitial?: Effect.Effect<readonly T[], E, RInitial> | undefined
+  /**
+   * Optional context to be provided to Schema decode/encode.
+   * Useful for effectful transformations like XWithItems, where items is a transformation retrieving elements from another database table or other source.
+   */
+  schemaContext?: Context.Context<RCtx>
+
+  /** IDs, including aliases, that identify an entity for dependency invalidation. */
+  dependencyIds?: (item: T) => NonEmptyReadonlyArray<string>
+
+  /**
+   * Additional derived queries or resources affected by writing an item.
+   * Saves invalidate dependencies derived from both the previous and next item;
+   * removals derive them from the removed item.
+   */
+  additionalWriteDependencies?: (item: T) => ReadonlyArray<DataDependencies.DataDependency>
+
+  overrides?: (
+    repo: Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish, RCtx>
+  ) => Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish, RCtx>
+}
+
+/**
+ * Create a repository instance.
+ * @param itemType an identifier used for the table name and e.g NotFoundError
+ * @param schema the Schema used for this Repository
+ * @param options @see RepositoryOptions
+ * @returns a Repository
+ */
+export const makeRepo: {
+  <
+    ItemType extends string,
+    RSchema,
+    Encoded extends FieldValues,
+    T,
+    IdKey extends keyof T & keyof Encoded,
+    E = never,
+    Evt = never,
+    RInitial = never,
+    RPublish = never,
+    RCtx = never
+  >(
+    itemType: ItemType,
+    schema: S.Codec<T, Encoded, RSchema>,
+    options: RepositoryOptions<IdKey, Encoded, T, ItemType, Evt, RPublish, E, RInitial, RCtx, RSchema>
+  ): Effect.Effect<
+    ExtendedRepository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish, RCtx>,
+    E,
+    RInitial | StoreMaker | RepositoryRegistry | Scope.Scope
+  >
+  <
+    ItemType extends string,
+    RSchema,
+    Encoded extends FieldValues,
+    T extends { id: unknown },
+    E = never,
+    Evt = never,
+    RInitial = never,
+    RPublish = never,
+    RCtx = never
+  >(
+    itemType: ItemType,
+    schema: S.Codec<T, Encoded, RSchema>,
+    options: Omit<RepositoryOptions<"id", Encoded, T, ItemType, Evt, RPublish, E, RInitial, RCtx, RSchema>, "idKey">
+  ): Effect.Effect<
+    ExtendedRepository<T, Encoded, Evt, ItemType, "id", Exclude<RSchema, RCtx>, RPublish, RCtx>,
+    E,
+    RInitial | StoreMaker | RepositoryRegistry | Scope.Scope
+  >
+} = <
+  ItemType extends string,
+  RSchema,
+  Encoded extends FieldValues,
+  T,
+  IdKey extends keyof T & keyof Encoded,
+  E = never,
+  RInitial = never,
+  RPublish = never,
+  Evt = never,
+  RCtx = never
+>(
+  itemType: ItemType,
+  schema: S.Codec<T, Encoded, RSchema>,
+  options: Omit<RepositoryOptions<IdKey, Encoded, T, ItemType, Evt, RPublish, E, RInitial, RCtx, RSchema>, "idKey"> & {
+    idKey?: IdKey
+  }
+) =>
+  Effect.gen(function*() {
+    const mkRepo = makeRepoInternal<Evt>()(
+      itemType,
+      schema,
+      (e, _etag) => ({ ...e, _etag }),
+      options.idKey ?? "id" as any
+    )
+    // `jitM` belongs to the store: it migrates the raw JSON document before the
+    // store decodes JSON→Encoded, so it travels as part of the store config.
+    const { jitM, ...rest } = options
+    let r = yield* mkRepo.make<RInitial, E, RPublish, RCtx>(
+      (jitM ? { ...rest, config: { ...rest.config, jitM } } : rest) as any
+    )
+    if (options.overrides) r = options.overrides(r)
+    const repo = extendRepo(r)
+    const registry = yield* RepositoryRegistry
+    registry.register(itemType, repo)
+    return repo
+  })