@furystack/repository 10.1.11 → 11.0.1

package/src/data-set.spec.ts

@@ -0,0 +1,397 @@
+/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion -- false positives: discriminated `AuthorizationResult` mocks need explicit casts so vi.fn return types match the union (rule's tsutils-based check disagrees with tsc) */
+import type { StoreToken, WithOptionalId } from '@furystack/core'
+import { AuthorizationError, defineStore, InMemoryStore } from '@furystack/core'
+import { createInjector, type Injector } from '@furystack/inject'
+import { usingAsync } from '@furystack/utils'
+import { describe, expect, it, vi } from 'vitest'
+import type { AuthorizationResult, DataSetSettings } from './data-set-setting.js'
+import type { DataSet } from './data-set.js'
+import { defineDataSet, type DefineDataSetSettings } from './define-data-set.js'
+import { getDataSetFor } from './helpers.js'
+
+class TestClass {
+  declare id: number
+  declare value: string
+}
+
+// Token declared at module scope so TypeScript preserves the literal primary
+// key. The explicit `StoreToken<TestClass, 'id'>` annotation keeps
+// `TPrimaryKey` narrow when the token is later passed to `defineDataSet`;
+// inferred return types from `defineStore` tend to widen back to
+// `keyof TestClass` in downstream inference contexts.
+const TestStore: StoreToken<TestClass, 'id'> = defineStore({
+  name: 'test/DataSetSpecStore',
+  model: TestClass,
+  primaryKey: 'id',
+  factory: () => new InMemoryStore({ model: TestClass, primaryKey: 'id' }),
+})
+
+/**
+ * Builds a fresh injector with a disposable {@link InMemoryStore} bound as the
+ * backing store for a {@link TestClass} dataset. Each call mints a new
+ * dataset token so the injector cache starts from scratch for every test.
+ */
+const withDataSet = async (
+  settings: DefineDataSetSettings<TestClass, 'id'> | undefined,
+  fn: (ctx: { i: Injector; dataSet: DataSet<TestClass, 'id'> }) => Promise<void>,
+): Promise<void> => {
+  const TestDataSet = defineDataSet<TestClass, 'id', WithOptionalId<TestClass, 'id'>>({
+    name: `test/DataSet-${Math.random()}`,
+    store: TestStore,
+    settings,
+  })
+  await usingAsync(createInjector(), async (i) => {
+    const dataSet = getDataSetFor(i, TestDataSet)
+    await fn({ i, dataSet })
+  })
+}
+
+describe('DataSet', () => {
+  describe('Authorizers', () => {
+    describe('Add', () => {
+      it('adds an entity when no settings are provided', async () => {
+        await withDataSet(undefined, async ({ i, dataSet }) => {
+          await dataSet.add(i, { id: 1, value: 'asd' })
+          const result = await dataSet.get(i, 1)
+          expect(result?.value).toBe('asd')
+        })
+      })
+
+      it('runs authorizeAdd and persists the entity on pass', async () => {
+        const authorizeAdd = vi.fn(async () => ({ isAllowed: true }) as AuthorizationResult)
+        await withDataSet({ authorizeAdd }, async ({ i, dataSet }) => {
+          await dataSet.add(i, { id: 1, value: 'asd' })
+          expect(authorizeAdd).toHaveBeenCalled()
+          expect((await dataSet.get(i, 1))?.value).toBe('asd')
+        })
+      })
+
+      it('throws and does not persist when authorizeAdd fails', async () => {
+        const authorizeAdd = vi.fn(async () => ({ isAllowed: false, message: '...' }) as AuthorizationResult)
+        await withDataSet({ authorizeAdd }, async ({ i, dataSet }) => {
+          await expect(dataSet.add(i, { id: 1, value: 'asd' })).rejects.toBeInstanceOf(AuthorizationError)
+          expect(authorizeAdd).toHaveBeenCalled()
+          expect(await dataSet.get(i, 1)).toBeUndefined()
+        })
+      })
+
+      it('applies modifyOnAdd before persisting', async () => {
+        const modifyOnAdd = vi.fn<NonNullable<DataSetSettings<TestClass, 'id'>['modifyOnAdd']>>(async ({ entity }) => ({
+          ...entity,
+          value: entity.value.toUpperCase(),
+        }))
+        await withDataSet({ modifyOnAdd }, async ({ i, dataSet }) => {
+          await dataSet.add(i, { id: 1, value: 'asd' })
+          const result = await dataSet.get(i, 1)
+          expect(modifyOnAdd).toHaveBeenCalled()
+          expect(result?.value).toBe('ASD')
+        })
+      })
+
+      it('emits onEntityAdded after a successful add', async () => {
+        await withDataSet(undefined, async ({ i, dataSet }) => {
+          const listener = vi.fn()
+          dataSet.addListener('onEntityAdded', listener)
+          await dataSet.add(i, { id: 1, value: 'asd' })
+          expect(listener).toHaveBeenCalledWith(expect.objectContaining({ entity: { id: 1, value: 'asd' } }))
+        })
+      })
+    })
+
+    describe('Update', () => {
+      it('updates an entity when no settings are provided', async () => {
+        await withDataSet(undefined, async ({ i, dataSet }) => {
+          await dataSet.add(i, { id: 1, value: 'asd' })
+          await dataSet.update(i, 1, { id: 1, value: 'asd2' })
+          expect((await dataSet.get(i, 1))?.value).toBe('asd2')
+        })
+      })
+
+      it('runs authorizeUpdate and persists on pass', async () => {
+        const authorizeUpdate = vi.fn(async () => ({ isAllowed: true }) as AuthorizationResult)
+        await withDataSet({ authorizeUpdate }, async ({ i, dataSet }) => {
+          await dataSet.add(i, { id: 1, value: 'asd' })
+          await dataSet.update(i, 1, { id: 1, value: 'asd2' })
+          expect(authorizeUpdate).toHaveBeenCalled()
+          expect((await dataSet.get(i, 1))?.value).toBe('asd2')
+        })
+      })
+
+      it('throws when authorizeUpdate fails and leaves the entity untouched', async () => {
+        const authorizeUpdate = vi.fn(async () => ({ isAllowed: false, message: '...' }) as AuthorizationResult)
+        await withDataSet({ authorizeUpdate }, async ({ i, dataSet }) => {
+          await dataSet.add(i, { id: 1, value: 'asd' })
+          await expect(dataSet.update(i, 1, { id: 1, value: 'asd2' })).rejects.toBeInstanceOf(AuthorizationError)
+          expect((await dataSet.get(i, 1))?.value).toBe('asd')
+        })
+      })
+
+      it('runs authorizeUpdateEntity against the loaded entity and persists on pass', async () => {
+        const authorizeUpdateEntity = vi.fn(async () => ({ isAllowed: true }) as AuthorizationResult)
+        await withDataSet({ authorizeUpdateEntity }, async ({ i, dataSet }) => {
+          await dataSet.add(i, { id: 1, value: 'asd' })
+          await dataSet.update(i, 1, { id: 1, value: 'asd2' })
+          expect(authorizeUpdateEntity).toHaveBeenCalled()
+          expect((await dataSet.get(i, 1))?.value).toBe('asd2')
+        })
+      })
+
+      it('throws and leaves the entity untouched when authorizeUpdateEntity fails', async () => {
+        const authorizeUpdateEntity = vi.fn(async () => ({ isAllowed: false, message: '...' }) as AuthorizationResult)
+        await withDataSet({ authorizeUpdateEntity }, async ({ i, dataSet }) => {
+          await dataSet.add(i, { id: 1, value: 'asd' })
+          await expect(dataSet.update(i, 1, { id: 1, value: 'asd2' })).rejects.toBeInstanceOf(AuthorizationError)
+          expect((await dataSet.get(i, 1))?.value).toBe('asd')
+        })
+      })
+
+      it('applies modifyOnUpdate before persisting', async () => {
+        const modifyOnUpdate = vi.fn<NonNullable<DataSetSettings<TestClass, 'id'>['modifyOnUpdate']>>(
+          async ({ entity }) => ({
+            ...entity,
+            value: entity.value?.toUpperCase() ?? '',
+          }),
+        )
+        await withDataSet({ modifyOnUpdate }, async ({ i, dataSet }) => {
+          await dataSet.add(i, { id: 1, value: 'asd' })
+          await dataSet.update(i, 1, { id: 1, value: 'asd2' })
+          expect(modifyOnUpdate).toHaveBeenCalled()
+          expect((await dataSet.get(i, 1))?.value).toBe('ASD2')
+        })
+      })
+
+      it('emits onEntityUpdated with the applied change', async () => {
+        await withDataSet(undefined, async ({ i, dataSet }) => {
+          const listener = vi.fn()
+          dataSet.addListener('onEntityUpdated', listener)
+          await dataSet.add(i, { id: 1, value: 'asd' })
+          await dataSet.update(i, 1, { id: 1, value: 'asd2' })
+          expect(listener).toHaveBeenCalledWith(expect.objectContaining({ change: { id: 1, value: 'asd2' }, id: 1 }))
+        })
+      })
+    })
+
+    describe('Count', () => {
+      it('returns the count when no settings are provided', async () => {
+        await withDataSet(undefined, async ({ i, dataSet }) => {
+          await dataSet.add(i, { id: 1, value: 'asd' })
+          expect(await dataSet.count(i)).toBe(1)
+        })
+      })
+
+      it('returns the count when authorizeGet passes', async () => {
+        const authorizeGet = vi.fn(async () => ({ isAllowed: true, message: '' }) as AuthorizationResult)
+        await withDataSet({ authorizeGet }, async ({ i, dataSet }) => {
+          await dataSet.add(i, { id: 1, value: 'asd' })
+          expect(await dataSet.count(i)).toBe(1)
+        })
+      })
+
+      it('throws when authorizeGet fails', async () => {
+        const authorizeGet = vi.fn(async () => ({ isAllowed: false, message: ':(' }) as AuthorizationResult)
+        await withDataSet({ authorizeGet }, async ({ i, dataSet }) => {
+          await dataSet.add(i, { id: 1, value: 'asd' })
+          await expect(dataSet.count(i)).rejects.toBeInstanceOf(AuthorizationError)
+        })
+      })
+    })
+  })
+
+  describe('filter', () => {
+    it('returns the unfiltered result when no settings are provided', async () => {
+      await withDataSet(undefined, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'asd' })
+        expect((await dataSet.find(i, {})).length).toBe(1)
+      })
+    })
+
+    it('returns the unfiltered result when authorizeGet passes', async () => {
+      const authorizeGet = vi.fn(async () => ({ isAllowed: true, message: '' }) as AuthorizationResult)
+      await withDataSet({ authorizeGet }, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'asd' })
+        expect((await dataSet.find(i, {})).length).toBe(1)
+      })
+    })
+
+    it('throws when authorizeGet fails', async () => {
+      const authorizeGet = vi.fn(async () => ({ isAllowed: false, message: ':(' }) as AuthorizationResult)
+      await withDataSet({ authorizeGet }, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'asd' })
+        await expect(dataSet.find(i, {})).rejects.toBeInstanceOf(AuthorizationError)
+      })
+    })
+  })
+
+  describe('get', () => {
+    it('returns the entity when no settings are provided', async () => {
+      await withDataSet(undefined, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'asd' })
+        expect((await dataSet.get(i, 1))?.id).toBe(1)
+      })
+    })
+
+    it('returns the entity when authorizeGet passes', async () => {
+      const authorizeGet = vi.fn(async () => ({ isAllowed: true, message: '' }) as AuthorizationResult)
+      await withDataSet({ authorizeGet }, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'asd' })
+        expect((await dataSet.get(i, 1))?.id).toBe(1)
+      })
+    })
+
+    it('throws when authorizeGet fails', async () => {
+      const authorizeGet = vi.fn(async () => ({ isAllowed: false, message: ':(' }) as AuthorizationResult)
+      await withDataSet({ authorizeGet }, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'asd' })
+        await expect(dataSet.get(i, 1)).rejects.toBeInstanceOf(AuthorizationError)
+      })
+    })
+
+    it('returns the entity when authorizeGetEntity passes', async () => {
+      const authorizeGetEntity = vi.fn(async () => ({ isAllowed: true, message: '' }) as AuthorizationResult)
+      await withDataSet({ authorizeGetEntity }, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'asd' })
+        expect((await dataSet.get(i, 1))?.id).toBe(1)
+      })
+    })
+
+    it('throws when authorizeGetEntity fails', async () => {
+      const authorizeGetEntity = vi.fn(async () => ({ isAllowed: false, message: ':(' }) as AuthorizationResult)
+      await withDataSet({ authorizeGetEntity }, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'asd' })
+        await expect(dataSet.get(i, 1)).rejects.toBeInstanceOf(AuthorizationError)
+      })
+    })
+
+    it('receives the full entity in authorizeGetEntity even when select is used', async () => {
+      const authorizeGetEntity = vi.fn(async () => ({ isAllowed: true, message: '' }) as AuthorizationResult)
+      await withDataSet({ authorizeGetEntity }, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'asd' })
+        const result = await dataSet.get(i, 1, ['value'])
+        expect(authorizeGetEntity).toHaveBeenCalledTimes(1)
+        const firstCall = authorizeGetEntity.mock.calls[0] as unknown as [{ entity: TestClass }]
+        expect(firstCall[0].entity).toEqual({ id: 1, value: 'asd' })
+        expect(result).toEqual({ value: 'asd' })
+        expect(result).not.toHaveProperty('id')
+      })
+    })
+
+    it('returns undefined without calling authorizeGetEntity when the entity does not exist', async () => {
+      const authorizeGetEntity = vi.fn(async () => ({ isAllowed: true, message: '' }) as AuthorizationResult)
+      await withDataSet({ authorizeGetEntity }, async ({ i, dataSet }) => {
+        const result = await dataSet.get(i, 999)
+        expect(result).toBeUndefined()
+        expect(authorizeGetEntity).not.toHaveBeenCalled()
+      })
+    })
+  })
+
+  describe('remove', () => {
+    it('removes the entity when no settings are provided', async () => {
+      await withDataSet(undefined, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'asd' })
+        await dataSet.remove(i, 1)
+        expect(await dataSet.count(i)).toBe(0)
+      })
+    })
+
+    it('removes the entity when authorizeRemove passes', async () => {
+      const authorizeRemove = vi.fn(async () => ({ isAllowed: true, message: '' }) as AuthorizationResult)
+      await withDataSet({ authorizeRemove }, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'asd' })
+        await dataSet.remove(i, 1)
+        expect(await dataSet.count(i)).toBe(0)
+      })
+    })
+
+    it('throws and preserves the entity when authorizeRemove fails', async () => {
+      const authorizeRemove = vi.fn(async () => ({ isAllowed: false, message: ':(' }) as AuthorizationResult)
+      await withDataSet({ authorizeRemove }, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'asd' })
+        await expect(dataSet.remove(i, 1)).rejects.toBeInstanceOf(AuthorizationError)
+        expect(await dataSet.count(i)).toBe(1)
+      })
+    })
+
+    it('removes the entity when authorizeRemoveEntity passes', async () => {
+      const authorizeRemoveEntity = vi.fn(async () => ({ isAllowed: true, message: '' }) as AuthorizationResult)
+      await withDataSet({ authorizeRemoveEntity }, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'asd' })
+        await dataSet.remove(i, 1)
+        expect(await dataSet.count(i)).toBe(0)
+      })
+    })
+
+    it('throws and preserves the entity when authorizeRemoveEntity fails', async () => {
+      const authorizeRemoveEntity = vi.fn(async () => ({ isAllowed: false, message: ':(' }) as AuthorizationResult)
+      await withDataSet({ authorizeRemoveEntity }, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'asd' })
+        await expect(dataSet.remove(i, 1)).rejects.toBeInstanceOf(AuthorizationError)
+        expect(await dataSet.count(i)).toBe(1)
+      })
+    })
+
+    it('emits onEntityRemoved after a successful remove', async () => {
+      await withDataSet(undefined, async ({ i, dataSet }) => {
+        const listener = vi.fn()
+        dataSet.addListener('onEntityRemoved', listener)
+        await dataSet.add(i, { id: 1, value: 'asd' })
+        await dataSet.remove(i, 1)
+        expect(listener).toHaveBeenCalledWith(expect.objectContaining({ key: 1 }))
+      })
+    })
+
+    it('removes multiple entities at once', async () => {
+      await withDataSet(undefined, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'a' }, { id: 2, value: 'b' }, { id: 3, value: 'c' })
+        await dataSet.remove(i, 1, 3)
+        expect(await dataSet.count(i)).toBe(1)
+        expect((await dataSet.get(i, 2))?.value).toBe('b')
+      })
+    })
+
+    it('emits onEntityRemoved for each removed key', async () => {
+      await withDataSet(undefined, async ({ i, dataSet }) => {
+        const removedKeys: number[] = []
+        dataSet.addListener('onEntityRemoved', ({ key }) => {
+          removedKeys.push(key)
+        })
+        await dataSet.add(i, { id: 1, value: 'a' }, { id: 2, value: 'b' })
+        await dataSet.remove(i, 1, 2)
+        expect(removedKeys).toEqual([1, 2])
+      })
+    })
+
+    it('authorizes each entity when authorizeRemoveEntity is set', async () => {
+      const authorizeRemoveEntity = vi.fn(async () => ({ isAllowed: true, message: '' }) as AuthorizationResult)
+      await withDataSet({ authorizeRemoveEntity }, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'a' }, { id: 2, value: 'b' })
+        await dataSet.remove(i, 1, 2)
+        expect(authorizeRemoveEntity).toHaveBeenCalledTimes(2)
+        expect(await dataSet.count(i)).toBe(0)
+      })
+    })
+
+    it('does not remove anything when authorizeRemoveEntity fails for one entity (all-or-nothing)', async () => {
+      const authorizeRemoveEntity = vi.fn(async ({ entity }: { entity: TestClass }) => {
+        if (entity.id === 2) {
+          return { isAllowed: false, message: 'forbidden' } as AuthorizationResult
+        }
+        return { isAllowed: true } as AuthorizationResult
+      })
+      await withDataSet({ authorizeRemoveEntity }, async ({ i, dataSet }) => {
+        await dataSet.add(i, { id: 1, value: 'a' }, { id: 2, value: 'b' }, { id: 3, value: 'c' })
+        await expect(dataSet.remove(i, 1, 2, 3)).rejects.toBeInstanceOf(AuthorizationError)
+        expect(await dataSet.count(i)).toBe(3)
+      })
+    })
+
+    it('no-ops when called without keys', async () => {
+      await withDataSet(undefined, async ({ i, dataSet }) => {
+        const listener = vi.fn()
+        dataSet.addListener('onEntityRemoved', listener)
+        await dataSet.remove(i)
+        expect(listener).not.toHaveBeenCalled()
+      })
+    })
+  })
+})

package/src/data-set.ts

@@ -1,34 +1,36 @@
-import type { CreateResult, FilterType, FindOptions, PartialResult, WithOptionalId } from '@furystack/core'
+import type {
+  CreateResult,
+  FilterType,
+  FindOptions,
+  PartialResult,
+  PhysicalStore,
+  WithOptionalId,
+} from '@furystack/core'
 import { AuthorizationError, selectFields } from '@furystack/core'
 import type { Injector } from '@furystack/inject'
 import { EventHub, type ListenerErrorPayload } from '@furystack/utils'
 import type { DataSetSettings } from './data-set-setting.js'
 
 /**
- * An authorized Repository Store instance that wraps a {@link PhysicalStore} with authorization,
- * modification hooks, and event dispatching.
+ * Authorization-enforcing wrapper around a {@link PhysicalStore}. The
+ * recommended write gateway for application code — `furystack/no-direct-store-token`
+ * enforces this. Each mutation runs the relevant `authorize*` and
+ * `modify*` callbacks from {@link DataSetSettings}, persists, then emits
+ * `onEntityAdded` / `onEntityUpdated` / `onEntityRemoved` (consumed by
+ * entity sync, audit logs).
  *
- * The DataSet is the **recommended write gateway** for all entity mutations. Writing through the DataSet
- * ensures that authorization rules are enforced, modification hooks are applied, and change events
- * (`onEntityAdded`, `onEntityUpdated`, `onEntityRemoved`) are emitted -- which are required for features
- * like entity sync to function correctly.
- *
- * All mutating methods require an `injector` parameter that provides the caller's context (e.g. the current
- * user's identity). For server-side or background operations that don't originate from an HTTP request,
- * use {@link useSystemIdentityContext} to create a scoped child injector with elevated privileges.
+ * Mutating methods take an `injector` parameter to surface caller identity
+ * to the authorizers. For server-side / background work without an HTTP
+ * request, wrap the injector with `useSystemIdentityContext` from
+ * `@furystack/core`.
  *
  * @example
  * ```ts
- * import { useSystemIdentityContext } from '@furystack/core'
- * import { getDataSetFor } from '@furystack/repository'
- * import { usingAsync } from '@furystack/utils'
- *
- * // Server-side write with an elevated identity
  * await usingAsync(
  *   useSystemIdentityContext({ injector, username: 'background-job' }),
  *   async (systemInjector) => {
- *     const dataSet = getDataSetFor(systemInjector, MyModel, 'id')
- *     await dataSet.add(systemInjector, newEntity)
+ *     const dataSet = getDataSetFor(systemInjector, UserDataSet)
+ *     await dataSet.add(systemInjector, { username: 'alice', roles: [] })
  *   },
  * )
  * ```
@@ -42,20 +44,8 @@ export class DataSet<T, TPrimaryKey extends keyof T, TWritableData = WithOptiona
   }>
   implements Disposable
 {
-  /**
-   * Primary key of the contained entity
-   */
   public primaryKey: TPrimaryKey
 
-  /**
-   * Adds an entity to the DataSet.
-   * Runs authorization checks, applies modification hooks, persists to the physical store,
-   * and emits an `onEntityAdded` event for each created entity.
-   * @param injector The injector from the caller's context. For server-side or background operations
-   *   without an HTTP request, use a child injector with an elevated {@link IdentityContext}.
-   * @param entities The entities to add
-   * @returns The CreateResult with the created entities
-   */
   public async add(injector: Injector, ...entities: TWritableData[]): Promise<CreateResult<T>> {
     await Promise.all(
       entities.map(async (entity) => {
@@ -81,15 +71,6 @@ export class DataSet<T, TPrimaryKey extends keyof T, TWritableData = WithOptiona
     return createResult
   }
 
-  /**
-   * Updates an entity in the store.
-   * Runs authorization checks, applies modification hooks, persists to the physical store,
-   * and emits an `onEntityUpdated` event.
-   * @param injector The injector from the caller's context. For server-side or background operations
-   *   without an HTTP request, use a child injector with an elevated {@link IdentityContext}.
-   * @param id The identifier of the entity
-   * @param change The update
-   */
   public async update(injector: Injector, id: T[TPrimaryKey], change: Partial<T>): Promise<void> {
     if (this.settings.authorizeUpdate) {
       const result = await this.settings.authorizeUpdate({ injector, change })
@@ -113,12 +94,6 @@ export class DataSet<T, TPrimaryKey extends keyof T, TWritableData = WithOptiona
     this.emit('onEntityUpdated', { injector, change: parsed, id })
   }
 
-  /**
-   * Returns a Promise with the entity count
-   * @param injector The Injector from the context
-   * @param filter The Filter that will be applied
-   * @returns the Count
-   */
   public async count(injector: Injector, filter?: FilterType<T>): Promise<number> {
     if (this.settings.authorizeGet) {
       const result = await this.settings.authorizeGet({ injector })
@@ -129,12 +104,6 @@ export class DataSet<T, TPrimaryKey extends keyof T, TWritableData = WithOptiona
     return await this.settings.physicalStore.count(filter)
   }
 
-  /**
-   * Returns a filtered subset of the entity
-   * @param injector The Injector from the context
-   * @param filter The Filter definition
-   * @returns A result with the current items
-   */
   public async find<TFields extends Array<keyof T>>(
     injector: Injector,
     filter: FindOptions<T, TFields>,
@@ -149,13 +118,6 @@ export class DataSet<T, TPrimaryKey extends keyof T, TWritableData = WithOptiona
     return this.settings.physicalStore.find(parsedFilter)
   }
 
-  /**
-   * Returns an entity based on its primary key
-   * @param injector The injector from the context
-   * @param key The identifier of the entity
-   * @param select A field list used for projection
-   * @returns An item with the current unique key or Undefined
-   */
   public async get<TSelect extends Array<keyof T>>(
     injector: Injector,
     key: T[TPrimaryKey],
@@ -172,30 +134,24 @@ export class DataSet<T, TPrimaryKey extends keyof T, TWritableData = WithOptiona
       if (!fullEntity) {
         return undefined
       }
-      const result = await this.settings.authorizeGetEntity({ injector, entity: fullEntity as T })
+      const result = await this.settings.authorizeGetEntity({ injector, entity: fullEntity })
       if (!result.isAllowed) {
         throw new AuthorizationError(result.message)
       }
       if (select) {
         return selectFields(fullEntity as T & object, ...select)
       }
-      return fullEntity as PartialResult<T, TSelect>
+      return fullEntity
     }
     return await this.settings.physicalStore.get(key, select)
   }
 
   /**
-   * Removes one or more entities based on their primary keys.
-   * Runs authorization checks (all-or-nothing), persists to the physical store,
-   * and emits an `onEntityRemoved` event for each removed entity.
-   *
-   * When `authorizeRemoveEntity` is configured, only entities that exist in the store
-   * are authorized. Keys that don't match any entity are silently forwarded to the
-   * physical store's `remove()` call.
-   * @param injector The injector from the caller's context. For server-side or background operations
-   *   without an HTTP request, use a child injector with an elevated {@link IdentityContext}.
-   * @param keys The primary keys of the entities to remove
-   * @returns A promise that will be resolved / rejected based on the remove success
+   * Removes by primary key. Pre-load `authorizeRemove` and per-entity
+   * `authorizeRemoveEntity` are all-or-nothing — any rejection aborts the
+   * whole batch before any persist call. When `authorizeRemoveEntity` is
+   * configured, missing keys are silently forwarded to the physical store
+   * (no entity to authorize).
    */
   public async remove(injector: Injector, ...keys: Array<T[TPrimaryKey]>): Promise<void> {
     if (keys.length === 0) {
@@ -213,7 +169,7 @@ export class DataSet<T, TPrimaryKey extends keyof T, TWritableData = WithOptiona
       })
       await Promise.all(
         entities.map(async (entity) => {
-          const removeResult = await this.settings.authorizeRemoveEntity!({ injector, entity: entity as T })
+          const removeResult = await this.settings.authorizeRemoveEntity!({ injector, entity })
           if (!removeResult.isAllowed) {
             throw new AuthorizationError(removeResult.message)
           }