@furystack/repository 10.1.10 → 11.0.0

package/src/helpers.ts

@@ -1,27 +1,26 @@
-import type { Constructable, Injector } from '@furystack/inject'
-import { Repository } from './repository.js'
+import type { WithOptionalId } from '@furystack/core'
+import type { Injector } from '@furystack/inject'
+import type { DataSet } from './data-set.js'
+import type { DataSetToken } from './define-data-set.js'
 
 /**
- * Returns a Repository on an injector
- * @param injector The Injector instance
- * @returns The Repository instance
- */
-export const getRepository = (injector: Injector) => injector.getInstance(Repository)
-
-/**
- * Gets a DataSet for a specific model from the repository.
+ * Resolves the {@link DataSet} identified by the supplied {@link DataSetToken}
+ * on the given injector.
  *
- * The DataSet is the recommended way to perform all entity mutations (add, update, remove).
- * Writing through the DataSet ensures that authorization, modification hooks, and change events
- * are properly triggered -- which is required for features like entity sync.
+ * Writing through the returned DataSet ensures authorization, modification
+ * hooks and change events (required for features such as entity sync) are
+ * triggered. Prefer this over direct physical-store access in application
+ * code.
  *
- * 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.
+ * For server-side or background operations that don't originate from an HTTP
+ * request, use
+ * {@link import('@furystack/core').useSystemIdentityContext | useSystemIdentityContext}
+ * to create a scoped child injector with elevated privileges before calling
+ * this helper.
  *
- * @param injector The Injector instance
- * @param model The Model
- * @param primaryKey The Primary Key field
- * @returns A Repository DataSet for a specific model
+ * @param injector - Any injector in the scope chain.
+ * @param token - The data-set token created by `defineDataSet`.
+ * @returns The cached {@link DataSet} instance.
  *
  * @example
  * ```ts
@@ -29,18 +28,16 @@ export const getRepository = (injector: Injector) => injector.getInstance(Reposi
  * import { getDataSetFor } from '@furystack/repository'
  * import { usingAsync } from '@furystack/utils'
  *
- * // In a background job or service
  * 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: [] })
  *   },
  * )
  * ```
  */
-export const getDataSetFor = <T, TPrimaryKey extends keyof T>(
+export const getDataSetFor = <T, TPrimaryKey extends keyof T, TWritableData = WithOptionalId<T, TPrimaryKey>>(
   injector: Injector,
-  model: Constructable<T>,
-  primaryKey: TPrimaryKey,
-) => injector.getInstance(Repository).getDataSetFor(model, primaryKey)
+  token: DataSetToken<T, TPrimaryKey, TWritableData>,
+): DataSet<T, TPrimaryKey, TWritableData> => injector.get(token)

package/src/index.ts

@@ -1,4 +1,4 @@
-export * from './repository.js'
-export * from './data-set.js'
 export * from './data-set-setting.js'
+export * from './data-set.js'
+export * from './define-data-set.js'
 export * from './helpers.js'

package/esm/dataset.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=dataset.spec.d.ts.map

package/esm/dataset.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dataset.spec.d.ts","sourceRoot":"","sources":["../src/dataset.spec.ts"],"names":[],"mappings":""}

package/esm/dataset.spec.js

@@ -1,552 +0,0 @@
-import { AuthorizationError, InMemoryStore, addStore } from '@furystack/core';
-import { Injector } from '@furystack/inject';
-import { usingAsync } from '@furystack/utils';
-import { describe, expect, it, vi } from 'vitest';
-import { getDataSetFor, getRepository } from './helpers.js';
-import { Repository } from './repository.js';
-class TestClass {
-    id = 1;
-    value = '';
-}
-describe('DataSet', () => {
-    describe('Construction', () => {
-        it('can be retrieved from an extension method with class', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                addStore(i, new InMemoryStore({
-                    model: TestClass,
-                    primaryKey: 'id',
-                }));
-                getRepository(i).createDataSet(TestClass, 'id');
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                expect(dataSet.settings.physicalStore.model).toBe(TestClass);
-            });
-        });
-        it('can be retrieved from an extension method with string', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                addStore(i, new InMemoryStore({
-                    model: TestClass,
-                    primaryKey: 'id',
-                }));
-                getRepository(i).createDataSet(TestClass, 'id');
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                expect(dataSet.settings.physicalStore.model).toBe(TestClass);
-            });
-        });
-        it('Should throw if dataset is not registered through extension', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                expect(() => getDataSetFor(i, TestClass, 'id')).toThrow(/No DataSet found for 'class TestClass/);
-            });
-        });
-        it('Should throw if dataset is not registered through service', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                expect(() => i.getInstance(Repository).getDataSetFor(TestClass, 'id')).toThrowError(/No DataSet found for 'class TestClass/);
-            });
-        });
-        it('Should throw error on mismatched primary key', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id', {});
-                expect(() => getDataSetFor(i, TestClass, 'name')).toThrowError();
-            });
-        });
-    });
-    describe('Authorizers', () => {
-        describe('Add', () => {
-            it('should add an entity if no settings are provided', async () => {
-                await usingAsync(new Injector(), async (i) => {
-                    addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                    getRepository(i).createDataSet(TestClass, 'id');
-                    const dataSet = getDataSetFor(i, TestClass, 'id');
-                    await dataSet.add(i, { id: 1, value: 'asd' });
-                    const result = await dataSet.get(i, 1);
-                    expect(result && result.value).toBe('asd');
-                });
-            });
-            it('should call the add async authorizer and add the entity on pass', async () => {
-                await usingAsync(new Injector(), async (i) => {
-                    const authorizeAdd = vi.fn(async () => ({ isAllowed: true }));
-                    addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                    getRepository(i).createDataSet(TestClass, 'id', { authorizeAdd });
-                    const dataSet = getDataSetFor(i, TestClass, 'id');
-                    await dataSet.add(i, { id: 1, value: 'asd' });
-                    expect(authorizeAdd).toBeCalled();
-                    const added = await dataSet.get(i, 1);
-                    expect(added && added.value).toBe('asd');
-                });
-            });
-            it('should throw if the add authorizer returns a non-valid result and should not add a value to the store', async () => {
-                await usingAsync(new Injector(), async (i) => {
-                    const authorizeAdd = vi.fn(async () => ({ isAllowed: false, message: '...' }));
-                    addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                    getRepository(i).createDataSet(TestClass, 'id', { authorizeAdd });
-                    const dataSet = getDataSetFor(i, TestClass, 'id');
-                    try {
-                        await dataSet.add(i, { id: 1, value: 'asd' });
-                        throw Error('Should throw');
-                    }
-                    catch (error) {
-                        /** */
-                        expect(authorizeAdd).toBeCalled();
-                        const added = await dataSet.get(i, 1);
-                        expect(added).toBeUndefined();
-                    }
-                });
-            });
-            it('should modify an entity on add, if modifyOnAdd is provided', async () => {
-                await usingAsync(new Injector(), async (i) => {
-                    const modifyOnAdd = vi.fn(async (options) => ({
-                        ...options.entity,
-                        value: options.entity.value.toUpperCase(),
-                    }));
-                    addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                    getRepository(i).createDataSet(TestClass, 'id', { modifyOnAdd });
-                    const dataSet = getDataSetFor(i, TestClass, 'id');
-                    await dataSet.add(i, { id: 1, value: 'asd' });
-                    const result = await dataSet.get(i, 1);
-                    expect(modifyOnAdd).toBeCalled();
-                    expect(result && result.value).toBe('ASD');
-                });
-            });
-            it('should call the onEntityAdded callback if an entity has been added', async () => {
-                await usingAsync(new Injector(), async (i) => {
-                    expect.assertions(1);
-                    addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                    getRepository(i).createDataSet(TestClass, 'id', {});
-                    getRepository(i)
-                        .getDataSetFor(TestClass, 'id')
-                        .subscribe('onEntityAdded', ({ entity }) => {
-                        expect(entity.value).toBe('asd');
-                    });
-                    const dataSet = getDataSetFor(i, TestClass, 'id');
-                    await dataSet.add(i, { id: 1, value: 'asd' });
-                });
-            });
-        });
-        describe('Update', () => {
-            it('should update an entity if no settings are provided', async () => {
-                await usingAsync(new Injector(), async (i) => {
-                    addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                    getRepository(i).createDataSet(TestClass, 'id');
-                    const dataSet = getDataSetFor(i, TestClass, 'id');
-                    await dataSet.add(i, { id: 1, value: 'asd' });
-                    await dataSet.update(i, 1, { id: 1, value: 'asd2' });
-                    const result = await dataSet.get(i, 1);
-                    expect(result && result.value).toBe('asd2');
-                });
-            });
-            it('should call the authorizeUpdate authorizer and add the entity on pass', async () => {
-                await usingAsync(new Injector(), async (i) => {
-                    const authorizeUpdate = vi.fn(async () => ({ isAllowed: true }));
-                    addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                    getRepository(i).createDataSet(TestClass, 'id', { authorizeUpdate });
-                    const dataSet = getDataSetFor(i, TestClass, 'id');
-                    await dataSet.add(i, { id: 1, value: 'asd' });
-                    await dataSet.update(i, 1, { id: 1, value: 'asd2' });
-                    expect(authorizeUpdate).toBeCalled();
-                    const added = await dataSet.get(i, 1);
-                    expect(added && added.value).toBe('asd2');
-                });
-            });
-            it('should throw if the authorizeUpdateEntity returns a non-valid result and should not update a value to the store', async () => {
-                await usingAsync(new Injector(), async (i) => {
-                    const authorizeUpdateEntity = vi.fn(async () => ({ isAllowed: false, message: '...' }));
-                    addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                    getRepository(i).createDataSet(TestClass, 'id', { authorizeUpdateEntity });
-                    const dataSet = getDataSetFor(i, TestClass, 'id');
-                    try {
-                        await dataSet.add(i, { id: 1, value: 'asd' });
-                        await dataSet.update(i, 1, { id: 1, value: 'asd2' });
-                        throw Error('Should throw');
-                    }
-                    catch (error) {
-                        /** */
-                        expect(authorizeUpdateEntity).toBeCalled();
-                        const added = await dataSet.get(i, 1);
-                        expect(added && added.value).toBe('asd');
-                    }
-                });
-            });
-            it('should call the authorizeUpdateEntity authorizer and add the entity on pass', async () => {
-                await usingAsync(new Injector(), async (i) => {
-                    const authorizeUpdateEntity = vi.fn(async () => ({ isAllowed: true }));
-                    addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                    getRepository(i).createDataSet(TestClass, 'id', { authorizeUpdateEntity });
-                    const dataSet = getDataSetFor(i, TestClass, 'id');
-                    await dataSet.add(i, { id: 1, value: 'asd' });
-                    await dataSet.update(i, 1, { id: 1, value: 'asd2' });
-                    expect(authorizeUpdateEntity).toBeCalled();
-                    const added = await dataSet.get(i, 1);
-                    expect(added && added.value).toBe('asd2');
-                });
-            });
-            it('should throw if the authorizeUpdate returns a non-valid result and should not update a value to the store', async () => {
-                await usingAsync(new Injector(), async (i) => {
-                    const authorizeUpdate = vi.fn(async () => ({ isAllowed: false, message: '...' }));
-                    addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                    getRepository(i).createDataSet(TestClass, 'id', { authorizeUpdate });
-                    const dataSet = getDataSetFor(i, TestClass, 'id');
-                    try {
-                        await dataSet.add(i, { id: 1, value: 'asd' });
-                        await dataSet.update(i, 1, { id: 1, value: 'asd2' });
-                        throw Error('Should throw');
-                    }
-                    catch (error) {
-                        /** */
-                        expect(authorizeUpdate).toBeCalled();
-                        const added = await dataSet.get(i, 1);
-                        expect(added && added.value).toBe('asd');
-                    }
-                });
-            });
-            it('should modify an entity on update, if modifyOnAdd is provided', async () => {
-                await usingAsync(new Injector(), async (i) => {
-                    const modifyOnUpdate = vi.fn(async (options) => ({
-                        ...options.entity,
-                        value: options.entity.value?.toUpperCase(),
-                    }));
-                    addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                    getRepository(i).createDataSet(TestClass, 'id', { modifyOnUpdate });
-                    const dataSet = getDataSetFor(i, TestClass, 'id');
-                    await dataSet.add(i, { id: 1, value: 'asd' });
-                    await dataSet.update(i, 1, { id: 1, value: 'asd2' });
-                    const result = await dataSet.get(i, 1);
-                    expect(modifyOnUpdate).toBeCalled();
-                    expect(result && result.value).toBe('ASD2');
-                });
-            });
-            it('should publish to the onEntityUpdated observable if an entity has been updated', async () => {
-                await usingAsync(new Injector(), async (i) => {
-                    expect.assertions(1);
-                    addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                    getRepository(i).createDataSet(TestClass, 'id');
-                    getRepository(i)
-                        .getDataSetFor(TestClass, 'id')
-                        .subscribe('onEntityUpdated', ({ change }) => {
-                        expect(change).toEqual({ id: 1, value: 'asd2' });
-                    });
-                    const dataSet = getDataSetFor(i, TestClass, 'id');
-                    await dataSet.add(i, { id: 1, value: 'asd' });
-                    await dataSet.update(i, 1, { id: 1, value: 'asd2' });
-                });
-            });
-        });
-        describe('Count', () => {
-            it('should return the count if no settings are provided', async () => {
-                await usingAsync(new Injector(), async (i) => {
-                    addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                    getRepository(i).createDataSet(TestClass, 'id');
-                    const dataSet = getDataSetFor(i, TestClass, 'id');
-                    await dataSet.add(i, { id: 1, value: 'asd' });
-                    const result = await dataSet.count(i);
-                    expect(result).toBe(1);
-                });
-            });
-            it('should return the count if authorizeGet returns valid result', async () => {
-                await usingAsync(new Injector(), async (i) => {
-                    const authorizeGet = vi.fn(async () => ({ isAllowed: true, message: '' }));
-                    addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                    getRepository(i).createDataSet(TestClass, 'id', { authorizeGet });
-                    const dataSet = getDataSetFor(i, TestClass, 'id');
-                    await dataSet.add(i, { id: 1, value: 'asd' });
-                    const result = await dataSet.count(i);
-                    expect(result).toBe(1);
-                });
-            });
-            it('should throw if authorizeGet returns invalid result', async () => {
-                await usingAsync(new Injector(), async (i) => {
-                    const authorizeGet = vi.fn(async () => ({ isAllowed: false, message: ':(' }));
-                    addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                    getRepository(i).createDataSet(TestClass, 'id', { authorizeGet });
-                    const dataSet = getDataSetFor(i, TestClass, 'id');
-                    await dataSet.add(i, { id: 1, value: 'asd' });
-                    try {
-                        await dataSet.count(i);
-                        throw Error('Should throw');
-                    }
-                    catch (error) {
-                        /** */
-                    }
-                });
-            });
-        });
-    });
-    describe('filter', () => {
-        it('should return the unfiltered result if no settings are provided', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id');
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'asd' });
-                const result = await dataSet.find(i, {});
-                expect(result.length).toBe(1);
-            });
-        });
-        it('should return the unfiltered result if authorizeGet returns valid result', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                const authorizeGet = vi.fn(async () => ({ isAllowed: true, message: '' }));
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id', { authorizeGet });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'asd' });
-                const result = await dataSet.find(i, {});
-                expect(result.length).toBe(1);
-            });
-        });
-        it('should throw if authorizeGet returns invalid result', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                const authorizeGet = vi.fn(async () => ({ isAllowed: false, message: ':(' }));
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id', { authorizeGet });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'asd' });
-                try {
-                    await dataSet.find(i, {});
-                    throw Error('Should throw');
-                }
-                catch (error) {
-                    /** */
-                }
-            });
-        });
-    });
-    describe('get', () => {
-        it('should return the entity if no settings are provided', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id');
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'asd' });
-                const result = await dataSet.get(i, 1);
-                expect(result && result.id).toBe(1);
-            });
-        });
-        it('should return the entity if authorizeGet returns valid result', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                const authorizeGet = vi.fn(async () => ({ isAllowed: true, message: '' }));
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id', { authorizeGet });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'asd' });
-                const result = await dataSet.get(i, 1);
-                expect(result && result.id).toBe(1);
-            });
-        });
-        it('should throw if authorizeGet returns invalid result', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                const authorizeGet = vi.fn(async () => ({ isAllowed: false, message: ':(' }));
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id', { authorizeGet });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'asd' });
-                try {
-                    await dataSet.get(i, 1);
-                    throw Error('Should throw');
-                }
-                catch (error) {
-                    /** */
-                }
-            });
-        });
-        it('should return the entity if authorizeGetEntity returns valid result', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                const authorizeGetEntity = vi.fn(async () => ({ isAllowed: true, message: '' }));
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id', { authorizeGetEntity });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'asd' });
-                const result = await dataSet.get(i, 1);
-                expect(result && result.id).toBe(1);
-            });
-        });
-        it('should throw if authorizeGetEntity returns invalid result', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                const authorizeGetEntity = vi.fn(async () => ({ isAllowed: false, message: ':(' }));
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id', { authorizeGetEntity });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'asd' });
-                try {
-                    await dataSet.get(i, 1);
-                    throw Error('Should throw');
-                }
-                catch (error) {
-                    /** */
-                }
-            });
-        });
-        it('should pass the full entity to authorizeGetEntity even when select is used', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                const authorizeGetEntity = vi.fn(async () => ({ isAllowed: true, message: '' }));
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id', { authorizeGetEntity });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'asd' });
-                const result = await dataSet.get(i, 1, ['value']);
-                expect(authorizeGetEntity).toHaveBeenCalledTimes(1);
-                const calls = authorizeGetEntity.mock.calls;
-                expect(calls[0][0].entity).toEqual({ id: 1, value: 'asd' });
-                expect(result).toEqual({ value: 'asd' });
-                expect(result).not.toHaveProperty('id');
-            });
-        });
-        it('should return undefined when authorizeGetEntity is set and entity does not exist', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                const authorizeGetEntity = vi.fn(async () => ({ isAllowed: true, message: '' }));
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id', { authorizeGetEntity });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                const result = await dataSet.get(i, 999);
-                expect(result).toBeUndefined();
-                expect(authorizeGetEntity).not.toHaveBeenCalled();
-            });
-        });
-    });
-    describe('remove', () => {
-        it('should remove the entity if no settings are provided', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id');
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'asd' });
-                await dataSet.remove(i, 1);
-                const countValue = await dataSet.count(i);
-                expect(countValue).toBe(0);
-            });
-        });
-        it('should remove the entity if authorizeRemove returns valid result', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                const authorizeRemove = vi.fn(async () => ({ isAllowed: true, message: '' }));
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id', { authorizeRemove });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'asd' });
-                await dataSet.remove(i, 1);
-                const count = await dataSet.count(i);
-                expect(count).toBe(0);
-            });
-        });
-        it('should throw if authorizeRemove returns invalid result', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                const authorizeRemove = vi.fn(async () => ({ isAllowed: false, message: ':(' }));
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id', { authorizeRemove });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'asd' });
-                try {
-                    await dataSet.remove(i, 1);
-                    throw Error('Should throw');
-                }
-                catch (error) {
-                    /** */
-                }
-                const count = await dataSet.count(i);
-                expect(count).toBe(1);
-            });
-        });
-        it('should remove the entity if authorizeRemoveEntity returns valid result', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                const authorizeRemoveEntity = vi.fn(async () => ({ isAllowed: true, message: '' }));
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id', { authorizeRemoveEntity });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'asd' });
-                await dataSet.remove(i, 1);
-                const count = await dataSet.count(i);
-                expect(count).toBe(0);
-            });
-        });
-        it('should throw if authorizeRemoveEntity returns invalid result', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                const authorizeRemoveEntity = vi.fn(async () => ({ isAllowed: false, message: ':(' }));
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id', { authorizeRemoveEntity });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'asd' });
-                try {
-                    await dataSet.remove(i, 1);
-                    throw Error('Should throw');
-                }
-                catch (error) {
-                    /** */
-                }
-                const count = await dataSet.count(i);
-                expect(count).toBe(1);
-            });
-        });
-        it('should publish to the onEntityRemoved observable if an entity has been removed', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                expect.assertions(1);
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id');
-                getRepository(i)
-                    .getDataSetFor(TestClass, 'id')
-                    .subscribe('onEntityRemoved', ({ key }) => {
-                    expect(key).toEqual(1);
-                });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'asd' });
-                await dataSet.remove(i, 1);
-            });
-        });
-        it('should remove multiple entities at once', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id');
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'a' }, { id: 2, value: 'b' }, { id: 3, value: 'c' });
-                await dataSet.remove(i, 1, 3);
-                const count = await dataSet.count(i);
-                expect(count).toBe(1);
-                const remaining = await dataSet.get(i, 2);
-                expect(remaining?.value).toBe('b');
-            });
-        });
-        it('should emit onEntityRemoved for each key when removing multiple entities', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                const removedKeys = [];
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id');
-                getRepository(i)
-                    .getDataSetFor(TestClass, 'id')
-                    .subscribe('onEntityRemoved', ({ key }) => {
-                    removedKeys.push(key);
-                });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'a' }, { id: 2, value: 'b' });
-                await dataSet.remove(i, 1, 2);
-                expect(removedKeys).toEqual([1, 2]);
-            });
-        });
-        it('should authorize each entity when removing multiple with authorizeRemoveEntity', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                const authorizeRemoveEntity = vi.fn(async () => ({ isAllowed: true, message: '' }));
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id', { authorizeRemoveEntity });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                await dataSet.add(i, { id: 1, value: 'a' }, { id: 2, value: 'b' });
-                await dataSet.remove(i, 1, 2);
-                expect(authorizeRemoveEntity).toHaveBeenCalledTimes(2);
-                const count = await dataSet.count(i);
-                expect(count).toBe(0);
-            });
-        });
-        it('should not remove any entity if authorizeRemoveEntity fails for one (all-or-nothing)', async () => {
-            await usingAsync(new Injector(), async (i) => {
-                const authorizeRemoveEntity = vi.fn(async ({ entity }) => {
-                    if (entity.id === 2) {
-                        return { isAllowed: false, message: 'forbidden' };
-                    }
-                    return { isAllowed: true };
-                });
-                addStore(i, new InMemoryStore({ model: TestClass, primaryKey: 'id' }));
-                getRepository(i).createDataSet(TestClass, 'id', { authorizeRemoveEntity });
-                const dataSet = getDataSetFor(i, TestClass, 'id');
-                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.toThrow(AuthorizationError);
-                const count = await dataSet.count(i);
-                expect(count).toBe(3);
-            });
-        });
-    });
-});
-//# sourceMappingURL=dataset.spec.js.map