@effect-app/infra 4.0.0-beta.13 → 4.0.0-beta.131

package/src/CUPS.ts

@@ -1,6 +1,6 @@
 import { type FileOptions, tempFile } from "@effect-app/infra/fileUtil"
 import cp from "child_process"
-import { Config, Effect, Layer, Option, Predicate, S, ServiceMap } from "effect-app"
+import { Config, Context, Effect, Layer, Option, Predicate, S } from "effect-app"
 import { pretty } from "effect-app/utils"
 import fs from "fs"
 import os from "os"
@@ -74,15 +74,13 @@ function printBuffer(printer: PrinterConfig, options: string[]) {
       )
 }
 
-function getAvailablePrinters(host?: string) {
-  return Effect.gen(function*() {
-    const { stdout } = yield* exec(["lpstat", ...buildListArgs({ host }), "-s"].join(" "))
-    return [...stdout.matchAll(/device for (\w+):/g)]
-      .map((_) => _[1])
-      .filter(Predicate.isNotNullish)
-      .map((_) => S.NonEmptyString255(_))
-  })
-}
+const getAvailablePrinters = Effect.fnUntraced(function*(host?: string) {
+  const { stdout } = yield* exec(["lpstat", ...buildListArgs({ host }), "-s"].join(" "))
+  return [...stdout.matchAll(/device for (\w+):/g)]
+    .map((_) => _[1])
+    .filter(Predicate.isNotNullish)
+    .map((_) => S.NonEmptyString255(_))
+})
 
 function* buildListArgs(config?: { host?: string | undefined }) {
   if (config?.host) {
@@ -100,7 +98,7 @@ export const CUPSConfig = Config.all({
     )
 })
 
-export class CUPS extends ServiceMap.Service<CUPS>()("effect-app/CUPS", {
+export class CUPS extends Context.Service<CUPS>()("effect-app/CUPS", {
   make: Effect.gen(function*() {
     const config = yield* CUPSConfig
     const serverUrl = Option.getOrUndefined(config.server)

package/src/Emailer/service.ts

@@ -1,13 +1,13 @@
 import type { MailContent, MailData } from "@sendgrid/helpers/classes/mail.js"
 import type { ResponseError } from "@sendgrid/mail"
-import { Data, type Effect, type NonEmptyReadonlyArray, type Redacted, ServiceMap } from "effect-app"
+import { Context, Data, type Effect, type NonEmptyReadonlyArray, type Redacted } from "effect-app"
 import type { Email } from "effect-app/Schema"
 
 export class SendMailError extends Data.TaggedError("SendMailError")<{
   readonly raw: Error | ResponseError
 }> {}
 
-export class Emailer extends ServiceMap.Opaque<Emailer, {
+export class Emailer extends Context.Opaque<Emailer, {
   sendMail: (msg: EmailMsgOptionalFrom) => Effect.Effect<void, SendMailError>
 }>()("effect-app/Emailer") {}
 

package/src/MainFiberSet.ts

@@ -1,4 +1,4 @@
-import { Effect, Fiber, FiberSet, Layer, ServiceMap } from "effect-app"
+import { Context, Effect, Fiber, FiberSet, Layer } from "effect-app"
 import type {} from "effect/Scope"
 import { InfraLogger } from "./logger.js"
 import { reportNonInterruptedFailureCause } from "./QueueMaker/errors.js"
@@ -62,7 +62,7 @@ const make = Effect.gen(function*() {
  * you should register these long running fibers in a FiberSet, and join them at the end of your main program.
  * This way any errors will blow up the main program instead of fibers dying unknowingly.
  */
-export class MainFiberSet extends ServiceMap.Service<MainFiberSet>()("MainFiberSet", { make }) {
+export class MainFiberSet extends Context.Service<MainFiberSet>()("MainFiberSet", { make }) {
   static readonly Live = Layer.effect(this, this.make)
   static readonly JoinLive = this.asEffect().pipe(
     Effect.andThen((_) => _.join),

package/src/Model/Repository/Registry.ts

@@ -0,0 +1,33 @@
+import { Context, Effect } from "effect-app"
+
+export interface RegisteredRepository {
+  readonly seedNamespace: (namespace: string) => Effect.Effect<void>
+}
+
+const make = Effect.sync(() => {
+  const repos = new Map<string, RegisteredRepository>()
+  return {
+    register(modelName: string, repo: RegisteredRepository) {
+      repos.set(modelName, repo)
+    },
+    seedNamespace: (namespace: string) =>
+      Effect.suspend(() =>
+        Effect.forEach(
+          repos.values(),
+          (r) => r.seedNamespace(namespace),
+          { concurrency: "unbounded", discard: true }
+        )
+      ),
+    get entries(): ReadonlyMap<string, RegisteredRepository> {
+      return repos
+    }
+  }
+})
+
+export class RepositoryRegistry extends Context.Opaque<RepositoryRegistry, {
+  readonly register: (modelName: string, repo: RegisteredRepository) => void
+  readonly seedNamespace: (namespace: string) => Effect.Effect<void>
+  readonly entries: ReadonlyMap<string, RegisteredRepository>
+}>()("effect-app/RepositoryRegistry", { make }) {}
+
+export const RepositoryRegistryLive = RepositoryRegistry.toLayer(RepositoryRegistry.make)

package/src/Model/Repository/ext.ts

@@ -9,6 +9,22 @@ import type { Query, QueryEnd, QueryWhere } from "../query.js"
 import * as Q from "../query.js"
 import type { Repository } from "./service.js"
 
+interface BatchOptions {
+  readonly batch?: true | number
+}
+
+const asReadonlyArray = <T>(itemOrItems: T | ReadonlyArray<T>): ReadonlyArray<T> =>
+  globalThis.Array.isArray(itemOrItems)
+    ? itemOrItems as ReadonlyArray<T>
+    : [itemOrItems as T]
+
+const getBatchSize = (batch?: true | number) =>
+  batch === true
+    ? 100
+    : typeof batch === "number" && Number.isFinite(batch) && batch > 0
+    ? Math.floor(batch)
+    : undefined
+
 export const extendRepo = <
   T,
   Encoded extends FieldValues,
@@ -16,9 +32,10 @@ export const extendRepo = <
   ItemType extends string,
   IdKey extends keyof T & keyof Encoded,
   RSchema,
-  RPublish
+  RPublish,
+  RProvided = never
 >(
-  repo: Repository<T, Encoded, Evt, ItemType, IdKey, RSchema, RPublish>
+  repo: Repository<T, Encoded, Evt, ItemType, IdKey, RSchema, RPublish, RProvided>
 ) => {
   const get = (id: T[IdKey]) =>
     repo.find(id).pipe(
@@ -244,8 +261,77 @@ export const extendRepo = <
     request: (id: T[IdKey]) => Effect.request(_request({ id }), requestResolver),
     get,
     log: (evt: Evt) => AnyPureDSL.log(evt),
-    save: (...items: NonEmptyArray<T>) => repo.saveAndPublish(items),
+    /**
+     * Enables chunked writes for large batches via `options.batch`.
+     * Note: batching breaks transactional properties because chunks are saved independently.
+     */
+    save: ((itemOrItems: T | ReadonlyArray<T>, options?: BatchOptions) => {
+      const items = asReadonlyArray(itemOrItems)
+      if (!Array.isReadonlyArrayNonEmpty(items)) {
+        return Effect.void
+      }
+      const batchSize = getBatchSize(options?.batch)
+      if (batchSize === undefined) {
+        return repo.saveAndPublish(items)
+      }
+      return Effect.forEach(
+        Array.chunksOf(items, batchSize),
+        (batch) => repo.saveAndPublish(batch),
+        { discard: true }
+      )
+    }) as (
+      itemOrItems: T | ReadonlyArray<T>,
+      options?: BatchOptions
+    ) => Effect.Effect<
+      void,
+      InvalidStateError | OptimisticConcurrencyException,
+      RSchema | RPublish
+    >,
     saveWithEvents: (events: Iterable<Evt>) => (...items: NonEmptyArray<T>) => repo.saveAndPublish(items, events),
+    /**
+     * Enables chunked deletes for large batches via `options.batch`.
+     * Note: batching breaks transactional properties because chunks are removed independently.
+     */
+    remove: ((itemOrItems: T | ReadonlyArray<T>, options?: BatchOptions) => {
+      const items = asReadonlyArray(itemOrItems)
+      if (!Array.isReadonlyArrayNonEmpty(items)) {
+        return Effect.void
+      }
+      const batchSize = getBatchSize(options?.batch)
+      if (batchSize === undefined) {
+        return repo.removeAndPublish(items)
+      }
+      return Effect.forEach(
+        Array.chunksOf(items, batchSize),
+        (batch) => repo.removeAndPublish(batch),
+        { discard: true }
+      )
+    }) as (
+      itemOrItems: T | ReadonlyArray<T>,
+      options?: BatchOptions
+    ) => Effect.Effect<void, never, RSchema | RPublish>,
+    /**
+     * Enables chunked deletes for large batches via `options.batch`.
+     * Note: batching breaks transactional properties because chunks are removed independently.
+     */
+    removeById: ((idOrIds: T[IdKey] | ReadonlyArray<T[IdKey]>, options?: BatchOptions) => {
+      const ids = asReadonlyArray(idOrIds)
+      if (!Array.isReadonlyArrayNonEmpty(ids)) {
+        return Effect.void
+      }
+      const batchSize = getBatchSize(options?.batch)
+      if (batchSize === undefined) {
+        return repo.removeById(ids)
+      }
+      return Effect.forEach(
+        Array.chunksOf(ids, batchSize),
+        (batch) => repo.removeById(batch),
+        { discard: true }
+      )
+    }) as (
+      idOrIds: T[IdKey] | ReadonlyArray<T[IdKey]>,
+      options?: BatchOptions
+    ) => Effect.Effect<void, never, RSchema>,
     queryAndSavePure,
     saveManyWithPure,
     byIdAndSaveWithPure,
@@ -268,7 +354,7 @@ export const extendRepo = <
   return {
     ...repo,
     ...exts
-  } as Repository<T, Encoded, Evt, ItemType, IdKey, RSchema, RPublish> & typeof exts
+  } as Repository<T, Encoded, Evt, ItemType, IdKey, RSchema, RPublish, RProvided> & typeof exts
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
@@ -279,5 +365,6 @@ export interface ExtendedRepository<
   ItemType extends string,
   IdKey extends keyof T & keyof Encoded,
   RSchema,
-  RPublish
-> extends ReturnType<typeof extendRepo<T, Encoded, Evt, ItemType, IdKey, RSchema, RPublish>> {}
+  RPublish,
+  RProvided = never
+> extends ReturnType<typeof extendRepo<T, Encoded, Evt, ItemType, IdKey, RSchema, RPublish, RProvided>> {}

package/src/Model/Repository/internal/internal.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type {} from "effect/Equal"
 import type {} from "effect/Hash"
-import { Array, Chunk, Effect, Equivalence, flow, type NonEmptyReadonlyArray, Option, pipe, Pipeable, PubSub, Result, S, SchemaAST, ServiceMap, Unify } from "effect-app"
+import { Array, Chunk, Context, Effect, Equivalence, flow, type NonEmptyReadonlyArray, Option, pipe, Pipeable, PubSub, Result, S, SchemaAST, Unify } from "effect-app"
 import { toNonEmptyArray } from "effect-app/Array"
 import { NotFoundError } from "effect-app/client/errors"
 import { flatMapOption } from "effect-app/Effect"
@@ -55,14 +55,14 @@ export function makeRepoInternal<
 
     function make<RInitial = never, E = never, RPublish = never, RCtx = never>(
       args: [Evt] extends [never] ? {
-          schemaContext?: ServiceMap.ServiceMap<RCtx>
+          schemaContext?: Context.Context<RCtx>
           makeInitial?: Effect.Effect<readonly T[], E, RInitial> | undefined
           config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
             partitionValue?: (e?: Encoded) => string
           }
         }
         : {
-          schemaContext?: ServiceMap.ServiceMap<RCtx>
+          schemaContext?: Context.Context<RCtx>
           publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect.Effect<void, never, RPublish>
           makeInitial?: Effect.Effect<readonly T[], E, RInitial> | undefined
           config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
@@ -72,12 +72,12 @@ export function makeRepoInternal<
     ) {
       return Effect
         .gen(function*() {
-          const rctx: ServiceMap.ServiceMap<RCtx> = args.schemaContext ?? ServiceMap.empty() as any
+          const rctx: Context.Context<RCtx> = args.schemaContext ?? Context.empty() as any
           const provideRctx = Effect.provide(rctx)
           const encodeMany = flow(
             S.encodeEffect(S.Array(schema)),
             provideRctx,
-            Effect.withSpan("encodeMany", {}, { captureStackTrace: false })
+            Effect.withSpan("encodeMany", { attributes: { itemType: name } }, { captureStackTrace: false })
           )
           const decode = flow(S.decodeEffect(schema), provideRctx)
           const decodeMany = flow(
@@ -113,11 +113,14 @@ export function makeRepoInternal<
               let ast = _.ast
               if (ast._tag === "Declaration") ast = ast.typeParameters[0]!
 
-              // In v4, to get the encoded (from) side of a schema, use SchemaAST.toEncoded
               const pickIdFromAst = (a: SchemaAST.AST) => {
-                const encoded = SchemaAST.toEncoded(a)
-                if (SchemaAST.isObjects(encoded)) {
-                  const field = encoded.propertySignatures.find((_) => _.name === idKey)
+                // Unwrap Declaration (e.g. TaggedClass) to get the underlying Objects AST
+                let inner = a
+                if (inner._tag === "Declaration") inner = inner.typeParameters[0]!
+                // Pick from the original AST to preserve the full encoding chain (e.g. decodeTo transformations).
+                // Using toEncoded would lose transformation info needed to encode Type -> Encoded.
+                if (SchemaAST.isObjects(inner)) {
+                  const field = inner.propertySignatures.find((_) => _.name === idKey)
                   if (field) {
                     return S.Struct({ [idKey]: S.make(field.type) }) as unknown as Codec<T, Encoded>
                   }
@@ -161,7 +164,7 @@ export function makeRepoInternal<
             )
           })
 
-          const find = Effect.fn("find")(function*(id: T[IdKey]) {
+          const find = Effect.fn("find", { attributes: { itemType: name } })(function*(id: T[IdKey]) {
             yield* Effect.annotateCurrentSpan({ itemId: id })
 
             return yield* flatMapOption(findE(id), (_) => Effect.orDie(decode(_)))
@@ -188,73 +191,76 @@ export function makeRepoInternal<
                 Effect.andThen(saveAllE)
               )
 
-          const saveAndPublish = Effect.fn("saveAndPublish")(function*(items: Iterable<T>, events: Iterable<Evt> = []) {
-            const it = Chunk.fromIterable(items)
-            const evts = [...events]
-            yield* Effect.annotateCurrentSpan({ itemIds: [...Chunk.map(it, (_) => _[idKey])], events: evts.length })
-            return yield* saveAll(it)
-              .pipe(
-                Effect.andThen(Effect.sync(() => toNonEmptyArray(evts))),
-                // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
-                (_) => flatMapOption(_, pub),
-                Effect.andThen(PubSub.publish(changeFeed, [Chunk.toArray(it), "save"] as [T[], "save" | "remove"])),
-                Effect.asVoid
-              )
-          })
+          const saveAndPublish = Effect.fn("saveAndPublish", { attributes: { itemType: name } })(
+            function*(items: Iterable<T>, events: Iterable<Evt> = []) {
+              const it = Chunk.fromIterable(items)
+              const evts = [...events]
+              yield* Effect.annotateCurrentSpan({ itemIds: [...Chunk.map(it, (_) => _[idKey])], events: evts.length })
+              return yield* saveAll(it)
+                .pipe(
+                  Effect.andThen(Effect.sync(() => toNonEmptyArray(evts))),
+                  // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
+                  (_) => flatMapOption(_, pub),
+                  Effect.andThen(PubSub.publish(changeFeed, [Chunk.toArray(it), "save"] as [T[], "save" | "remove"])),
+                  Effect.asVoid
+                )
+            }
+          )
 
-          const removeAndPublish = Effect.fn("removeAndPublish")(function*(a: Iterable<T>, events: Iterable<Evt> = []) {
-            const { set } = yield* cms
-            const it = [...a]
-            const evts = [...events]
-            yield* Effect.annotateCurrentSpan({ itemIds: it.map((_) => _[idKey]), eventCount: evts.length })
-            const items = yield* encodeMany(it).pipe(Effect.orDie)
-            if (Array.isReadonlyArrayNonEmpty(items)) {
-              yield* store.batchRemove(
-                items.map((_) => (_[idKey])),
-                args.config?.partitionValue?.(items[0])
-              )
-              for (const e of items) {
-                set(e[idKey], undefined)
-              }
-              yield* Effect
-                .sync(() => toNonEmptyArray(evts))
-                // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
-                .pipe((_) => flatMapOption(_, pub))
+          const removeAndPublish = Effect.fn("removeAndPublish", { attributes: { itemType: name } })(
+            function*(a: Iterable<T>, events: Iterable<Evt> = []) {
+              const { set } = yield* cms
+              const it = [...a]
+              const evts = [...events]
+              yield* Effect.annotateCurrentSpan({ itemIds: it.map((_) => _[idKey]), eventCount: evts.length })
+              const items = yield* encodeMany(it).pipe(Effect.orDie)
+              if (Array.isReadonlyArrayNonEmpty(items)) {
+                yield* store.batchRemove(
+                  items.map((_) => (_[idKey])),
+                  args.config?.partitionValue?.(items[0])
+                )
+                for (const e of items) {
+                  set(e[idKey], undefined)
+                }
+                yield* Effect
+                  .sync(() => toNonEmptyArray(evts))
+                  // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
+                  .pipe((_) => flatMapOption(_, pub))
 
-              yield* PubSub.publish(changeFeed, [it, "remove"] as [T[], "save" | "remove"])
+                yield* PubSub.publish(changeFeed, [it, "remove"] as [T[], "save" | "remove"])
+              }
             }
-          })
+          )
 
-          const removeById = Effect.fn("removeById")(function*(...ids: readonly T[IdKey][]) {
-            if (!Array.isReadonlyArrayNonEmpty(ids)) {
-              return
-            }
-            const { set } = yield* cms
-            const eids = yield* Effect.forEach(ids, (_) => encodeIdOnly(_ as any)).pipe(Effect.orDie)
-            yield* Effect.annotateCurrentSpan({ itemIds: eids })
-            yield* store.batchRemove(eids)
-            for (const id of eids) {
-              set(id, undefined)
+          const removeById = Effect.fn("removeById", { attributes: { itemType: name } })(
+            function*(idOrIds: T[IdKey] | ReadonlyArray<T[IdKey]>) {
+              const ids = globalThis.Array.isArray(idOrIds)
+                ? idOrIds as readonly T[IdKey][]
+                : [idOrIds as T[IdKey]]
+              if (!Array.isReadonlyArrayNonEmpty(ids)) {
+                return
+              }
+              const { set } = yield* cms
+              const eids = yield* Effect.forEach(ids, (_) => encodeIdOnly(_ as any)).pipe(Effect.orDie)
+              yield* Effect.annotateCurrentSpan({ itemIds: eids })
+              yield* store.batchRemove(eids)
+              for (const id of eids) {
+                set(id, undefined)
+              }
+              yield* PubSub.publish(changeFeed, [[], "remove"] as [T[], "save" | "remove"])
             }
-            yield* PubSub.publish(changeFeed, [[], "remove"] as [T[], "save" | "remove"])
-          })
+          )
 
-          const parseMany = (items: readonly PM[]) =>
-            Effect
-              .flatMap(cms, (cm) =>
-                decodeMany(items.map((_) => mapReverse(_, cm.set)))
-                  .pipe(Effect.orDie, Effect.withSpan("parseMany", {}, { captureStackTrace: false })))
-          const parseMany2 = <A, R>(
-            items: readonly PM[],
-            schema: S.Codec<A, Encoded, R>
-          ) =>
-            Effect
-              .flatMap(cms, (cm) =>
-                S
-                  .decodeEffect(S.Array(schema))(
-                    items.map((_) => mapReverse(_, cm.set))
-                  )
-                  .pipe(Effect.orDie, Effect.withSpan("parseMany2", {}, { captureStackTrace: false })))
+          const parseMany = Effect.fn("parseMany", { attributes: { itemType: name } })(function*(items: readonly PM[]) {
+            const cm = yield* cms
+            return yield* decodeMany(items.map((_) => mapReverse(_, cm.set))).pipe(Effect.orDie)
+          })
+          const parseMany2 = Effect.fn("parseMany2", { attributes: { itemType: name } })(
+            function*<A, R>(items: readonly PM[], schema: S.Codec<A, Encoded, R>) {
+              const cm = yield* cms
+              return yield* S.decodeEffect(S.Array(schema))(items.map((_) => mapReverse(_, cm.set))).pipe(Effect.orDie)
+            }
+          )
           const filter = <U extends keyof Encoded = keyof Encoded>(args: FilterArgs<Encoded, U>) =>
             store
               .filter(
@@ -276,10 +282,10 @@ export function makeRepoInternal<
           const query: {
             <A, R, From extends FieldValues>(
               q: Q.QueryProjection<Encoded extends From ? From : never, A, R>
-            ): Effect.Effect<readonly A[], S.SchemaError, R>
+            ): Effect.Effect<readonly A[], S.SchemaError, Exclude<R, RCtx>>
             <A, R, EncodedRefined extends Encoded = Encoded>(
               q: Q.QAll<NoInfer<Encoded>, NoInfer<EncodedRefined>, A, R>
-            ): Effect.Effect<readonly A[], never, R>
+            ): Effect.Effect<readonly A[], never, Exclude<R, RCtx>>
           } = (<A, R, EncodedRefined extends Encoded = Encoded>(q: Q.QAll<Encoded, EncodedRefined, A, R>) => {
             const a = Q.toFilter(q)
             const eff = a.mode === "project"
@@ -327,6 +333,7 @@ export function makeRepoInternal<
                 : eff,
               Effect.withSpan("Repository.query [effect-app/infra]", {
                 attributes: {
+                  itemType: name,
                   "repository.model_name": name,
                   query: { ...a, schema: a.schema ? "__SCHEMA__" : a.schema, filter: a.filter }
                 }
@@ -334,7 +341,7 @@ export function makeRepoInternal<
             )
           }) as any
 
-          const validateSample = Effect.fn("validateSample")(function*(options?: {
+          const validateSample = Effect.fn("validateSample", { attributes: { itemType: name } })(function*(options?: {
             percentage?: number
             maxItems?: number
           }) {
@@ -401,6 +408,7 @@ export function makeRepoInternal<
             saveAndPublish,
             removeAndPublish,
             removeById,
+            seedNamespace: (namespace: string) => store.seedNamespace(namespace),
             validateSample,
             queryRaw<A, Out, QR>(schema: S.Codec<A, Out, QR>, q: Q.RawQuery<Encoded, Out>) {
               const dec = S.decodeEffect(S.Array(schema))
@@ -441,12 +449,12 @@ export function makeRepoInternal<
                 // },
                 save: (...xes: any[]) =>
                   Effect.flatMap(encMany(xes), (_) => saveAllE(_)).pipe(
-                    Effect.withSpan("mapped.save", {}, { captureStackTrace: false })
+                    Effect.withSpan("mapped.save", { attributes: { itemType: name } }, { captureStackTrace: false })
                   )
               }
             }
           }
-          return r as Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<R, RCtx>, RPublish>
+          return r as Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<R, RCtx>, RPublish, RCtx>
         })
         .pipe(Effect
           // .withSpan("Repository.make [effect-app/infra]", { attributes: { "repository.model_name": name } })

package/src/Model/Repository/makeRepo.ts

@@ -7,11 +7,12 @@
 // import type { ParserEnv } from "effect-app/Schema/custom/Parser"
 import type {} from "effect/Equal"
 import type {} from "effect/Hash"
-import { Effect, type NonEmptyReadonlyArray, type S, type ServiceMap } from "effect-app"
+import { type Context, Effect, type NonEmptyReadonlyArray, type S } from "effect-app"
 import type { StoreConfig, StoreMaker } from "../../Store.js"
 import type { FieldValues } from "../filter/types.js"
 import { type ExtendedRepository, extendRepo } from "./ext.js"
 import { makeRepoInternal } from "./internal/internal.js"
+import { RepositoryRegistry } from "./Registry.js"
 import type { Repository } from "./service.js"
 
 export interface RepositoryOptions<
@@ -52,11 +53,11 @@ export interface RepositoryOptions<
    * 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?: ServiceMap.ServiceMap<RCtx>
+  schemaContext?: Context.Context<RCtx>
 
   overrides?: (
-    repo: Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish>
-  ) => Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish>
+    repo: Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish, RCtx>
+  ) => Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish, RCtx>
 }
 
 /**
@@ -83,9 +84,9 @@ export const makeRepo: {
     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>,
+    ExtendedRepository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish, RCtx>,
     E,
-    RInitial | StoreMaker
+    RInitial | StoreMaker | RepositoryRegistry
   >
   <
     ItemType extends string,
@@ -102,9 +103,9 @@ export const makeRepo: {
     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>,
+    ExtendedRepository<T, Encoded, Evt, ItemType, "id", Exclude<RSchema, RCtx>, RPublish, RCtx>,
     E,
-    RInitial | StoreMaker
+    RInitial | StoreMaker | RepositoryRegistry
   >
 } = <
   ItemType extends string,
@@ -135,5 +136,7 @@ export const makeRepo: {
     let r = yield* mkRepo.make<RInitial, E, RPublish, RCtx>(options as any)
     if (options.overrides) r = options.overrides(r)
     const repo = extendRepo(r)
+    const registry = yield* RepositoryRegistry
+    registry.register(itemType, repo)
     return repo
   })