improve: align remove/removeById/save

Author: patroza

.changeset/remove-by-id-array.md

@@ -0,0 +1,5 @@
+---
+"@effect-app/infra": patch
+---
+
+`removeById` now takes `id | NonEmptyReadonlyArray<id>` instead of a variadic rest, and the extended repo's `removeById` accepts a `batch` option to chunk large deletes — consistent with `save` and `remove`.

.claude/settings.json

@@ -4,7 +4,8 @@
       "Bash(git commit -m ':*)",
       "Bash(pnpm -r check)",
       "Bash(pnpm lint-fix:*)",
-      "Bash(git commit -m ' *)"
+      "Bash(git commit -m ' *)",
+      "Read(//home/patroza/pj/effect-app/**)"
     ]
   }
 }

packages/infra/src/Model/Repository/ext.ts

@@ -263,6 +263,10 @@ export const extendRepo = <
     request: (id: T[IdKey]) => Effect.request(_request({ id }), requestResolver),
     get,
     log: (evt: Evt) => AnyPureDSL.log(evt),
+    /**
+     * Enables chunked writes for large batches via `options.batch`.
+     * Note: batching breaks transactional properties because chunks are saved independently.
+     */
     save: ((itemOrItems: T | NonEmptyReadonlyArray<T>, options?: BatchOptions) => {
       const items = asReadonlyArray(itemOrItems)
       const batchSize = getBatchSize(options?.batch)
@@ -274,23 +278,19 @@ export const extendRepo = <
         (batch) => repo.saveAndPublish(batch),
         { discard: true }
       )
-    }) as {
-      (item: T, options?: BatchOptions): Effect.Effect<
-        void,
-        InvalidStateError | OptimisticConcurrencyException,
-        RSchema | RPublish
-      >
-      (items: NonEmptyReadonlyArray<T>, options?: BatchOptions): Effect.Effect<
-        void,
-        InvalidStateError | OptimisticConcurrencyException,
-        RSchema | RPublish
-      >
-      /**
-       * Enables chunked writes for large batches.
-       * Note: batching breaks transactional properties because chunks are saved independently.
-       */
-    },
+    }) as (
+      itemOrItems: T | NonEmptyReadonlyArray<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 | NonEmptyReadonlyArray<T>, options?: BatchOptions) => {
       const items = asReadonlyArray(itemOrItems)
       const batchSize = getBatchSize(options?.batch)
@@ -302,14 +302,29 @@ export const extendRepo = <
         (batch) => repo.removeAndPublish(batch),
         { discard: true }
       )
-    }) as {
-      (item: T, options?: BatchOptions): Effect.Effect<void, never, RSchema | RPublish>
-      (items: NonEmptyReadonlyArray<T>, options?: BatchOptions): Effect.Effect<void, never, RSchema | RPublish>
-      /**
-       * Enables chunked deletes for large batches.
-       * Note: batching breaks transactional properties because chunks are removed independently.
-       */
-    },
+    }) as (
+      itemOrItems: T | NonEmptyReadonlyArray<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] | NonEmptyReadonlyArray<T[IdKey]>, options?: BatchOptions) => {
+      const ids = asReadonlyArray(idOrIds) as NonEmptyReadonlyArray<T[IdKey]>
+      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] | NonEmptyReadonlyArray<T[IdKey]>,
+      options?: BatchOptions
+    ) => Effect.Effect<void, never, RSchema>,
     queryAndSavePure,
     saveManyWithPure,
     byIdAndSaveWithPure,

packages/infra/src/Model/Repository/internal/internal.ts

@@ -233,7 +233,10 @@ export function makeRepoInternal<
           )
 
           const removeById = Effect.fn("removeById", { attributes: { itemType: name } })(
-            function*(...ids: readonly T[IdKey][]) {
+            function*(idOrIds: T[IdKey] | NonEmptyReadonlyArray<T[IdKey]>) {
+              const ids = globalThis.Array.isArray(idOrIds)
+                ? idOrIds as readonly T[IdKey][]
+                : [idOrIds as T[IdKey]]
               if (!Array.isReadonlyArrayNonEmpty(ids)) {
                 return
               }

packages/infra/src/Model/Repository/service.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type { Effect, Option, PubSub, S } from "effect-app"
+import type { Effect, NonEmptyReadonlyArray, Option, PubSub, S } from "effect-app"
 import type { InvalidStateError, NotFoundError, OptimisticConcurrencyException } from "effect-app/client/errors"
 import type { NonNegativeInt } from "effect-app/Schema/numbers"
 import type { FieldValues, IsNever, ResolveFirstLevel } from "../filter/types.js"
@@ -31,7 +31,9 @@ export interface Repository<
     events?: Iterable<Evt>
   ) => Effect.Effect<void, never, RSchema | RPublish>
 
-  readonly removeById: (...id: readonly T[IdKey][]) => Effect.Effect<void, never, RSchema>
+  readonly removeById: (
+    idOrIds: T[IdKey] | NonEmptyReadonlyArray<T[IdKey]>
+  ) => Effect.Effect<void, never, RSchema>
 
   readonly queryRaw: <T, Out, R>(
     schema: S.Codec<T, Out, R>,

packages/infra/test/rawQuery.test.ts

@@ -409,7 +409,7 @@ describe("removeByIds", () => {
 
       yield* repo.saveAndPublish(items)
       const itemsAfterSave = yield* repo.all
-      yield* repo.removeById(...items.slice(0, 2).map((_) => _.id))
+      yield* repo.removeById([items[0]!.id, items[1]!.id])
 
       const items2 = yield* repo.all