mirror of
https://github.com/expo/entity.git
synced 2026-11-15 17:32:07 -10:00
Compare commits
7
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
7f102ef29d | ||
|
|
0dbf5e98bb | ||
|
|
4347d9d577 | ||
|
|
9a91b19466 | ||
|
|
cb7aaad979 | ||
|
|
9fcfbf746a | ||
|
|
9c44e8e8d4 |
No files matched your search
@@ -14,7 +14,7 @@ jobs:
|
||||
ref: ${{ github.event.pull_request.head.sha }}
|
||||
- uses: actions/setup-node@v1
|
||||
with:
|
||||
node-version: 12.x
|
||||
node-version: 18.x
|
||||
- name: Cache Node.js modules
|
||||
uses: actions/cache@v1
|
||||
with:
|
||||
|
||||
+2
-2
@@ -19,7 +19,6 @@
|
||||
"@expo/entity": "file:packages/entity",
|
||||
"@expo/results": "^1.0.0",
|
||||
"@types/invariant": "^2.2.33",
|
||||
"@types/ioredis": "^4.26.4",
|
||||
"@types/jest": "^26.0.10",
|
||||
"@types/jsbn": "^1.2.29",
|
||||
"@types/lru-cache": "^5.1.1",
|
||||
@@ -31,6 +30,7 @@
|
||||
"eslint": "^7.7.0",
|
||||
"eslint-config-universe": "^7.0.0",
|
||||
"eslint-plugin-tsdoc": "^0.2.11",
|
||||
"ioredis": "^5.0.4",
|
||||
"jest": "^26.6.3",
|
||||
"lerna": "^4.0.0",
|
||||
"lru-cache": "^6.0.0",
|
||||
@@ -40,7 +40,7 @@
|
||||
"ts-jest": "~26.4.4",
|
||||
"ts-mockito": "^2.6.1",
|
||||
"typedoc": "^0.21.9",
|
||||
"typescript": "^4.4.2",
|
||||
"typescript": "^4.6.3",
|
||||
"uuid": "^8.3.0"
|
||||
},
|
||||
"dependencies": {
|
||||
|
||||
@@ -68,7 +68,7 @@ export default class LocalMemoryCacheAdapter<TFields> extends EntityCacheAdapter
|
||||
fieldValue: NonNullable<TFields[N]>
|
||||
): string {
|
||||
const columnName = this.entityConfiguration.entityToDBFieldsKeyMapping.get(fieldName);
|
||||
invariant(columnName, `database field mapping missing for ${fieldName}`);
|
||||
invariant(columnName, `database field mapping missing for ${String(fieldName)}`);
|
||||
const parts = [
|
||||
this.entityConfiguration.tableName,
|
||||
`${this.entityConfiguration.cacheKeyVersion}`,
|
||||
|
||||
+12
-10
@@ -32,9 +32,9 @@ describe(LocalMemoryCacheAdapter, () => {
|
||||
.enforceCreateAsync();
|
||||
|
||||
// loading an entity should put it in cache
|
||||
const entity1 = await LocalMemoryTestEntity.loader(viewerContext).loadByIDAsync(
|
||||
entity1Created.getID()
|
||||
);
|
||||
const entity1 = await LocalMemoryTestEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity1Created.getID());
|
||||
|
||||
const entitySpecificGenericCacher =
|
||||
LocalMemoryCacheAdapterProvider.localMemoryCacheAdapterMap.get(
|
||||
@@ -97,13 +97,15 @@ describe(LocalMemoryCacheAdapter, () => {
|
||||
.enforceCreateAsync();
|
||||
|
||||
// loading an entity should put it in cache
|
||||
await LocalMemoryTestEntity.loader(viewerContext).loadByIDAsync(entity1Created.getID());
|
||||
await LocalMemoryTestEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity1Created.getID());
|
||||
|
||||
// load entity with a different request
|
||||
const viewerContext2 = new TestViewerContext(createLocalMemoryTestEntityCompanionProvider());
|
||||
const entity1WithVc2 = await LocalMemoryTestEntity.loader(viewerContext2).loadByIDAsync(
|
||||
entity1Created.getID()
|
||||
);
|
||||
const entity1WithVc2 = await LocalMemoryTestEntity.loader(viewerContext2)
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity1Created.getID());
|
||||
|
||||
const cacheAdapter = viewerContext.entityCompanionProvider.getCompanionForEntity(
|
||||
LocalMemoryTestEntity,
|
||||
@@ -138,9 +140,9 @@ describe(LocalMemoryCacheAdapter, () => {
|
||||
.enforceCreateAsync();
|
||||
|
||||
// loading an entity will try to put it in cache but it's a noop cache, so it should be a miss
|
||||
const entity1 = await LocalMemoryTestEntity.loader(viewerContext).loadByIDAsync(
|
||||
entity1Created.getID()
|
||||
);
|
||||
const entity1 = await LocalMemoryTestEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity1Created.getID());
|
||||
|
||||
const entitySpecificGenericCacher =
|
||||
LocalMemoryCacheAdapterProvider.localMemoryCacheAdapterMap.get(
|
||||
|
||||
@@ -27,12 +27,11 @@
|
||||
"author": "Expo",
|
||||
"license": "MIT",
|
||||
"peerDependencies": {
|
||||
"@expo/entity": "*"
|
||||
},
|
||||
"dependencies": {
|
||||
"ioredis": "^4.27.3"
|
||||
"@expo/entity": "*",
|
||||
"ioredis": ">=5"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@expo/entity": "^0.25.3"
|
||||
"@expo/entity": "^0.25.3",
|
||||
"ioredis": "^5.0.4"
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
import { EntityCacheAdapter, EntityConfiguration, CacheLoadResult, mapKeys } from '@expo/entity';
|
||||
import invariant from 'invariant';
|
||||
import { Redis } from 'ioredis';
|
||||
import type { Redis } from 'ioredis';
|
||||
|
||||
import GenericRedisCacher from './GenericRedisCacher';
|
||||
|
||||
@@ -113,7 +113,7 @@ export default class RedisCacheAdapter<TFields> extends EntityCacheAdapter<TFiel
|
||||
fieldValue: NonNullable<TFields[N]>
|
||||
): string {
|
||||
const columnName = this.entityConfiguration.entityToDBFieldsKeyMapping.get(fieldName);
|
||||
invariant(columnName, `database field mapping missing for ${fieldName}`);
|
||||
invariant(columnName, `database field mapping missing for ${String(fieldName)}`);
|
||||
return this.context.makeKeyFn(
|
||||
this.context.cacheKeyPrefix,
|
||||
this.entityConfiguration.tableName,
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import { DateField } from '@expo/entity';
|
||||
import { DateField, LowercaseStringField } from '@expo/entity';
|
||||
|
||||
export const redisTransformerMap = new Map([
|
||||
[
|
||||
@@ -22,4 +22,10 @@ export const redisTransformerMap = new Map([
|
||||
read: (val: any) => (val ? new Date(val) : val),
|
||||
},
|
||||
],
|
||||
[
|
||||
LowercaseStringField.name,
|
||||
{
|
||||
write: (val: any) => (typeof val === 'string' ? val.toLowerCase() : val),
|
||||
},
|
||||
],
|
||||
]);
|
||||
+13
-10
@@ -52,9 +52,9 @@ describe(RedisCacheAdapter, () => {
|
||||
.enforceCreateAsync();
|
||||
|
||||
// loading an entity should put it in cache
|
||||
const entity1 = await RedisTestEntity.loader(viewerContext).loadByIDAsync(
|
||||
entity1Created.getID()
|
||||
);
|
||||
const entity1 = await RedisTestEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity1Created.getID());
|
||||
|
||||
const cachedJSON = await redisCacheAdapterContext.redisClient.get(
|
||||
cacheKeyMaker('id', entity1.getID())
|
||||
@@ -102,14 +102,16 @@ describe(RedisCacheAdapter, () => {
|
||||
);
|
||||
expect(entity1.getField('dateField')).toEqual(date);
|
||||
|
||||
const entity2 = await RedisTestEntity.loader(viewerContext).loadByIDAsync(entity1.getID());
|
||||
const entity2 = await RedisTestEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity1.getID());
|
||||
expect(entity2.getField('dateField')).toEqual(date);
|
||||
|
||||
// simulate new request
|
||||
const vc2 = new TestViewerContext(
|
||||
createRedisIntegrationTestEntityCompanionProvider(redisCacheAdapterContext)
|
||||
);
|
||||
const entity3 = await RedisTestEntity.loader(vc2).loadByIDAsync(entity1.getID());
|
||||
const entity3 = await RedisTestEntity.loader(vc2).enforcing().loadByIDAsync(entity1.getID());
|
||||
expect(entity3.getField('dateField')).toEqual(date);
|
||||
});
|
||||
|
||||
@@ -120,17 +122,18 @@ describe(RedisCacheAdapter, () => {
|
||||
const entity1 = await enforceAsyncResult(
|
||||
RedisTestEntity.creator(viewerContext).setField('name', '').createAsync()
|
||||
);
|
||||
const entity2 = await RedisTestEntity.loader(viewerContext).loadByFieldEqualingAsync(
|
||||
'name',
|
||||
''
|
||||
);
|
||||
const entity2 = await RedisTestEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', '');
|
||||
expect(entity2?.getID()).toEqual(entity1.getID());
|
||||
|
||||
// simulate new request
|
||||
const vc2 = new TestViewerContext(
|
||||
createRedisIntegrationTestEntityCompanionProvider(redisCacheAdapterContext)
|
||||
);
|
||||
const entity3 = await RedisTestEntity.loader(vc2).loadByFieldEqualingAsync('name', '');
|
||||
const entity3 = await RedisTestEntity.loader(vc2)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', '');
|
||||
expect(entity3?.getID()).toEqual(entity1.getID());
|
||||
});
|
||||
});
|
||||
@@ -7,6 +7,7 @@ import {
|
||||
TableQuerySelectionModifiers,
|
||||
TableFieldSingleValueEqualityCondition,
|
||||
TableFieldMultiValueEqualityCondition,
|
||||
LowercaseStringField,
|
||||
} from '@expo/entity';
|
||||
import { Knex } from 'knex';
|
||||
|
||||
@@ -36,6 +37,12 @@ export default class PostgresEntityDatabaseAdapter<TFields> extends EntityDataba
|
||||
write: (val: any[] | any) => (Array.isArray(val) ? JSON.stringify(val) : val),
|
||||
},
|
||||
],
|
||||
[
|
||||
LowercaseStringField.name,
|
||||
{
|
||||
write: (val: any) => (typeof val === 'string' ? val.toLowerCase() : val),
|
||||
},
|
||||
],
|
||||
]);
|
||||
}
|
||||
|
||||
|
||||
+111
-86
@@ -50,7 +50,9 @@ describe('postgres entity integration', () => {
|
||||
PostgresTestEntity.updater(entity).setField('hasADog', false).updateAsync(),
|
||||
]);
|
||||
|
||||
const loadedEntity = await PostgresTestEntity.loader(vc).loadByIDAsync(entity.getID());
|
||||
const loadedEntity = await PostgresTestEntity.loader(vc)
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity.getID());
|
||||
|
||||
expect(loadedEntity.getField('hasACat')).toBe(true);
|
||||
expect(loadedEntity.getField('hasADog')).toBe(false);
|
||||
@@ -183,22 +185,26 @@ describe('postgres entity integration', () => {
|
||||
.createAsync()
|
||||
);
|
||||
|
||||
const results = await PostgresTestEntity.loader(vc1).loadManyByFieldEqualityConjunctionAsync([
|
||||
{
|
||||
fieldName: 'hasACat',
|
||||
fieldValue: false,
|
||||
},
|
||||
{
|
||||
fieldName: 'hasADog',
|
||||
fieldValue: true,
|
||||
},
|
||||
]);
|
||||
const results = await PostgresTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadManyByFieldEqualityConjunctionAsync([
|
||||
{
|
||||
fieldName: 'hasACat',
|
||||
fieldValue: false,
|
||||
},
|
||||
{
|
||||
fieldName: 'hasADog',
|
||||
fieldValue: true,
|
||||
},
|
||||
]);
|
||||
|
||||
expect(results).toHaveLength(2);
|
||||
|
||||
const results2 = await PostgresTestEntity.loader(vc1).loadManyByFieldEqualityConjunctionAsync(
|
||||
[{ fieldName: 'hasADog', fieldValues: [true, false] }]
|
||||
);
|
||||
const results2 = await PostgresTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadManyByFieldEqualityConjunctionAsync([
|
||||
{ fieldName: 'hasADog', fieldValues: [true, false] },
|
||||
]);
|
||||
expect(results2).toHaveLength(3);
|
||||
});
|
||||
|
||||
@@ -211,9 +217,9 @@ describe('postgres entity integration', () => {
|
||||
|
||||
await enforceAsyncResult(PostgresTestEntity.creator(vc1).setField('name', 'c').createAsync());
|
||||
|
||||
const results = await PostgresTestEntity.loader(vc1).loadManyByFieldEqualityConjunctionAsync(
|
||||
[],
|
||||
{
|
||||
const results = await PostgresTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadManyByFieldEqualityConjunctionAsync([], {
|
||||
limit: 2,
|
||||
offset: 1,
|
||||
orderBy: [
|
||||
@@ -222,8 +228,7 @@ describe('postgres entity integration', () => {
|
||||
order: OrderByOrdering.DESCENDING,
|
||||
},
|
||||
],
|
||||
}
|
||||
);
|
||||
});
|
||||
expect(results).toHaveLength(2);
|
||||
expect(results.map((e) => e.getField('name'))).toEqual(['b', 'a']);
|
||||
});
|
||||
@@ -255,26 +260,28 @@ describe('postgres entity integration', () => {
|
||||
.createAsync()
|
||||
);
|
||||
|
||||
const results = await PostgresTestEntity.loader(vc1).loadManyByFieldEqualityConjunctionAsync([
|
||||
{ fieldName: 'name', fieldValue: null },
|
||||
]);
|
||||
const results = await PostgresTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadManyByFieldEqualityConjunctionAsync([{ fieldName: 'name', fieldValue: null }]);
|
||||
expect(results).toHaveLength(2);
|
||||
expect(results[0]!.getField('name')).toBeNull();
|
||||
|
||||
const results2 = await PostgresTestEntity.loader(vc1).loadManyByFieldEqualityConjunctionAsync(
|
||||
[
|
||||
{ fieldName: 'name', fieldValues: ['a', null] },
|
||||
{ fieldName: 'hasADog', fieldValue: true },
|
||||
],
|
||||
{
|
||||
orderBy: [
|
||||
{
|
||||
fieldName: 'name',
|
||||
order: OrderByOrdering.DESCENDING,
|
||||
},
|
||||
const results2 = await PostgresTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadManyByFieldEqualityConjunctionAsync(
|
||||
[
|
||||
{ fieldName: 'name', fieldValues: ['a', null] },
|
||||
{ fieldName: 'hasADog', fieldValue: true },
|
||||
],
|
||||
}
|
||||
);
|
||||
{
|
||||
orderBy: [
|
||||
{
|
||||
fieldName: 'name',
|
||||
order: OrderByOrdering.DESCENDING,
|
||||
},
|
||||
],
|
||||
}
|
||||
);
|
||||
expect(results2).toHaveLength(2);
|
||||
expect(results2.map((e) => e.getField('name'))).toEqual([null, 'a']);
|
||||
});
|
||||
@@ -291,10 +298,9 @@ describe('postgres entity integration', () => {
|
||||
.createAsync()
|
||||
);
|
||||
|
||||
const results = await PostgresTestEntity.loader(vc1).loadManyByRawWhereClauseAsync(
|
||||
'name = ?',
|
||||
['hello']
|
||||
);
|
||||
const results = await PostgresTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadManyByRawWhereClauseAsync('name = ?', ['hello']);
|
||||
|
||||
expect(results).toHaveLength(1);
|
||||
});
|
||||
@@ -310,9 +316,9 @@ describe('postgres entity integration', () => {
|
||||
);
|
||||
|
||||
await expect(
|
||||
PostgresTestEntity.loader(vc1).loadManyByRawWhereClauseAsync('invalid_column = ?', [
|
||||
'hello',
|
||||
])
|
||||
PostgresTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadManyByRawWhereClauseAsync('invalid_column = ?', ['hello'])
|
||||
).rejects.toThrow();
|
||||
});
|
||||
|
||||
@@ -340,10 +346,9 @@ describe('postgres entity integration', () => {
|
||||
.createAsync()
|
||||
);
|
||||
|
||||
const results = await PostgresTestEntity.loader(vc1).loadManyByRawWhereClauseAsync(
|
||||
'has_a_dog = ?',
|
||||
[true],
|
||||
{
|
||||
const results = await PostgresTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadManyByRawWhereClauseAsync('has_a_dog = ?', [true], {
|
||||
limit: 2,
|
||||
offset: 1,
|
||||
orderBy: [
|
||||
@@ -352,26 +357,25 @@ describe('postgres entity integration', () => {
|
||||
order: OrderByOrdering.ASCENDING,
|
||||
},
|
||||
],
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
expect(results).toHaveLength(2);
|
||||
expect(results.map((e) => e.getField('name'))).toEqual(['b', 'c']);
|
||||
|
||||
const resultsMultipleOrderBy = await PostgresTestEntity.loader(
|
||||
vc1
|
||||
).loadManyByRawWhereClauseAsync('has_a_dog = ?', [true], {
|
||||
orderBy: [
|
||||
{
|
||||
fieldName: 'hasADog',
|
||||
order: OrderByOrdering.ASCENDING,
|
||||
},
|
||||
{
|
||||
fieldName: 'name',
|
||||
order: OrderByOrdering.DESCENDING,
|
||||
},
|
||||
],
|
||||
});
|
||||
const resultsMultipleOrderBy = await PostgresTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadManyByRawWhereClauseAsync('has_a_dog = ?', [true], {
|
||||
orderBy: [
|
||||
{
|
||||
fieldName: 'hasADog',
|
||||
order: OrderByOrdering.ASCENDING,
|
||||
},
|
||||
{
|
||||
fieldName: 'name',
|
||||
order: OrderByOrdering.DESCENDING,
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
expect(resultsMultipleOrderBy).toHaveLength(3);
|
||||
expect(resultsMultipleOrderBy.map((e) => e.getField('name'))).toEqual(['c', 'b', 'a']);
|
||||
@@ -391,7 +395,9 @@ describe('postgres entity integration', () => {
|
||||
.enforceCreateAsync()
|
||||
).rejects.toThrowError('name cannot have value beforeCreate');
|
||||
await expect(
|
||||
PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'beforeCreate')
|
||||
PostgresTriggerTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', 'beforeCreate')
|
||||
).resolves.toBeNull();
|
||||
|
||||
await expect(
|
||||
@@ -400,21 +406,27 @@ describe('postgres entity integration', () => {
|
||||
.enforceCreateAsync()
|
||||
).rejects.toThrowError('name cannot have value afterCreate');
|
||||
await expect(
|
||||
PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'afterCreate')
|
||||
PostgresTriggerTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', 'afterCreate')
|
||||
).resolves.toBeNull();
|
||||
|
||||
await expect(
|
||||
PostgresTriggerTestEntity.creator(vc1).setField('name', 'beforeAll').enforceCreateAsync()
|
||||
).rejects.toThrowError('name cannot have value beforeAll');
|
||||
await expect(
|
||||
PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'beforeAll')
|
||||
PostgresTriggerTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', 'beforeAll')
|
||||
).resolves.toBeNull();
|
||||
|
||||
await expect(
|
||||
PostgresTriggerTestEntity.creator(vc1).setField('name', 'afterAll').enforceCreateAsync()
|
||||
).rejects.toThrowError('name cannot have value afterAll');
|
||||
await expect(
|
||||
PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'afterAll')
|
||||
PostgresTriggerTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', 'afterAll')
|
||||
).resolves.toBeNull();
|
||||
|
||||
await expect(
|
||||
@@ -423,7 +435,9 @@ describe('postgres entity integration', () => {
|
||||
.enforceCreateAsync()
|
||||
).rejects.toThrowError('name cannot have value afterCommit');
|
||||
await expect(
|
||||
PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'afterCommit')
|
||||
PostgresTriggerTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', 'afterCommit')
|
||||
).resolves.not.toBeNull();
|
||||
});
|
||||
});
|
||||
@@ -444,7 +458,9 @@ describe('postgres entity integration', () => {
|
||||
.enforceUpdateAsync()
|
||||
).rejects.toThrowError('name cannot have value beforeUpdate');
|
||||
await expect(
|
||||
PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'beforeUpdate')
|
||||
PostgresTriggerTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', 'beforeUpdate')
|
||||
).resolves.toBeNull();
|
||||
|
||||
await expect(
|
||||
@@ -453,7 +469,9 @@ describe('postgres entity integration', () => {
|
||||
.enforceUpdateAsync()
|
||||
).rejects.toThrowError('name cannot have value afterUpdate');
|
||||
await expect(
|
||||
PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'afterUpdate')
|
||||
PostgresTriggerTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', 'afterUpdate')
|
||||
).resolves.toBeNull();
|
||||
|
||||
await expect(
|
||||
@@ -462,7 +480,9 @@ describe('postgres entity integration', () => {
|
||||
.enforceUpdateAsync()
|
||||
).rejects.toThrowError('name cannot have value beforeAll');
|
||||
await expect(
|
||||
PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'beforeAll')
|
||||
PostgresTriggerTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', 'beforeAll')
|
||||
).resolves.toBeNull();
|
||||
|
||||
await expect(
|
||||
@@ -471,7 +491,9 @@ describe('postgres entity integration', () => {
|
||||
.enforceUpdateAsync()
|
||||
).rejects.toThrowError('name cannot have value afterAll');
|
||||
await expect(
|
||||
PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'afterAll')
|
||||
PostgresTriggerTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', 'afterAll')
|
||||
).resolves.toBeNull();
|
||||
|
||||
await expect(
|
||||
@@ -480,7 +502,9 @@ describe('postgres entity integration', () => {
|
||||
.enforceUpdateAsync()
|
||||
).rejects.toThrowError('name cannot have value afterCommit');
|
||||
await expect(
|
||||
PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'afterCommit')
|
||||
PostgresTriggerTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', 'afterCommit')
|
||||
).resolves.not.toBeNull();
|
||||
});
|
||||
});
|
||||
@@ -498,7 +522,9 @@ describe('postgres entity integration', () => {
|
||||
PostgresTriggerTestEntity.enforceDeleteAsync(entityBeforeDelete)
|
||||
).rejects.toThrowError('name cannot have value beforeDelete');
|
||||
await expect(
|
||||
PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'beforeDelete')
|
||||
PostgresTriggerTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', 'beforeDelete')
|
||||
).resolves.not.toBeNull();
|
||||
|
||||
const entityAfterDelete = await PostgresTriggerTestEntity.creator(vc1)
|
||||
@@ -508,7 +534,9 @@ describe('postgres entity integration', () => {
|
||||
PostgresTriggerTestEntity.enforceDeleteAsync(entityAfterDelete)
|
||||
).rejects.toThrowError('name cannot have value afterDelete');
|
||||
await expect(
|
||||
PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'afterDelete')
|
||||
PostgresTriggerTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', 'afterDelete')
|
||||
).resolves.not.toBeNull();
|
||||
});
|
||||
});
|
||||
@@ -525,10 +553,9 @@ describe('postgres entity integration', () => {
|
||||
.enforceCreateAsync()
|
||||
).rejects.toThrowError('name cannot have value beforeCreateAndBeforeUpdate');
|
||||
await expect(
|
||||
PostgresValidatorTestEntity.loader(vc1).loadByFieldEqualingAsync(
|
||||
'name',
|
||||
'beforeCreateAndBeforeUpdate'
|
||||
)
|
||||
PostgresValidatorTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', 'beforeCreateAndBeforeUpdate')
|
||||
).resolves.toBeNull();
|
||||
});
|
||||
});
|
||||
@@ -548,10 +575,9 @@ describe('postgres entity integration', () => {
|
||||
.enforceUpdateAsync()
|
||||
).rejects.toThrowError('name cannot have value beforeCreateAndBeforeUpdate');
|
||||
await expect(
|
||||
PostgresValidatorTestEntity.loader(vc1).loadByFieldEqualingAsync(
|
||||
'name',
|
||||
'beforeCreateAndBeforeUpdate'
|
||||
)
|
||||
PostgresValidatorTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', 'beforeCreateAndBeforeUpdate')
|
||||
).resolves.toBeNull();
|
||||
});
|
||||
});
|
||||
@@ -566,10 +592,9 @@ describe('postgres entity integration', () => {
|
||||
.enforceCreateAsync();
|
||||
await PostgresValidatorTestEntity.enforceDeleteAsync(entityToDelete);
|
||||
await expect(
|
||||
PostgresValidatorTestEntity.loader(vc1).loadByFieldEqualingAsync(
|
||||
'name',
|
||||
'shouldBeDeleted'
|
||||
)
|
||||
PostgresValidatorTestEntity.loader(vc1)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('name', 'shouldBeDeleted')
|
||||
).resolves.toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
@@ -60,7 +60,7 @@ describe('postgres errors', () => {
|
||||
const vc2 = new ViewerContext(
|
||||
createKnexIntegrationTestEntityCompanionProvider(shortTimeoutKnexInstance)
|
||||
);
|
||||
await expect(ErrorsTestEntity.loader(vc2).loadByIDAsync(1)).rejects.toThrow(
|
||||
await expect(ErrorsTestEntity.loader(vc2).enforcing().loadByIDAsync(1)).rejects.toThrow(
|
||||
EntityDatabaseAdapterTransientError
|
||||
);
|
||||
await shortTimeoutKnexInstance.destroy();
|
||||
|
||||
@@ -19,10 +19,9 @@ router.get('/', async (ctx: ExampleContext) => {
|
||||
const viewerContext = ctx.state.viewerContext;
|
||||
let notes: readonly NoteEntity[] = [];
|
||||
if (viewerContext.isUserViewerContext()) {
|
||||
notes = await NoteEntity.loader(viewerContext).loadManyByFieldEqualingAsync(
|
||||
'userID',
|
||||
viewerContext.userID
|
||||
);
|
||||
notes = await NoteEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadManyByFieldEqualingAsync('userID', viewerContext.userID);
|
||||
}
|
||||
ctx.body = {
|
||||
notes: notes.map((note) => note.getAllFields()),
|
||||
@@ -31,7 +30,7 @@ router.get('/', async (ctx: ExampleContext) => {
|
||||
|
||||
router.get('/:id', async (ctx: ExampleContext) => {
|
||||
const viewerContext = ctx.state.viewerContext;
|
||||
const noteResult = await NoteEntity.loader(viewerContext).loadByIDAsync(ctx.params.id);
|
||||
const noteResult = await NoteEntity.loader(viewerContext).loadByIDAsync(ctx.params['id']!);
|
||||
if (!noteResult.ok) {
|
||||
ctx.throw(403, noteResult.reason);
|
||||
}
|
||||
@@ -70,7 +69,7 @@ router.put('/:id', async (ctx: ExampleContext) => {
|
||||
const viewerContext = ctx.state.viewerContext;
|
||||
const { title, body } = ctx.request.body;
|
||||
|
||||
const noteLoadResult = await NoteEntity.loader(viewerContext).loadByIDAsync(ctx.params.id);
|
||||
const noteLoadResult = await NoteEntity.loader(viewerContext).loadByIDAsync(ctx.params['id']!);
|
||||
if (!noteLoadResult.ok) {
|
||||
ctx.throw(403, noteLoadResult.reason);
|
||||
}
|
||||
@@ -91,7 +90,7 @@ router.put('/:id', async (ctx: ExampleContext) => {
|
||||
router.delete('/:id', async (ctx: ExampleContext) => {
|
||||
const viewerContext = ctx.state.viewerContext;
|
||||
|
||||
const noteLoadResult = await NoteEntity.loader(viewerContext).loadByIDAsync(ctx.params.id);
|
||||
const noteLoadResult = await NoteEntity.loader(viewerContext).loadByIDAsync(ctx.params['id']!);
|
||||
if (!noteLoadResult.ok) {
|
||||
ctx.throw(403, noteLoadResult.reason);
|
||||
}
|
||||
|
||||
@@ -46,14 +46,16 @@ export const resolvers: IResolvers<any, GraphqlContext> = {
|
||||
return viewerContext.userID;
|
||||
},
|
||||
async noteByID(_root, args, { viewerContext }) {
|
||||
return await NoteEntity.loader(viewerContext).loadByIDAsync(args.id);
|
||||
return await NoteEntity.loader(viewerContext).enforcing().loadByIDAsync(args.id);
|
||||
},
|
||||
} as IResolverObject<any, GraphqlContext>,
|
||||
|
||||
User: {
|
||||
id: (root) => root,
|
||||
async notes(root, _args, { viewerContext }) {
|
||||
return await NoteEntity.loader(viewerContext).loadManyByFieldEqualingAsync('userID', root);
|
||||
return await NoteEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadManyByFieldEqualingAsync('userID', root);
|
||||
},
|
||||
} as IResolverObject<string, GraphqlContext>,
|
||||
|
||||
@@ -77,14 +79,18 @@ export const resolvers: IResolvers<any, GraphqlContext> = {
|
||||
.enforceCreateAsync();
|
||||
},
|
||||
async updateNote(_root, args, { viewerContext }) {
|
||||
const existingNote = await NoteEntity.loader(viewerContext).loadByIDAsync(args.id);
|
||||
const existingNote = await NoteEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByIDAsync(args.id);
|
||||
return await NoteEntity.updater(existingNote)
|
||||
.setField('title', args.note.title)
|
||||
.setField('body', args.note.body)
|
||||
.enforceUpdateAsync();
|
||||
},
|
||||
async deleteNote(_root, args, { viewerContext }) {
|
||||
const existingNote = await NoteEntity.loader(viewerContext).loadByIDAsync(args.id);
|
||||
const existingNote = await NoteEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByIDAsync(args.id);
|
||||
await NoteEntity.enforceDeleteAsync(existingNote);
|
||||
return existingNote;
|
||||
},
|
||||
|
||||
+11
-8
@@ -153,8 +153,10 @@ describe('Entity cache inconsistency', () => {
|
||||
.enforceCreateAsync();
|
||||
|
||||
// put entities in cache and dataloader
|
||||
await TestEntity.loader(viewerContext).loadByIDAsync(entity1.getID());
|
||||
await TestEntity.loader(viewerContext).loadByFieldEqualingAsync('other_string', 'hello');
|
||||
await TestEntity.loader(viewerContext).enforcing().loadByIDAsync(entity1.getID());
|
||||
await TestEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('other_string', 'hello');
|
||||
|
||||
let openBarrier1: () => void;
|
||||
const barrier1 = new Promise<void>((resolve) => {
|
||||
@@ -177,7 +179,7 @@ describe('Entity cache inconsistency', () => {
|
||||
const viewerContextInternal = new ViewerContext(
|
||||
createFullIntegrationTestEntityCompanionProvider(knexInstance, redisCacheAdapterContext)
|
||||
);
|
||||
await TestEntity.loader(viewerContextInternal).loadByIDAsync(entity1.getID());
|
||||
await TestEntity.loader(viewerContextInternal).enforcing().loadByIDAsync(entity1.getID());
|
||||
|
||||
openBarrier2!();
|
||||
})(),
|
||||
@@ -201,11 +203,12 @@ describe('Entity cache inconsistency', () => {
|
||||
createFullIntegrationTestEntityCompanionProvider(knexInstance, redisCacheAdapterContext)
|
||||
);
|
||||
|
||||
const loadedById = await TestEntity.loader(viewerContextLast).loadByIDAsync(entity1.getID());
|
||||
const loadedByField = await TestEntity.loader(viewerContextLast).loadByFieldEqualingAsync(
|
||||
'other_string',
|
||||
'hello'
|
||||
);
|
||||
const loadedById = await TestEntity.loader(viewerContextLast)
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity1.getID());
|
||||
const loadedByField = await TestEntity.loader(viewerContextLast)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('other_string', 'hello');
|
||||
|
||||
expect(loadedById.getField('third_string')).toEqual('updated');
|
||||
expect(loadedByField!.getField('third_string')).toEqual('updated');
|
||||
|
||||
+6
-4
@@ -87,20 +87,22 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
|
||||
.enforceCreateAsync();
|
||||
|
||||
await expect(
|
||||
ParentEntity.loader(viewerContext).loadByIDNullableAsync(parent.getID())
|
||||
ParentEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parent.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
ChildEntity.loader(viewerContext).loadByFieldEqualingAsync('parent_id', parent.getID())
|
||||
ChildEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('parent_id', parent.getID())
|
||||
).resolves.not.toBeNull();
|
||||
|
||||
await ParentEntity.enforceDeleteAsync(parent);
|
||||
|
||||
await expect(
|
||||
ParentEntity.loader(viewerContext).loadByIDNullableAsync(parent.getID())
|
||||
ParentEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parent.getID())
|
||||
).resolves.toBeNull();
|
||||
|
||||
await expect(
|
||||
ChildEntity.loader(viewerContext).loadByIDNullableAsync(child.getID())
|
||||
ChildEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(child.getID())
|
||||
).resolves.toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
+6
-6
@@ -224,18 +224,18 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
|
||||
|
||||
if (edgeDeletionBehavior === EntityEdgeDeletionBehavior.SET_NULL) {
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(category1.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(category1.getID())
|
||||
).resolves.toBeNull();
|
||||
const otherLoaded = await OtherEntity.loader(viewerContext).loadByIDNullableAsync(
|
||||
other1.getID()
|
||||
);
|
||||
const otherLoaded = await OtherEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByIDNullableAsync(other1.getID());
|
||||
expect(otherLoaded?.getField('parent_category_id')).toBeNull();
|
||||
} else {
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(category1.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(category1.getID())
|
||||
).resolves.toBeNull();
|
||||
await expect(
|
||||
OtherEntity.loader(viewerContext).loadByIDNullableAsync(other1.getID())
|
||||
OtherEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(other1.getID())
|
||||
).resolves.toBeNull();
|
||||
}
|
||||
});
|
||||
|
||||
@@ -1,8 +0,0 @@
|
||||
import { EntityFieldDefinition } from '@expo/entity';
|
||||
import { Address4, Address6 } from 'ip-address';
|
||||
|
||||
export class IPAddressField extends EntityFieldDefinition<string> {
|
||||
protected validateInputValueInternal(value: string): boolean {
|
||||
return Address4.isValid(value) || Address6.isValid(value);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
import { EntityFieldDefinition } from '@expo/entity';
|
||||
import { Address4, Address6 } from 'ip-address';
|
||||
|
||||
export class IPAddressField extends EntityFieldDefinition<string> {
|
||||
protected validateAndTransformInputValueInternal(
|
||||
value: string
|
||||
): { isValid: false } | { isValid: true; transformedValue: string } {
|
||||
return Address4.isValid(value) || Address6.isValid(value)
|
||||
? { isValid: true, transformedValue: value }
|
||||
: { isValid: false };
|
||||
}
|
||||
}
|
||||
+3
-2
@@ -1,6 +1,6 @@
|
||||
import { describeFieldTestCase } from '@expo/entity';
|
||||
|
||||
import { IPAddressField } from '../EntityFields';
|
||||
import { IPAddressField } from '../IPAddressField';
|
||||
|
||||
describeFieldTestCase(
|
||||
new IPAddressField({ columnName: 'wat' }),
|
||||
@@ -12,5 +12,6 @@ describeFieldTestCase(
|
||||
'1:2:3:4:5:6:7:8/64',
|
||||
'fedc:ba98:7654:3210:fedc:ba98:7654:3210',
|
||||
],
|
||||
['', 'abs', '0.0.0.x/0', '123.21.23', '1:2:3:4:5:6', '198.10/8']
|
||||
['', 'abs', '0.0.0.x/0', '123.21.23', '1:2:3:4:5:6', '198.10/8'],
|
||||
[{ in: '192.168.1.1', out: '192.168.1.1' }]
|
||||
);
|
||||
@@ -4,4 +4,4 @@
|
||||
* @module @expo/entity-ip-address-field
|
||||
*/
|
||||
|
||||
export * from './EntityFields';
|
||||
export * from './IPAddressField';
|
||||
+5
-3
@@ -159,9 +159,11 @@ class TestSecondaryLocalMemoryCacheLoader extends EntitySecondaryCacheLoader<
|
||||
}
|
||||
return nullthrows(
|
||||
(
|
||||
await this.entityLoader.loadManyByFieldEqualityConjunctionAsync([
|
||||
{ fieldName: 'id', fieldValue: loadParams.id },
|
||||
])
|
||||
await this.entityLoader
|
||||
.enforcing()
|
||||
.loadManyByFieldEqualityConjunctionAsync([
|
||||
{ fieldName: 'id', fieldValue: loadParams.id },
|
||||
])
|
||||
)[0]
|
||||
).getAllFields();
|
||||
});
|
||||
|
||||
@@ -30,12 +30,10 @@
|
||||
"@expo/entity": "*",
|
||||
"@expo/entity-cache-adapter-redis": "*"
|
||||
},
|
||||
"dependencies": {
|
||||
"ioredis": "^4.17.3"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@expo/entity": "^0.25.3",
|
||||
"@expo/entity-cache-adapter-redis": "^0.25.3",
|
||||
"ioredis": "^5.0.4",
|
||||
"nullthrows": "^1.1.1"
|
||||
}
|
||||
}
|
||||
+5
-3
@@ -40,9 +40,11 @@ class TestSecondaryRedisCacheLoader extends EntitySecondaryCacheLoader<
|
||||
}
|
||||
return nullthrows(
|
||||
(
|
||||
await this.entityLoader.loadManyByFieldEqualityConjunctionAsync([
|
||||
{ fieldName: 'id', fieldValue: loadParams.id },
|
||||
])
|
||||
await this.entityLoader
|
||||
.enforcing()
|
||||
.loadManyByFieldEqualityConjunctionAsync([
|
||||
{ fieldName: 'id', fieldValue: loadParams.id },
|
||||
])
|
||||
)[0]
|
||||
).getAllFields();
|
||||
});
|
||||
|
||||
@@ -0,0 +1,144 @@
|
||||
import { FieldEqualityCondition, QuerySelectionModifiers } from './EntityDatabaseAdapter';
|
||||
import EntityLoader from './EntityLoader';
|
||||
import EntityPrivacyPolicy from './EntityPrivacyPolicy';
|
||||
import ReadonlyEntity from './ReadonlyEntity';
|
||||
import ViewerContext from './ViewerContext';
|
||||
import { mapMap } from './utils/collections/maps';
|
||||
|
||||
/**
|
||||
* Enforcing view on an entity loader. All loads through this loader will throw
|
||||
* if the loads are not successful.
|
||||
*/
|
||||
export default class EnforcingEntityLoader<
|
||||
TFields,
|
||||
TID extends NonNullable<TFields[TSelectedFields]>,
|
||||
TViewerContext extends ViewerContext,
|
||||
TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
|
||||
TPrivacyPolicy extends EntityPrivacyPolicy<
|
||||
TFields,
|
||||
TID,
|
||||
TViewerContext,
|
||||
TEntity,
|
||||
TSelectedFields
|
||||
>,
|
||||
TSelectedFields extends keyof TFields
|
||||
> {
|
||||
constructor(
|
||||
private readonly entityLoader: EntityLoader<
|
||||
TFields,
|
||||
TID,
|
||||
TViewerContext,
|
||||
TEntity,
|
||||
TPrivacyPolicy,
|
||||
TSelectedFields
|
||||
>
|
||||
) {}
|
||||
|
||||
/**
|
||||
* Enforcing version of entity loader method by the same name.
|
||||
* @throws {@link EntityNotAuthorizedError} when viewer is not authorized to view one or more of the returned entities
|
||||
*/
|
||||
async loadManyByFieldEqualingManyAsync<N extends keyof Pick<TFields, TSelectedFields>>(
|
||||
fieldName: N,
|
||||
fieldValues: readonly NonNullable<TFields[N]>[]
|
||||
): Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly TEntity[]>> {
|
||||
const fieldValuesToResults = await this.entityLoader.loadManyByFieldEqualingManyAsync(
|
||||
fieldName,
|
||||
fieldValues
|
||||
);
|
||||
return mapMap(fieldValuesToResults, (results) =>
|
||||
results.map((result) => result.enforceValue())
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Enforcing version of entity loader method by the same name.
|
||||
* @throws {@link EntityNotAuthorizedError} when viewer is not authorized to view one or more of the returned entities
|
||||
*/
|
||||
async loadManyByFieldEqualingAsync<N extends keyof Pick<TFields, TSelectedFields>>(
|
||||
fieldName: N,
|
||||
fieldValue: NonNullable<TFields[N]>
|
||||
): Promise<readonly TEntity[]> {
|
||||
const entityResults = await this.entityLoader.loadManyByFieldEqualingAsync(
|
||||
fieldName,
|
||||
fieldValue
|
||||
);
|
||||
return entityResults.map((result) => result.enforceValue());
|
||||
}
|
||||
|
||||
/**
|
||||
* Enforcing version of entity loader method by the same name.
|
||||
* @throws {@link EntityNotAuthorizedError} when viewer is not authorized to view the returned entity
|
||||
* @throws when multiple entities are found matching the condition
|
||||
*/
|
||||
async loadByFieldEqualingAsync<N extends keyof Pick<TFields, TSelectedFields>>(
|
||||
uniqueFieldName: N,
|
||||
fieldValue: NonNullable<TFields[N]>
|
||||
): Promise<TEntity | null> {
|
||||
const entityResult = await this.entityLoader.loadByFieldEqualingAsync(
|
||||
uniqueFieldName,
|
||||
fieldValue
|
||||
);
|
||||
return entityResult ? entityResult.enforceValue() : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Enforcing version of entity loader method by the same name.
|
||||
* @throws {@link EntityNotAuthorizedError} when viewer is not authorized to view the returned entity
|
||||
*/
|
||||
async loadByIDAsync(id: TID): Promise<TEntity> {
|
||||
const entityResult = await this.entityLoader.loadByIDAsync(id);
|
||||
return entityResult.enforceValue();
|
||||
}
|
||||
|
||||
/**
|
||||
* Enforcing version of entity loader method by the same name.
|
||||
* @throws {@link EntityNotAuthorizedError} when viewer is not authorized to view the returned entity
|
||||
* @throws when multiple entities are found matching the condition
|
||||
*/
|
||||
async loadByIDNullableAsync(id: TID): Promise<TEntity | null> {
|
||||
const entityResult = await this.entityLoader.loadByIDNullableAsync(id);
|
||||
return entityResult ? entityResult.enforceValue() : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Enforcing version of entity loader method by the same name.
|
||||
* @throws {@link EntityNotAuthorizedError} when viewer is not authorized to view one or more of the returned entities
|
||||
*/
|
||||
async loadManyByIDsAsync(ids: readonly TID[]): Promise<ReadonlyMap<TID, TEntity>> {
|
||||
const entityResults = await this.entityLoader.loadManyByIDsAsync(ids);
|
||||
return mapMap(entityResults, (result) => result.enforceValue());
|
||||
}
|
||||
|
||||
/**
|
||||
* Enforcing version of entity loader method by the same name.
|
||||
* @throws {@link EntityNotAuthorizedError} when viewer is not authorized to view one or more of the returned entities
|
||||
*/
|
||||
async loadManyByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(
|
||||
fieldEqualityOperands: FieldEqualityCondition<TFields, N>[],
|
||||
querySelectionModifiers: QuerySelectionModifiers<TFields> = {}
|
||||
): Promise<readonly TEntity[]> {
|
||||
const entityResults = await this.entityLoader.loadManyByFieldEqualityConjunctionAsync(
|
||||
fieldEqualityOperands,
|
||||
querySelectionModifiers
|
||||
);
|
||||
return entityResults.map((result) => result.enforceValue());
|
||||
}
|
||||
|
||||
/**
|
||||
* Enforcing version of entity loader method by the same name.
|
||||
* @throws {@link EntityNotAuthorizedError} when viewer is not authorized to view one or more of the returned entities
|
||||
*/
|
||||
async loadManyByRawWhereClauseAsync(
|
||||
rawWhereClause: string,
|
||||
bindings: any[] | object,
|
||||
querySelectionModifiers: QuerySelectionModifiers<TFields> = {}
|
||||
): Promise<readonly TEntity[]> {
|
||||
const entityResults = await this.entityLoader.loadManyByRawWhereClauseAsync(
|
||||
rawWhereClause,
|
||||
bindings,
|
||||
querySelectionModifiers
|
||||
);
|
||||
return entityResults.map((result) => result.enforceValue());
|
||||
}
|
||||
}
|
||||
@@ -71,9 +71,7 @@ export default class EntityAssociationLoader<
|
||||
.getLoaderFactory()
|
||||
.forLoad(queryContext, { cascadingDeleteCause: null });
|
||||
|
||||
return (await loader.resultLoader.loadByIDAsync(
|
||||
associatedEntityID as unknown as TAssociatedID
|
||||
)) as Result<
|
||||
return (await loader.loadByIDAsync(associatedEntityID as unknown as TAssociatedID)) as Result<
|
||||
null extends TFields[TIdentifyingField] ? TAssociatedEntity | null : TAssociatedEntity
|
||||
>;
|
||||
}
|
||||
@@ -126,7 +124,7 @@ export default class EntityAssociationLoader<
|
||||
.getViewerScopedEntityCompanionForClass(associatedEntityClass)
|
||||
.getLoaderFactory()
|
||||
.forLoad(queryContext, { cascadingDeleteCause: null });
|
||||
return await loader.resultLoader.loadManyByFieldEqualingAsync(
|
||||
return await loader.loadManyByFieldEqualingAsync(
|
||||
associatedEntityFieldContainingThisID,
|
||||
thisID as any
|
||||
);
|
||||
@@ -183,7 +181,7 @@ export default class EntityAssociationLoader<
|
||||
.getViewerScopedEntityCompanionForClass(associatedEntityClass)
|
||||
.getLoaderFactory()
|
||||
.forLoad(queryContext, { cascadingDeleteCause: null });
|
||||
return await loader.resultLoader.loadByFieldEqualingAsync(
|
||||
return await loader.loadByFieldEqualingAsync(
|
||||
associatedEntityLookupByField,
|
||||
associatedFieldValue as any
|
||||
);
|
||||
@@ -241,7 +239,7 @@ export default class EntityAssociationLoader<
|
||||
.getViewerScopedEntityCompanionForClass(associatedEntityClass)
|
||||
.getLoaderFactory()
|
||||
.forLoad(queryContext, { cascadingDeleteCause: null });
|
||||
return await loader.resultLoader.loadManyByFieldEqualingAsync(
|
||||
return await loader.loadManyByFieldEqualingAsync(
|
||||
associatedEntityLookupByField,
|
||||
associatedFieldValue as any
|
||||
);
|
||||
|
||||
@@ -121,12 +121,20 @@ export abstract class EntityFieldDefinition<T> {
|
||||
* - EntityLoader.loadByFieldValue - to ensure the value being loaded by is a valid value
|
||||
* - EntityMutator.setField - to ensure the value being set is a valid value
|
||||
*/
|
||||
public validateInputValue(value: T | null | undefined): boolean {
|
||||
public validateAndTransformInputValue(
|
||||
value: T | null | undefined
|
||||
): { isValid: false } | { isValid: true; transformedValue: T | null | undefined } {
|
||||
if (value === null || value === undefined) {
|
||||
return true;
|
||||
return { isValid: true, transformedValue: value };
|
||||
}
|
||||
|
||||
return this.validateInputValueInternal(value);
|
||||
return this.validateAndTransformInputValueInternal(value);
|
||||
}
|
||||
protected abstract validateAndTransformInputValueInternal(
|
||||
value: T
|
||||
): { isValid: false } | { isValid: true; transformedValue: T };
|
||||
|
||||
public transformInputValue(value: T): T {
|
||||
return value;
|
||||
}
|
||||
protected abstract validateInputValueInternal(value: T): boolean;
|
||||
}
|
||||
@@ -6,8 +6,28 @@ import { EntityFieldDefinition } from './EntityFieldDefinition';
|
||||
* {@link EntityFieldDefinition} for a column with a JS string type.
|
||||
*/
|
||||
export class StringField extends EntityFieldDefinition<string> {
|
||||
protected validateInputValueInternal(value: string): boolean {
|
||||
return typeof value === 'string';
|
||||
protected validateAndTransformInputValueInternal(
|
||||
value: string
|
||||
): { isValid: false } | { isValid: true; transformedValue: string } {
|
||||
return typeof value === 'string'
|
||||
? { isValid: true, transformedValue: value }
|
||||
: { isValid: false };
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@link EntityFieldDefinition} for a column with a JS string type in which
|
||||
* stored values are lower-cased.
|
||||
*/
|
||||
export class LowercaseStringField extends StringField {
|
||||
protected override validateAndTransformInputValueInternal(
|
||||
value: string
|
||||
): { isValid: false } | { isValid: true; transformedValue: string } {
|
||||
const superValue = super.validateAndTransformInputValueInternal(value);
|
||||
if (superValue.isValid) {
|
||||
return { isValid: true, transformedValue: superValue.transformedValue.toLowerCase() };
|
||||
}
|
||||
return { isValid: false };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -16,8 +36,14 @@ export class StringField extends EntityFieldDefinition<string> {
|
||||
* Enforces that the string is a valid UUID.
|
||||
*/
|
||||
export class UUIDField extends StringField {
|
||||
protected override validateInputValueInternal(value: string): boolean {
|
||||
return validateUUID(value);
|
||||
public override validateAndTransformInputValueInternal(
|
||||
value: string
|
||||
): { isValid: false } | { isValid: true; transformedValue: string } {
|
||||
const superValue = super.validateAndTransformInputValueInternal(value);
|
||||
if (superValue.isValid && validateUUID(superValue.transformedValue)) {
|
||||
return { isValid: true, transformedValue: superValue.transformedValue };
|
||||
}
|
||||
return { isValid: false };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -25,8 +51,10 @@ export class UUIDField extends StringField {
|
||||
* {@link EntityFieldDefinition} for a column with a JS Date type.
|
||||
*/
|
||||
export class DateField extends EntityFieldDefinition<Date> {
|
||||
protected validateInputValueInternal(value: Date): boolean {
|
||||
return value instanceof Date;
|
||||
protected validateAndTransformInputValueInternal(
|
||||
value: Date
|
||||
): { isValid: false } | { isValid: true; transformedValue: Date } {
|
||||
return value instanceof Date ? { isValid: true, transformedValue: value } : { isValid: false };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -34,8 +62,12 @@ export class DateField extends EntityFieldDefinition<Date> {
|
||||
* {@link EntityFieldDefinition} for a column with a JS boolean type.
|
||||
*/
|
||||
export class BooleanField extends EntityFieldDefinition<boolean> {
|
||||
protected validateInputValueInternal(value: boolean): boolean {
|
||||
return typeof value === 'boolean';
|
||||
protected validateAndTransformInputValueInternal(
|
||||
value: boolean
|
||||
): { isValid: false } | { isValid: true; transformedValue: boolean } {
|
||||
return typeof value === 'boolean'
|
||||
? { isValid: true, transformedValue: value }
|
||||
: { isValid: false };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -44,8 +76,12 @@ export class BooleanField extends EntityFieldDefinition<boolean> {
|
||||
* Enforces that the number is an integer.
|
||||
*/
|
||||
export class IntField extends EntityFieldDefinition<number> {
|
||||
protected validateInputValueInternal(value: number): boolean {
|
||||
return typeof value === 'number' && Number.isInteger(value);
|
||||
protected validateAndTransformInputValueInternal(
|
||||
value: number
|
||||
): { isValid: false } | { isValid: true; transformedValue: number } {
|
||||
return typeof value === 'number' && Number.isInteger(value)
|
||||
? { isValid: true, transformedValue: value }
|
||||
: { isValid: false };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -54,8 +90,12 @@ export class IntField extends EntityFieldDefinition<number> {
|
||||
* Enforces that the number is a float (which includes integers in JS).
|
||||
*/
|
||||
export class FloatField extends EntityFieldDefinition<number> {
|
||||
protected validateInputValueInternal(value: number): boolean {
|
||||
return typeof value === 'number';
|
||||
protected validateAndTransformInputValueInternal(
|
||||
value: number
|
||||
): { isValid: false } | { isValid: true; transformedValue: number } {
|
||||
return typeof value === 'number'
|
||||
? { isValid: true, transformedValue: value }
|
||||
: { isValid: false };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -64,8 +104,12 @@ export class FloatField extends EntityFieldDefinition<number> {
|
||||
* Enforces that every member of the string array is a string.
|
||||
*/
|
||||
export class StringArrayField extends EntityFieldDefinition<string[]> {
|
||||
protected validateInputValueInternal(value: string[]): boolean {
|
||||
return Array.isArray(value) && value.every((subValue) => typeof subValue === 'string');
|
||||
protected validateAndTransformInputValueInternal(
|
||||
value: string[]
|
||||
): { isValid: false } | { isValid: true; transformedValue: string[] } {
|
||||
return Array.isArray(value) && value.every((subValue) => typeof subValue === 'string')
|
||||
? { isValid: true, transformedValue: value }
|
||||
: { isValid: false };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -73,8 +117,12 @@ export class StringArrayField extends EntityFieldDefinition<string[]> {
|
||||
* {@link EntityFieldDefinition} for a column with a JS JSON object type.
|
||||
*/
|
||||
export class JSONObjectField extends EntityFieldDefinition<object> {
|
||||
protected validateInputValueInternal(value: object): boolean {
|
||||
return typeof value === 'object' && !Array.isArray(value);
|
||||
protected validateAndTransformInputValueInternal(
|
||||
value: object
|
||||
): { isValid: false } | { isValid: true; transformedValue: object } {
|
||||
return typeof value === 'object' && !Array.isArray(value)
|
||||
? { isValid: true, transformedValue: value }
|
||||
: { isValid: false };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -82,8 +130,12 @@ export class JSONObjectField extends EntityFieldDefinition<object> {
|
||||
* {@link EntityFieldDefinition} for a enum column with a JS string or number type.
|
||||
*/
|
||||
export class EnumField extends EntityFieldDefinition<string | number> {
|
||||
protected validateInputValueInternal(value: string | number): boolean {
|
||||
return typeof value === 'number' || typeof value === 'string';
|
||||
protected validateAndTransformInputValueInternal(
|
||||
value: string | number
|
||||
): { isValid: false } | { isValid: true; transformedValue: string | number } {
|
||||
return typeof value === 'number' || typeof value === 'string'
|
||||
? { isValid: true, transformedValue: value }
|
||||
: { isValid: false };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -91,8 +143,10 @@ export class EnumField extends EntityFieldDefinition<string | number> {
|
||||
* {@link EntityFieldDefinition} for a column with a JS JSON array type.
|
||||
*/
|
||||
export class JSONArrayField extends EntityFieldDefinition<any[]> {
|
||||
protected validateInputValueInternal(value: any[]): boolean {
|
||||
return Array.isArray(value);
|
||||
protected validateAndTransformInputValueInternal(
|
||||
value: any[]
|
||||
): { isValid: false } | { isValid: true; transformedValue: any[] } {
|
||||
return Array.isArray(value) ? { isValid: true, transformedValue: value } : { isValid: false };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -101,7 +155,9 @@ export class JSONArrayField extends EntityFieldDefinition<any[]> {
|
||||
* Does not do any validation.
|
||||
*/
|
||||
export class MaybeJSONArrayField extends EntityFieldDefinition<any | any[]> {
|
||||
protected validateInputValueInternal(_value: any): boolean {
|
||||
return true;
|
||||
protected validateAndTransformInputValueInternal(
|
||||
value: any
|
||||
): { isValid: false } | { isValid: true; transformedValue: any } {
|
||||
return { isValid: true, transformedValue: value };
|
||||
}
|
||||
}
|
||||
@@ -1,14 +1,23 @@
|
||||
import { Result, asyncResult, result } from '@expo/results';
|
||||
import invariant from 'invariant';
|
||||
|
||||
import EnforcingEntityLoader from './EnforcingEntityLoader';
|
||||
import { IEntityClass } from './Entity';
|
||||
import EntityConfiguration from './EntityConfiguration';
|
||||
import { FieldEqualityCondition, QuerySelectionModifiers } from './EntityDatabaseAdapter';
|
||||
import {
|
||||
FieldEqualityCondition,
|
||||
QuerySelectionModifiers,
|
||||
isSingleValueFieldEqualityCondition,
|
||||
} from './EntityDatabaseAdapter';
|
||||
import EntityPrivacyPolicy, { EntityPrivacyPolicyEvaluationContext } from './EntityPrivacyPolicy';
|
||||
import { EntityQueryContext } from './EntityQueryContext';
|
||||
import EntityResultLoader from './EntityResultLoader';
|
||||
import ReadonlyEntity from './ReadonlyEntity';
|
||||
import ViewerContext from './ViewerContext';
|
||||
import EntityInvalidFieldValueError from './errors/EntityInvalidFieldValueError';
|
||||
import EntityNotFoundError from './errors/EntityNotFoundError';
|
||||
import EntityDataManager from './internal/EntityDataManager';
|
||||
import IEntityMetricsAdapter from './metrics/IEntityMetricsAdapter';
|
||||
import { mapMap } from './utils/collections/maps';
|
||||
import { mapMap, mapMapAsync } from './utils/collections/maps';
|
||||
|
||||
/**
|
||||
* The primary interface for loading entities. All normal loads are batched,
|
||||
@@ -28,24 +37,12 @@ export default class EntityLoader<
|
||||
>,
|
||||
TSelectedFields extends keyof TFields
|
||||
> {
|
||||
/**
|
||||
* Result-based view on an entity loader. All loads through this loader will wrap their results in Result.
|
||||
*/
|
||||
public readonly resultLoader: EntityResultLoader<
|
||||
TFields,
|
||||
TID,
|
||||
TViewerContext,
|
||||
TEntity,
|
||||
TPrivacyPolicy,
|
||||
TSelectedFields
|
||||
>;
|
||||
|
||||
constructor(
|
||||
viewerContext: TViewerContext,
|
||||
queryContext: EntityQueryContext,
|
||||
privacyPolicyEvaluationContext: EntityPrivacyPolicyEvaluationContext,
|
||||
entityConfiguration: EntityConfiguration<TFields>,
|
||||
entityClass: IEntityClass<
|
||||
private readonly viewerContext: TViewerContext,
|
||||
private readonly queryContext: EntityQueryContext,
|
||||
private readonly privacyPolicyEvaluationContext: EntityPrivacyPolicyEvaluationContext,
|
||||
private readonly entityConfiguration: EntityConfiguration<TFields>,
|
||||
private readonly entityClass: IEntityClass<
|
||||
TFields,
|
||||
TID,
|
||||
TViewerContext,
|
||||
@@ -53,105 +50,138 @@ export default class EntityLoader<
|
||||
TPrivacyPolicy,
|
||||
TSelectedFields
|
||||
>,
|
||||
privacyPolicy: TPrivacyPolicy,
|
||||
private readonly privacyPolicy: TPrivacyPolicy,
|
||||
private readonly dataManager: EntityDataManager<TFields>,
|
||||
protected readonly metricsAdapter: IEntityMetricsAdapter
|
||||
) {
|
||||
this.resultLoader = new EntityResultLoader(
|
||||
viewerContext,
|
||||
queryContext,
|
||||
privacyPolicyEvaluationContext,
|
||||
entityConfiguration,
|
||||
entityClass,
|
||||
privacyPolicy,
|
||||
dataManager,
|
||||
metricsAdapter
|
||||
);
|
||||
) {}
|
||||
|
||||
/**
|
||||
* Enforcing view on this entity loader. All loads through this view are
|
||||
* guaranteed to be the values of successful results (or null for some loader methods),
|
||||
* and will throw otherwise.
|
||||
*/
|
||||
enforcing(): EnforcingEntityLoader<
|
||||
TFields,
|
||||
TID,
|
||||
TViewerContext,
|
||||
TEntity,
|
||||
TPrivacyPolicy,
|
||||
TSelectedFields
|
||||
> {
|
||||
return new EnforcingEntityLoader(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Load many entities where fieldName is one of fieldValues.
|
||||
* @param fieldName - entity field being queried
|
||||
* @param fieldValues - fieldName field values being queried
|
||||
* @returns map from fieldValue to entities that match the query for that fieldValue
|
||||
* @returns map from fieldValue to entity results that match the query for that fieldValue,
|
||||
* where result errors can be UnauthorizedError
|
||||
*/
|
||||
async loadManyByFieldEqualingManyAsync<N extends keyof Pick<TFields, TSelectedFields>>(
|
||||
fieldName: N,
|
||||
fieldValues: readonly NonNullable<TFields[N]>[]
|
||||
): Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly TEntity[]>> {
|
||||
const fieldValuesToResults = await this.resultLoader.loadManyByFieldEqualingManyAsync(
|
||||
): Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Result<TEntity>[]>> {
|
||||
const validatedAndTransformedFieldValues = this.validateAndTransformFieldValues(
|
||||
fieldName,
|
||||
fieldValues
|
||||
);
|
||||
return mapMap(fieldValuesToResults, (results) =>
|
||||
results.map((result) => result.enforceValue())
|
||||
|
||||
const fieldValuesToFieldObjects = await this.dataManager.loadManyByFieldEqualingAsync(
|
||||
this.queryContext,
|
||||
fieldName,
|
||||
validatedAndTransformedFieldValues
|
||||
);
|
||||
|
||||
return await this.constructAndAuthorizeEntitiesAsync(fieldValuesToFieldObjects);
|
||||
}
|
||||
|
||||
/**
|
||||
* Load many entities where fieldName equals fieldValue.
|
||||
* @param fieldName - entity field being queried
|
||||
* @param fieldValue - fieldName field value being queried
|
||||
* @returns array of entities that match the query for fieldValue
|
||||
* @returns array of entity results that match the query for fieldValue, where result error can be UnauthorizedError
|
||||
*/
|
||||
async loadManyByFieldEqualingAsync<N extends keyof Pick<TFields, TSelectedFields>>(
|
||||
fieldName: N,
|
||||
fieldValue: NonNullable<TFields[N]>
|
||||
): Promise<readonly TEntity[]> {
|
||||
const entityResults = await this.resultLoader.loadManyByFieldEqualingAsync(
|
||||
fieldName,
|
||||
fieldValue
|
||||
): Promise<readonly Result<TEntity>[]> {
|
||||
const entityResults = await this.loadManyByFieldEqualingManyAsync(fieldName, [fieldValue]);
|
||||
const entityResultsForFieldValue = entityResults.get(fieldValue);
|
||||
invariant(
|
||||
entityResultsForFieldValue !== undefined,
|
||||
`${fieldValue} should be guaranteed to be present in returned map of entities`
|
||||
);
|
||||
return entityResults.map((result) => result.enforceValue());
|
||||
return entityResultsForFieldValue!;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load an entity where fieldName equals fieldValue, or null if no entity exists.
|
||||
* @param uniqueFieldName - entity field being queried
|
||||
* @param fieldValue - uniqueFieldName field value being queried
|
||||
* @returns entity where uniqueFieldName equals fieldValue, or null if no entity matches the condition.
|
||||
* @returns entity result where uniqueFieldName equals fieldValue, or null if no entity matches the condition.
|
||||
* @throws when multiple entities match the condition
|
||||
*/
|
||||
async loadByFieldEqualingAsync<N extends keyof Pick<TFields, TSelectedFields>>(
|
||||
uniqueFieldName: N,
|
||||
fieldValue: NonNullable<TFields[N]>
|
||||
): Promise<TEntity | null> {
|
||||
const entityResult = await this.resultLoader.loadByFieldEqualingAsync(
|
||||
uniqueFieldName,
|
||||
fieldValue
|
||||
): Promise<Result<TEntity> | null> {
|
||||
const entityResults = await this.loadManyByFieldEqualingAsync(uniqueFieldName, fieldValue);
|
||||
invariant(
|
||||
entityResults.length <= 1,
|
||||
`loadByFieldEqualing: Multiple entities of type ${this.entityClass.name} found for ${String(
|
||||
uniqueFieldName
|
||||
)}=${fieldValue}`
|
||||
);
|
||||
return entityResult ? entityResult.enforceValue() : null;
|
||||
return entityResults[0] ?? null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads an entity by a specified ID.
|
||||
* @param id - ID of the entity
|
||||
* @returns entity for matching ID
|
||||
* @returns entity result for matching ID, where result error can be UnauthorizedError or EntityNotFoundError.
|
||||
*/
|
||||
async loadByIDAsync(id: TID): Promise<TEntity> {
|
||||
const entityResult = await this.resultLoader.loadByIDAsync(id);
|
||||
return entityResult.enforceValue();
|
||||
async loadByIDAsync(id: TID): Promise<Result<TEntity>> {
|
||||
const entityResults = await this.loadManyByIDsAsync([id]);
|
||||
const entityResult = entityResults.get(id);
|
||||
if (entityResult === undefined) {
|
||||
return result(
|
||||
new EntityNotFoundError(this.entityClass, this.entityConfiguration.idField, id)
|
||||
);
|
||||
}
|
||||
return entityResult;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load an entity by a specified ID, or return null if non-existent.
|
||||
* @param id - ID of the entity
|
||||
* @returns entity for matching ID, or null if no entity exists for ID.
|
||||
* @returns entity result for matching ID, or null if no entity exists for ID.
|
||||
*/
|
||||
async loadByIDNullableAsync(id: TID): Promise<TEntity | null> {
|
||||
const entityResult = await this.resultLoader.loadByIDNullableAsync(id);
|
||||
return entityResult ? entityResult.enforceValue() : null;
|
||||
async loadByIDNullableAsync(id: TID): Promise<Result<TEntity> | null> {
|
||||
return await this.loadByFieldEqualingAsync(
|
||||
this.entityConfiguration.idField as TSelectedFields,
|
||||
id
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads many entities for a list of IDs.
|
||||
* @param viewerContext - viewer context of loading user
|
||||
* @param ids - IDs of the entities to load
|
||||
* @returns map from ID to corresponding entity
|
||||
* @returns map from ID to corresponding entity result, where result error can be UnauthorizedError or EntityNotFoundError.
|
||||
*/
|
||||
async loadManyByIDsAsync(ids: readonly TID[]): Promise<ReadonlyMap<TID, TEntity>> {
|
||||
const entityResults = await this.resultLoader.loadManyByIDsAsync(ids);
|
||||
return mapMap(entityResults, (result) => result.enforceValue());
|
||||
async loadManyByIDsAsync(ids: readonly TID[]): Promise<ReadonlyMap<TID, Result<TEntity>>> {
|
||||
const entityResults = (await this.loadManyByFieldEqualingManyAsync(
|
||||
this.entityConfiguration.idField as TSelectedFields,
|
||||
ids
|
||||
)) as ReadonlyMap<TID, readonly Result<TEntity>[]>;
|
||||
return mapMap(entityResults, (entityResultsForId, id) => {
|
||||
const entityResult = entityResultsForId[0];
|
||||
return (
|
||||
entityResult ??
|
||||
result(new EntityNotFoundError(this.entityClass, this.entityConfiguration.idField, id))
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -166,17 +196,54 @@ export default class EntityLoader<
|
||||
*
|
||||
* @param fieldEqualityOperands - list of field equality WHERE clause operand specifications
|
||||
* @param querySelectionModifiers - limit, offset, and orderBy for the query
|
||||
* @returns array of entities that match the query
|
||||
* @returns array of entity results that match the query, where result error can be UnauthorizedError
|
||||
*/
|
||||
async loadManyByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(
|
||||
fieldEqualityOperands: FieldEqualityCondition<TFields, N>[],
|
||||
querySelectionModifiers: QuerySelectionModifiers<TFields> = {}
|
||||
): Promise<readonly TEntity[]> {
|
||||
const entityResults = await this.resultLoader.loadManyByFieldEqualityConjunctionAsync(
|
||||
fieldEqualityOperands,
|
||||
): Promise<readonly Result<TEntity>[]> {
|
||||
const validatedAndTransformedFieldEqualityOperands: FieldEqualityCondition<TFields, N>[] =
|
||||
fieldEqualityOperands.map((fieldEqualityOperand) => {
|
||||
if (isSingleValueFieldEqualityCondition(fieldEqualityOperand)) {
|
||||
return {
|
||||
...fieldEqualityOperand,
|
||||
fieldValue: this.validateAndTransformFieldValues(fieldEqualityOperand.fieldName, [
|
||||
fieldEqualityOperand.fieldValue,
|
||||
])[0]!,
|
||||
};
|
||||
} else {
|
||||
return {
|
||||
...fieldEqualityOperand,
|
||||
fieldValues: this.validateAndTransformFieldValues(
|
||||
fieldEqualityOperand.fieldName,
|
||||
fieldEqualityOperand.fieldValues
|
||||
),
|
||||
};
|
||||
}
|
||||
});
|
||||
|
||||
const fieldObjects = await this.dataManager.loadManyByFieldEqualityConjunctionAsync(
|
||||
this.queryContext,
|
||||
validatedAndTransformedFieldEqualityOperands,
|
||||
querySelectionModifiers
|
||||
);
|
||||
return entityResults.map((result) => result.enforceValue());
|
||||
const uncheckedEntityResults = this.tryConstructEntities(fieldObjects);
|
||||
return await Promise.all(
|
||||
uncheckedEntityResults.map(async (uncheckedEntityResult) => {
|
||||
if (!uncheckedEntityResult.ok) {
|
||||
return uncheckedEntityResult;
|
||||
}
|
||||
return await asyncResult(
|
||||
this.privacyPolicy.authorizeReadAsync(
|
||||
this.viewerContext,
|
||||
this.queryContext,
|
||||
this.privacyPolicyEvaluationContext,
|
||||
uncheckedEntityResult.value,
|
||||
this.metricsAdapter
|
||||
)
|
||||
);
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -199,7 +266,7 @@ export default class EntityLoader<
|
||||
* @param rawWhereClause - parameterized SQL WHERE clause with positional binding placeholders or named binding placeholders
|
||||
* @param bindings - array of positional bindings or object of named bindings
|
||||
* @param querySelectionModifiers - limit, offset, and orderBy for the query
|
||||
* @returns array of entities that match the query
|
||||
* @returns array of entity results that match the query, where result error can be UnauthorizedError
|
||||
* @throws Error when rawWhereClause or bindings are invalid
|
||||
*
|
||||
* @deprecated prefer caching loaders
|
||||
@@ -208,13 +275,30 @@ export default class EntityLoader<
|
||||
rawWhereClause: string,
|
||||
bindings: any[] | object,
|
||||
querySelectionModifiers: QuerySelectionModifiers<TFields> = {}
|
||||
): Promise<readonly TEntity[]> {
|
||||
const entityResults = await this.resultLoader.loadManyByRawWhereClauseAsync(
|
||||
): Promise<readonly Result<TEntity>[]> {
|
||||
const fieldObjects = await this.dataManager.loadManyByRawWhereClauseAsync(
|
||||
this.queryContext,
|
||||
rawWhereClause,
|
||||
bindings,
|
||||
querySelectionModifiers
|
||||
);
|
||||
return entityResults.map((result) => result.enforceValue());
|
||||
const uncheckedEntityResults = this.tryConstructEntities(fieldObjects);
|
||||
return await Promise.all(
|
||||
uncheckedEntityResults.map(async (uncheckedEntityResult) => {
|
||||
if (!uncheckedEntityResult.ok) {
|
||||
return uncheckedEntityResult;
|
||||
}
|
||||
return await asyncResult(
|
||||
this.privacyPolicy.authorizeReadAsync(
|
||||
this.viewerContext,
|
||||
this.queryContext,
|
||||
this.privacyPolicyEvaluationContext,
|
||||
uncheckedEntityResult.value,
|
||||
this.metricsAdapter
|
||||
)
|
||||
);
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -233,4 +317,65 @@ export default class EntityLoader<
|
||||
async invalidateEntityAsync(entity: TEntity): Promise<void> {
|
||||
await this.invalidateFieldsAsync(entity.getAllDatabaseFields());
|
||||
}
|
||||
|
||||
private tryConstructEntities(fieldsObjects: readonly TFields[]): readonly Result<TEntity>[] {
|
||||
return fieldsObjects.map((fieldsObject) => {
|
||||
try {
|
||||
return result(new this.entityClass(this.viewerContext, fieldsObject));
|
||||
} catch (e) {
|
||||
if (!(e instanceof Error)) {
|
||||
throw e;
|
||||
}
|
||||
return result(e);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct and authorize entities from fields map, returning error results for entities that fail
|
||||
* to construct or fail to authorize.
|
||||
*
|
||||
* @param map - map from an arbitrary key type to an array of entity field objects
|
||||
*/
|
||||
public async constructAndAuthorizeEntitiesAsync<K>(
|
||||
map: ReadonlyMap<K, readonly Readonly<TFields>[]>
|
||||
): Promise<ReadonlyMap<K, readonly Result<TEntity>[]>> {
|
||||
const uncheckedEntityResultsMap = mapMap(map, (fieldObjects) =>
|
||||
this.tryConstructEntities(fieldObjects)
|
||||
);
|
||||
return await mapMapAsync(uncheckedEntityResultsMap, async (uncheckedEntityResults) => {
|
||||
return await Promise.all(
|
||||
uncheckedEntityResults.map(async (uncheckedEntityResult) => {
|
||||
if (!uncheckedEntityResult.ok) {
|
||||
return uncheckedEntityResult;
|
||||
}
|
||||
return await asyncResult(
|
||||
this.privacyPolicy.authorizeReadAsync(
|
||||
this.viewerContext,
|
||||
this.queryContext,
|
||||
this.privacyPolicyEvaluationContext,
|
||||
uncheckedEntityResult.value,
|
||||
this.metricsAdapter
|
||||
)
|
||||
);
|
||||
})
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
private validateAndTransformFieldValues<
|
||||
N extends keyof Pick<TFields, TSelectedFields>,
|
||||
T extends TFields[N]
|
||||
>(fieldName: N, fieldValues: readonly T[]): readonly T[] {
|
||||
const fieldDefinition = this.entityConfiguration.schema.get(fieldName);
|
||||
invariant(fieldDefinition, `must have field definition for field = ${String(fieldName)}`);
|
||||
return fieldValues.map((fieldValue) => {
|
||||
const result = fieldDefinition.validateAndTransformInputValue(fieldValue);
|
||||
if (result.isValid) {
|
||||
return result.transformedValue;
|
||||
} else {
|
||||
throw new EntityInvalidFieldValueError(this.entityClass, fieldName, fieldValue);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -81,16 +81,22 @@ abstract class BaseMutator<
|
||||
protected readonly metricsAdapter: IEntityMetricsAdapter
|
||||
) {}
|
||||
|
||||
protected validateFields(fields: Partial<TFields>): void {
|
||||
protected validateAndTransformFields(fields: Partial<TFields>): Partial<TFields> {
|
||||
const result: Partial<TFields> = {};
|
||||
|
||||
for (const fieldName in fields) {
|
||||
const fieldValue = fields[fieldName];
|
||||
const fieldDefinition = this.entityConfiguration.schema.get(fieldName);
|
||||
invariant(fieldDefinition, `must have field definition for field = ${fieldName}`);
|
||||
const isInputValid = fieldDefinition.validateInputValue(fieldValue);
|
||||
if (!isInputValid) {
|
||||
const validationResult = fieldDefinition.validateAndTransformInputValue(fieldValue);
|
||||
if (validationResult.isValid) {
|
||||
result[fieldName] = validationResult.transformedValue;
|
||||
} else {
|
||||
throw new EntityInvalidFieldValueError(this.entityClass, fieldName, fieldValue);
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected async executeMutationValidatorsAsync(
|
||||
@@ -183,7 +189,7 @@ export class CreateMutator<
|
||||
|
||||
/**
|
||||
* Commit the new entity after authorizing against creation privacy rules. Invalidates all caches for
|
||||
* queries that would return new entity and caches the new entity if not in a transactional query context.
|
||||
* queries that would return new entity.
|
||||
* @returns authorized, cached, newly-created entity result, where result error can be UnauthorizedError
|
||||
*/
|
||||
async createAsync(): Promise<Result<TEntity>> {
|
||||
@@ -210,11 +216,13 @@ export class CreateMutator<
|
||||
private async createInternalAsync(
|
||||
queryContext: EntityTransactionalQueryContext
|
||||
): Promise<Result<TEntity>> {
|
||||
this.validateFields(this.fieldsForEntity);
|
||||
const transformedAndValidatedFieldsForEntity = this.validateAndTransformFields(
|
||||
this.fieldsForEntity
|
||||
);
|
||||
|
||||
const temporaryEntityForPrivacyCheck = new this.entityClass(this.viewerContext, {
|
||||
[this.entityConfiguration.idField]: '00000000-0000-0000-0000-000000000000', // zero UUID
|
||||
...this.fieldsForEntity,
|
||||
...transformedAndValidatedFieldsForEntity,
|
||||
} as unknown as TFields);
|
||||
|
||||
const authorizeCreateResult = await asyncResult(
|
||||
@@ -249,7 +257,10 @@ export class CreateMutator<
|
||||
{ type: EntityMutationType.CREATE }
|
||||
);
|
||||
|
||||
const insertResult = await this.databaseAdapter.insertAsync(queryContext, this.fieldsForEntity);
|
||||
const insertResult = await this.databaseAdapter.insertAsync(
|
||||
queryContext,
|
||||
transformedAndValidatedFieldsForEntity
|
||||
);
|
||||
|
||||
const entityLoader = this.entityLoaderFactory.forLoad(
|
||||
this.viewerContext,
|
||||
@@ -261,7 +272,9 @@ export class CreateMutator<
|
||||
);
|
||||
|
||||
const unauthorizedEntityAfterInsert = new this.entityClass(this.viewerContext, insertResult);
|
||||
const newEntity = await entityLoader.loadByIDAsync(unauthorizedEntityAfterInsert.getID());
|
||||
const newEntity = await entityLoader
|
||||
.enforcing()
|
||||
.loadByIDAsync(unauthorizedEntityAfterInsert.getID());
|
||||
|
||||
await this.executeMutationTriggersAsync(
|
||||
this.mutationTriggers.afterCreate,
|
||||
@@ -380,8 +393,7 @@ export class UpdateMutator<
|
||||
|
||||
/**
|
||||
* Commit the changes to the entity after authorizing against update privacy rules.
|
||||
* Invalidates all caches for pre-update entity and caches the updated entity if not in a
|
||||
* transactional query context.
|
||||
* Invalidates all caches for pre-update entity.
|
||||
* @returns authorized updated entity result, where result error can be UnauthorizedError
|
||||
*/
|
||||
async updateAsync(): Promise<Result<TEntity>> {
|
||||
@@ -408,9 +420,14 @@ export class UpdateMutator<
|
||||
private async updateInternalAsync(
|
||||
queryContext: EntityTransactionalQueryContext
|
||||
): Promise<Result<TEntity>> {
|
||||
this.validateFields(this.updatedFields);
|
||||
const transformedAndValidatedFieldsForEntity = this.validateAndTransformFields(
|
||||
this.fieldsForEntity
|
||||
) as TFields;
|
||||
|
||||
const entityAboutToBeUpdated = new this.entityClass(this.viewerContext, this.fieldsForEntity);
|
||||
const entityAboutToBeUpdated = new this.entityClass(
|
||||
this.viewerContext,
|
||||
transformedAndValidatedFieldsForEntity
|
||||
);
|
||||
const authorizeUpdateResult = await asyncResult(
|
||||
this.privacyPolicy.authorizeUpdateAsync(
|
||||
this.viewerContext,
|
||||
@@ -463,11 +480,13 @@ export class UpdateMutator<
|
||||
)
|
||||
);
|
||||
queryContext.appendPostCommitInvalidationCallback(
|
||||
entityLoader.invalidateFieldsAsync.bind(entityLoader, this.fieldsForEntity)
|
||||
entityLoader.invalidateFieldsAsync.bind(entityLoader, transformedAndValidatedFieldsForEntity)
|
||||
);
|
||||
|
||||
const unauthorizedEntityAfterUpdate = new this.entityClass(this.viewerContext, updateResult);
|
||||
const updatedEntity = await entityLoader.loadByIDAsync(unauthorizedEntityAfterUpdate.getID());
|
||||
const updatedEntity = await entityLoader
|
||||
.enforcing()
|
||||
.loadByIDAsync(unauthorizedEntityAfterUpdate.getID());
|
||||
|
||||
await this.executeMutationTriggersAsync(
|
||||
this.mutationTriggers.afterUpdate,
|
||||
@@ -755,7 +774,7 @@ export class DeleteMutator<
|
||||
if (associatedEntityLookupByField) {
|
||||
inboundReferenceEntities = await loaderFactory
|
||||
.forLoad(queryContext, { cascadingDeleteCause: newCascadingDeleteCause })
|
||||
|
||||
.enforcing()
|
||||
.loadManyByFieldEqualingAsync(
|
||||
fieldName,
|
||||
entity.getField(associatedEntityLookupByField as any)
|
||||
@@ -763,7 +782,7 @@ export class DeleteMutator<
|
||||
} else {
|
||||
inboundReferenceEntities = await loaderFactory
|
||||
.forLoad(queryContext, { cascadingDeleteCause: newCascadingDeleteCause })
|
||||
|
||||
.enforcing()
|
||||
.loadManyByFieldEqualingAsync(fieldName, entity.getID());
|
||||
}
|
||||
|
||||
|
||||
@@ -19,9 +19,24 @@ export type EntityPrivacyPolicyEvaluationContext = {
|
||||
cascadingDeleteCause: EntityCascadingDeletionInfo | null;
|
||||
};
|
||||
|
||||
/**
|
||||
* Evaluation mode for a {@link EntityPrivacyPolicy}. Useful when transitioning to
|
||||
* using Entity for privacy.
|
||||
*/
|
||||
export enum EntityPrivacyPolicyEvaluationMode {
|
||||
/**
|
||||
* Enforce this privacy policy. Throw upon denial.
|
||||
*/
|
||||
ENFORCE,
|
||||
|
||||
/**
|
||||
* Do not enforce this privacy policy. Always allow but log when it would have denied.
|
||||
*/
|
||||
DRY_RUN,
|
||||
|
||||
/**
|
||||
* Enforce this privacy policy. Throw and log upon denial.
|
||||
*/
|
||||
ENFORCE_AND_LOG,
|
||||
}
|
||||
|
||||
|
||||
@@ -29,6 +29,12 @@ export abstract class EntityQueryContext {
|
||||
): Promise<T>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Entity framework representation of a non-transactional query execution unit.
|
||||
* When supplied to {@link EntityMutator} and {@link EntityLoader} methods, they will be
|
||||
* run independently of any running transaction (though mutations start their own
|
||||
* independent transactions internally when not being run in a transaction).
|
||||
*/
|
||||
export class EntityNonTransactionalQueryContext extends EntityQueryContext {
|
||||
constructor(
|
||||
queryInterface: any,
|
||||
@@ -48,6 +54,11 @@ export class EntityNonTransactionalQueryContext extends EntityQueryContext {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Entity framework representation of a transactional query execution unit. When supplied
|
||||
* to {@link EntityMutator} and {@link EntityLoader} methods, those methods and their
|
||||
* dependent triggers and validators will run within the transaction.
|
||||
*/
|
||||
export class EntityTransactionalQueryContext extends EntityQueryContext {
|
||||
private readonly postCommitInvalidationCallbacks: PostCommitCallback[] = [];
|
||||
private readonly postCommitCallbacks: PostCommitCallback[] = [];
|
||||
|
||||
@@ -1,326 +0,0 @@
|
||||
import { Result, asyncResult, result } from '@expo/results';
|
||||
import invariant from 'invariant';
|
||||
|
||||
import { IEntityClass } from './Entity';
|
||||
import EntityConfiguration from './EntityConfiguration';
|
||||
import {
|
||||
FieldEqualityCondition,
|
||||
QuerySelectionModifiers,
|
||||
isSingleValueFieldEqualityCondition,
|
||||
} from './EntityDatabaseAdapter';
|
||||
import EntityPrivacyPolicy, { EntityPrivacyPolicyEvaluationContext } from './EntityPrivacyPolicy';
|
||||
import { EntityQueryContext } from './EntityQueryContext';
|
||||
import ReadonlyEntity from './ReadonlyEntity';
|
||||
import ViewerContext from './ViewerContext';
|
||||
import EntityInvalidFieldValueError from './errors/EntityInvalidFieldValueError';
|
||||
import EntityNotFoundError from './errors/EntityNotFoundError';
|
||||
import EntityDataManager from './internal/EntityDataManager';
|
||||
import IEntityMetricsAdapter from './metrics/IEntityMetricsAdapter';
|
||||
import { mapMap, mapMapAsync } from './utils/collections/maps';
|
||||
|
||||
/**
|
||||
* Result-based view on an entity loader. All loads through this loader will wrap their results in Result.
|
||||
*/
|
||||
export default class EntityResultLoader<
|
||||
TFields,
|
||||
TID extends NonNullable<TFields[TSelectedFields]>,
|
||||
TViewerContext extends ViewerContext,
|
||||
TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
|
||||
TPrivacyPolicy extends EntityPrivacyPolicy<
|
||||
TFields,
|
||||
TID,
|
||||
TViewerContext,
|
||||
TEntity,
|
||||
TSelectedFields
|
||||
>,
|
||||
TSelectedFields extends keyof TFields
|
||||
> {
|
||||
constructor(
|
||||
private readonly viewerContext: TViewerContext,
|
||||
private readonly queryContext: EntityQueryContext,
|
||||
private readonly privacyPolicyEvaluationContext: EntityPrivacyPolicyEvaluationContext,
|
||||
private readonly entityConfiguration: EntityConfiguration<TFields>,
|
||||
private readonly entityClass: IEntityClass<
|
||||
TFields,
|
||||
TID,
|
||||
TViewerContext,
|
||||
TEntity,
|
||||
TPrivacyPolicy,
|
||||
TSelectedFields
|
||||
>,
|
||||
private readonly privacyPolicy: TPrivacyPolicy,
|
||||
private readonly dataManager: EntityDataManager<TFields>,
|
||||
protected readonly metricsAdapter: IEntityMetricsAdapter
|
||||
) {}
|
||||
|
||||
/**
|
||||
* Load many entity results where fieldName is one of fieldValues.
|
||||
* @param fieldName - entity field being queried
|
||||
* @param fieldValues - fieldName field values being queried
|
||||
* @returns map from fieldValue to entity results that match the query for that fieldValue,
|
||||
* where result errors can be UnauthorizedError
|
||||
*/
|
||||
async loadManyByFieldEqualingManyAsync<N extends keyof Pick<TFields, TSelectedFields>>(
|
||||
fieldName: N,
|
||||
fieldValues: readonly NonNullable<TFields[N]>[]
|
||||
): Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Result<TEntity>[]>> {
|
||||
this.validateFieldValues(fieldName, fieldValues);
|
||||
|
||||
const fieldValuesToFieldObjects = await this.dataManager.loadManyByFieldEqualingAsync(
|
||||
this.queryContext,
|
||||
fieldName,
|
||||
fieldValues
|
||||
);
|
||||
|
||||
return await this.constructAndAuthorizeEntitiesAsync(fieldValuesToFieldObjects);
|
||||
}
|
||||
|
||||
/**
|
||||
* Load many entity results where fieldName equals fieldValue.
|
||||
* @param fieldName - entity field being queried
|
||||
* @param fieldValue - fieldName field value being queried
|
||||
* @returns array of entity results that match the query for fieldValue, where result error can be UnauthorizedError
|
||||
*/
|
||||
async loadManyByFieldEqualingAsync<N extends keyof Pick<TFields, TSelectedFields>>(
|
||||
fieldName: N,
|
||||
fieldValue: NonNullable<TFields[N]>
|
||||
): Promise<readonly Result<TEntity>[]> {
|
||||
const entityResults = await this.loadManyByFieldEqualingManyAsync(fieldName, [fieldValue]);
|
||||
const entityResultsForFieldValue = entityResults.get(fieldValue);
|
||||
invariant(
|
||||
entityResultsForFieldValue !== undefined,
|
||||
`${fieldValue} should be guaranteed to be present in returned map of entities`
|
||||
);
|
||||
return entityResultsForFieldValue!;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load an entity result where fieldName equals fieldValue, or null if no entity exists.
|
||||
* @param uniqueFieldName - entity field being queried
|
||||
* @param fieldValue - uniqueFieldName field value being queried
|
||||
* @returns entity result where uniqueFieldName equals fieldValue, or null if no entity matches the condition.
|
||||
* @throws when multiple entities match the condition
|
||||
*/
|
||||
async loadByFieldEqualingAsync<N extends keyof Pick<TFields, TSelectedFields>>(
|
||||
uniqueFieldName: N,
|
||||
fieldValue: NonNullable<TFields[N]>
|
||||
): Promise<Result<TEntity> | null> {
|
||||
const entityResults = await this.loadManyByFieldEqualingAsync(uniqueFieldName, fieldValue);
|
||||
invariant(
|
||||
entityResults.length <= 1,
|
||||
`loadByFieldEqualing: Multiple entities of type ${this.entityClass.name} found for ${uniqueFieldName}=${fieldValue}`
|
||||
);
|
||||
return entityResults[0] ?? null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads an entityresult by a specified ID.
|
||||
* @param id - ID of the entity
|
||||
* @returns entity result for matching ID, where result error can be UnauthorizedError or EntityNotFoundError.
|
||||
*/
|
||||
async loadByIDAsync(id: TID): Promise<Result<TEntity>> {
|
||||
const entityResults = await this.loadManyByIDsAsync([id]);
|
||||
const entityResult = entityResults.get(id);
|
||||
if (entityResult === undefined) {
|
||||
return result(
|
||||
new EntityNotFoundError(this.entityClass, this.entityConfiguration.idField, id)
|
||||
);
|
||||
}
|
||||
return entityResult;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load an entity result by a specified ID, or return null if non-existent.
|
||||
* @param id - ID of the entity
|
||||
* @returns entity result for matching ID, or null if no entity exists for ID.
|
||||
*/
|
||||
async loadByIDNullableAsync(id: TID): Promise<Result<TEntity> | null> {
|
||||
return await this.loadByFieldEqualingAsync(
|
||||
this.entityConfiguration.idField as TSelectedFields,
|
||||
id
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads many entity results for a list of IDs.
|
||||
* @param viewerContext - viewer context of loading user
|
||||
* @param ids - IDs of the entities to load
|
||||
* @returns map from ID to corresponding entity result, where result error can be UnauthorizedError or EntityNotFoundError.
|
||||
*/
|
||||
async loadManyByIDsAsync(ids: readonly TID[]): Promise<ReadonlyMap<TID, Result<TEntity>>> {
|
||||
const entityResults = (await this.loadManyByFieldEqualingManyAsync(
|
||||
this.entityConfiguration.idField as TSelectedFields,
|
||||
ids
|
||||
)) as ReadonlyMap<TID, readonly Result<TEntity>[]>;
|
||||
return mapMap(entityResults, (entityResultsForId, id) => {
|
||||
const entityResult = entityResultsForId[0];
|
||||
return (
|
||||
entityResult ??
|
||||
result(new EntityNotFoundError(this.entityClass, this.entityConfiguration.idField, id))
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads many entity results matching the conjunction of WHERE clauses constructed from specified operands.
|
||||
* Entities loaded using this method are not batched or cached.
|
||||
*
|
||||
* @example
|
||||
* fieldEqualityOperands:
|
||||
* `[{fieldName: 'hello', fieldValue: 1}, {fieldName: 'world', fieldValues: [2, 3]}]`
|
||||
* Entities returned:
|
||||
* `WHERE hello = 1 AND world = ANY({2, 3})`
|
||||
*
|
||||
* @param fieldEqualityOperands - list of field equality WHERE clause operand specifications
|
||||
* @param querySelectionModifiers - limit, offset, and orderBy for the query
|
||||
* @returns array of entity results that match the query, where result error can be UnauthorizedError
|
||||
*/
|
||||
async loadManyByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(
|
||||
fieldEqualityOperands: FieldEqualityCondition<TFields, N>[],
|
||||
querySelectionModifiers: QuerySelectionModifiers<TFields> = {}
|
||||
): Promise<readonly Result<TEntity>[]> {
|
||||
for (const fieldEqualityOperand of fieldEqualityOperands) {
|
||||
const fieldValues = isSingleValueFieldEqualityCondition(fieldEqualityOperand)
|
||||
? [fieldEqualityOperand.fieldValue]
|
||||
: fieldEqualityOperand.fieldValues;
|
||||
this.validateFieldValues(fieldEqualityOperand.fieldName, fieldValues);
|
||||
}
|
||||
|
||||
const fieldObjects = await this.dataManager.loadManyByFieldEqualityConjunctionAsync(
|
||||
this.queryContext,
|
||||
fieldEqualityOperands,
|
||||
querySelectionModifiers
|
||||
);
|
||||
const uncheckedEntityResults = this.tryConstructEntities(fieldObjects);
|
||||
return await Promise.all(
|
||||
uncheckedEntityResults.map(async (uncheckedEntityResult) => {
|
||||
if (!uncheckedEntityResult.ok) {
|
||||
return uncheckedEntityResult;
|
||||
}
|
||||
return await asyncResult(
|
||||
this.privacyPolicy.authorizeReadAsync(
|
||||
this.viewerContext,
|
||||
this.queryContext,
|
||||
this.privacyPolicyEvaluationContext,
|
||||
uncheckedEntityResult.value,
|
||||
this.metricsAdapter
|
||||
)
|
||||
);
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads many entity results matching the raw WHERE clause. Corresponds to the knex `whereRaw` argument format.
|
||||
*
|
||||
* @remarks
|
||||
* Important notes:
|
||||
* - Fields in clause are database column names instead of transformed entity field names.
|
||||
* - Entities loaded using this method are not batched or cached.
|
||||
* - Not all database adapters implement the ability to execute this method of fetching entities.
|
||||
*
|
||||
* @example
|
||||
* rawWhereClause: `id = ?`
|
||||
* bindings: `[1]`
|
||||
* Entites returned `WHERE id = 1`
|
||||
*
|
||||
* {@link http://knexjs.org/#Builder-whereRaw}
|
||||
* {@link http://knexjs.org/#Raw-Bindings}
|
||||
*
|
||||
* @param rawWhereClause - parameterized SQL WHERE clause with positional binding placeholders or named binding placeholders
|
||||
* @param bindings - array of positional bindings or object of named bindings
|
||||
* @param querySelectionModifiers - limit, offset, and orderBy for the query
|
||||
* @returns array of entity results that match the query, where result error can be UnauthorizedError
|
||||
* @throws Error when rawWhereClause or bindings are invalid
|
||||
*
|
||||
* @deprecated prefer caching loaders
|
||||
*/
|
||||
async loadManyByRawWhereClauseAsync(
|
||||
rawWhereClause: string,
|
||||
bindings: any[] | object,
|
||||
querySelectionModifiers: QuerySelectionModifiers<TFields> = {}
|
||||
): Promise<readonly Result<TEntity>[]> {
|
||||
const fieldObjects = await this.dataManager.loadManyByRawWhereClauseAsync(
|
||||
this.queryContext,
|
||||
rawWhereClause,
|
||||
bindings,
|
||||
querySelectionModifiers
|
||||
);
|
||||
const uncheckedEntityResults = this.tryConstructEntities(fieldObjects);
|
||||
return await Promise.all(
|
||||
uncheckedEntityResults.map(async (uncheckedEntityResult) => {
|
||||
if (!uncheckedEntityResult.ok) {
|
||||
return uncheckedEntityResult;
|
||||
}
|
||||
return await asyncResult(
|
||||
this.privacyPolicy.authorizeReadAsync(
|
||||
this.viewerContext,
|
||||
this.queryContext,
|
||||
this.privacyPolicyEvaluationContext,
|
||||
uncheckedEntityResult.value,
|
||||
this.metricsAdapter
|
||||
)
|
||||
);
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
private tryConstructEntities(fieldsObjects: readonly TFields[]): readonly Result<TEntity>[] {
|
||||
return fieldsObjects.map((fieldsObject) => {
|
||||
try {
|
||||
return result(new this.entityClass(this.viewerContext, fieldsObject));
|
||||
} catch (e) {
|
||||
if (!(e instanceof Error)) {
|
||||
throw e;
|
||||
}
|
||||
return result(e);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct and authorize entities from fields map, returning error results for entities that fail
|
||||
* to construct or fail to authorize.
|
||||
*
|
||||
* @param map - map from an arbitrary key type to an array of entity field objects
|
||||
*/
|
||||
public async constructAndAuthorizeEntitiesAsync<K>(
|
||||
map: ReadonlyMap<K, readonly Readonly<TFields>[]>
|
||||
): Promise<ReadonlyMap<K, readonly Result<TEntity>[]>> {
|
||||
const uncheckedEntityResultsMap = mapMap(map, (fieldObjects) =>
|
||||
this.tryConstructEntities(fieldObjects)
|
||||
);
|
||||
return await mapMapAsync(uncheckedEntityResultsMap, async (uncheckedEntityResults) => {
|
||||
return await Promise.all(
|
||||
uncheckedEntityResults.map(async (uncheckedEntityResult) => {
|
||||
if (!uncheckedEntityResult.ok) {
|
||||
return uncheckedEntityResult;
|
||||
}
|
||||
return await asyncResult(
|
||||
this.privacyPolicy.authorizeReadAsync(
|
||||
this.viewerContext,
|
||||
this.queryContext,
|
||||
this.privacyPolicyEvaluationContext,
|
||||
uncheckedEntityResult.value,
|
||||
this.metricsAdapter
|
||||
)
|
||||
);
|
||||
})
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
private validateFieldValues<N extends keyof Pick<TFields, TSelectedFields>>(
|
||||
fieldName: N,
|
||||
fieldValues: readonly TFields[N][]
|
||||
): void {
|
||||
const fieldDefinition = this.entityConfiguration.schema.get(fieldName);
|
||||
invariant(fieldDefinition, `must have field definition for field = ${fieldName}`);
|
||||
for (const fieldValue of fieldValues) {
|
||||
const isInputValid = fieldDefinition.validateInputValue(fieldValue);
|
||||
if (!isInputValid) {
|
||||
throw new EntityInvalidFieldValueError(this.entityClass, fieldName, fieldValue);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -95,7 +95,7 @@ class TestLocalCacheAdapter<TFields> extends EntityCacheAdapter<TFields> {
|
||||
fieldValue: NonNullable<TFields[N]>
|
||||
): string {
|
||||
const columnName = this.entityConfiguration.entityToDBFieldsKeyMapping.get(fieldName);
|
||||
invariant(columnName, `database field mapping missing for ${fieldName}`);
|
||||
invariant(columnName, `database field mapping missing for ${String(fieldName)}`);
|
||||
const parts = [
|
||||
this.entityConfiguration.tableName,
|
||||
`${this.entityConfiguration.cacheKeyVersion}`,
|
||||
|
||||
@@ -1,17 +1,15 @@
|
||||
import { result } from '@expo/results';
|
||||
import { mock, instance, when, anything } from 'ts-mockito';
|
||||
|
||||
import EnforcingEntityLoader from '../EnforcingEntityLoader';
|
||||
import EntityLoader from '../EntityLoader';
|
||||
import EnforcingEntityLoader from '../EntityResultLoader';
|
||||
|
||||
describe(EnforcingEntityLoader, () => {
|
||||
describe('loadManyByFieldEqualingManyAsync', () => {
|
||||
it('throws when result is unsuccessful', async () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const rejection = new Error();
|
||||
when(
|
||||
entityLoaderMock.resultLoader.loadManyByFieldEqualingManyAsync(anything(), anything())
|
||||
).thenResolve(
|
||||
when(entityLoaderMock.loadManyByFieldEqualingManyAsync(anything(), anything())).thenResolve(
|
||||
new Map(
|
||||
Object.entries({
|
||||
hello: [result(rejection)],
|
||||
@@ -28,9 +26,7 @@ describe(EnforcingEntityLoader, () => {
|
||||
it('returns value when result is successful', async () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const resolved = {};
|
||||
when(
|
||||
entityLoaderMock.resultLoader.loadManyByFieldEqualingManyAsync(anything(), anything())
|
||||
).thenResolve(
|
||||
when(entityLoaderMock.loadManyByFieldEqualingManyAsync(anything(), anything())).thenResolve(
|
||||
new Map(
|
||||
Object.entries({
|
||||
hello: [result(resolved)],
|
||||
@@ -55,9 +51,9 @@ describe(EnforcingEntityLoader, () => {
|
||||
it('throws when result is unsuccessful', async () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const rejection = new Error();
|
||||
when(
|
||||
entityLoaderMock.resultLoader.loadManyByFieldEqualingAsync(anything(), anything())
|
||||
).thenResolve([result(rejection)]);
|
||||
when(entityLoaderMock.loadManyByFieldEqualingAsync(anything(), anything())).thenResolve([
|
||||
result(rejection),
|
||||
]);
|
||||
const entityLoader = instance(entityLoaderMock);
|
||||
const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
|
||||
await expect(
|
||||
@@ -68,9 +64,9 @@ describe(EnforcingEntityLoader, () => {
|
||||
it('returns value when result is successful', async () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const resolved = {};
|
||||
when(
|
||||
entityLoaderMock.resultLoader.loadManyByFieldEqualingAsync(anything(), anything())
|
||||
).thenResolve([result(resolved)]);
|
||||
when(entityLoaderMock.loadManyByFieldEqualingAsync(anything(), anything())).thenResolve([
|
||||
result(resolved),
|
||||
]);
|
||||
const entityLoader = instance(entityLoaderMock);
|
||||
const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
|
||||
await expect(
|
||||
@@ -83,9 +79,9 @@ describe(EnforcingEntityLoader, () => {
|
||||
it('throws when result is unsuccessful', async () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const rejection = new Error();
|
||||
when(
|
||||
entityLoaderMock.resultLoader.loadByFieldEqualingAsync(anything(), anything())
|
||||
).thenResolve(result(rejection));
|
||||
when(entityLoaderMock.loadByFieldEqualingAsync(anything(), anything())).thenResolve(
|
||||
result(rejection)
|
||||
);
|
||||
const entityLoader = instance(entityLoaderMock);
|
||||
const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
|
||||
await expect(
|
||||
@@ -96,9 +92,9 @@ describe(EnforcingEntityLoader, () => {
|
||||
it('returns value when result is successful', async () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const resolved = {};
|
||||
when(
|
||||
entityLoaderMock.resultLoader.loadByFieldEqualingAsync(anything(), anything())
|
||||
).thenResolve(result(resolved));
|
||||
when(entityLoaderMock.loadByFieldEqualingAsync(anything(), anything())).thenResolve(
|
||||
result(resolved)
|
||||
);
|
||||
const entityLoader = instance(entityLoaderMock);
|
||||
const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
|
||||
await expect(
|
||||
@@ -109,9 +105,9 @@ describe(EnforcingEntityLoader, () => {
|
||||
it('returns null when result is successful and no entity is found', async () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const resolved = null;
|
||||
when(
|
||||
entityLoaderMock.resultLoader.loadByFieldEqualingAsync(anything(), anything())
|
||||
).thenResolve(result(resolved));
|
||||
when(entityLoaderMock.loadByFieldEqualingAsync(anything(), anything())).thenResolve(
|
||||
result(resolved)
|
||||
);
|
||||
const entityLoader = instance(entityLoaderMock);
|
||||
const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
|
||||
await expect(
|
||||
@@ -122,9 +118,9 @@ describe(EnforcingEntityLoader, () => {
|
||||
it('throws when multiple matching entities are found', async () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const multipleEntitiesError = new Error();
|
||||
when(
|
||||
entityLoaderMock.resultLoader.loadByFieldEqualingAsync(anything(), anything())
|
||||
).thenReject(multipleEntitiesError);
|
||||
when(entityLoaderMock.loadByFieldEqualingAsync(anything(), anything())).thenReject(
|
||||
multipleEntitiesError
|
||||
);
|
||||
const entityLoader = instance(entityLoaderMock);
|
||||
const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
|
||||
await expect(
|
||||
@@ -137,7 +133,7 @@ describe(EnforcingEntityLoader, () => {
|
||||
it('throws when result is unsuccessful', async () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const rejection = new Error();
|
||||
when(entityLoaderMock.resultLoader.loadByIDAsync(anything())).thenResolve(result(rejection));
|
||||
when(entityLoaderMock.loadByIDAsync(anything())).thenResolve(result(rejection));
|
||||
const entityLoader = instance(entityLoaderMock);
|
||||
const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
|
||||
await expect(enforcingEntityLoader.loadByIDAsync(anything())).rejects.toThrow(rejection);
|
||||
@@ -146,7 +142,7 @@ describe(EnforcingEntityLoader, () => {
|
||||
it('returns value when result is successful', async () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const resolved = {};
|
||||
when(entityLoaderMock.resultLoader.loadByIDAsync(anything())).thenResolve(result(resolved));
|
||||
when(entityLoaderMock.loadByIDAsync(anything())).thenResolve(result(resolved));
|
||||
const entityLoader = instance(entityLoaderMock);
|
||||
const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
|
||||
await expect(enforcingEntityLoader.loadByIDAsync(anything())).resolves.toEqual(resolved);
|
||||
@@ -157,9 +153,7 @@ describe(EnforcingEntityLoader, () => {
|
||||
it('throws when result is unsuccessful', async () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const rejection = new Error();
|
||||
when(entityLoaderMock.resultLoader.loadByIDNullableAsync(anything())).thenResolve(
|
||||
result(rejection)
|
||||
);
|
||||
when(entityLoaderMock.loadByIDNullableAsync(anything())).thenResolve(result(rejection));
|
||||
const entityLoader = instance(entityLoaderMock);
|
||||
const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
|
||||
await expect(enforcingEntityLoader.loadByIDNullableAsync(anything())).rejects.toThrow(
|
||||
@@ -170,9 +164,7 @@ describe(EnforcingEntityLoader, () => {
|
||||
it('returns value when result is successful', async () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const resolved = {};
|
||||
when(entityLoaderMock.resultLoader.loadByIDNullableAsync(anything())).thenResolve(
|
||||
result(resolved)
|
||||
);
|
||||
when(entityLoaderMock.loadByIDNullableAsync(anything())).thenResolve(result(resolved));
|
||||
const entityLoader = instance(entityLoaderMock);
|
||||
const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
|
||||
await expect(enforcingEntityLoader.loadByIDNullableAsync(anything())).resolves.toEqual(
|
||||
@@ -183,9 +175,7 @@ describe(EnforcingEntityLoader, () => {
|
||||
it('returns null when non-existent object', async () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const resolved = null;
|
||||
when(entityLoaderMock.resultLoader.loadByIDNullableAsync(anything())).thenResolve(
|
||||
result(resolved)
|
||||
);
|
||||
when(entityLoaderMock.loadByIDNullableAsync(anything())).thenResolve(result(resolved));
|
||||
const entityLoader = instance(entityLoaderMock);
|
||||
const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
|
||||
await expect(enforcingEntityLoader.loadByIDNullableAsync(anything())).resolves.toEqual(
|
||||
@@ -198,7 +188,7 @@ describe(EnforcingEntityLoader, () => {
|
||||
it('throws when result is unsuccessful', async () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const rejection = new Error();
|
||||
when(entityLoaderMock.resultLoader.loadManyByIDsAsync(anything())).thenResolve(
|
||||
when(entityLoaderMock.loadManyByIDsAsync(anything())).thenResolve(
|
||||
new Map(
|
||||
Object.entries({
|
||||
hello: result(rejection),
|
||||
@@ -213,7 +203,7 @@ describe(EnforcingEntityLoader, () => {
|
||||
it('returns value when result is successful', async () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const resolved = {};
|
||||
when(entityLoaderMock.resultLoader.loadManyByIDsAsync(anything())).thenResolve(
|
||||
when(entityLoaderMock.loadManyByIDsAsync(anything())).thenResolve(
|
||||
new Map(
|
||||
Object.entries({
|
||||
hello: result(resolved),
|
||||
@@ -237,10 +227,7 @@ describe(EnforcingEntityLoader, () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const rejection = new Error();
|
||||
when(
|
||||
entityLoaderMock.resultLoader.loadManyByFieldEqualityConjunctionAsync(
|
||||
anything(),
|
||||
anything()
|
||||
)
|
||||
entityLoaderMock.loadManyByFieldEqualityConjunctionAsync(anything(), anything())
|
||||
).thenResolve([result(rejection)]);
|
||||
const entityLoader = instance(entityLoaderMock);
|
||||
const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
|
||||
@@ -253,10 +240,7 @@ describe(EnforcingEntityLoader, () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const resolved = {};
|
||||
when(
|
||||
entityLoaderMock.resultLoader.loadManyByFieldEqualityConjunctionAsync(
|
||||
anything(),
|
||||
anything()
|
||||
)
|
||||
entityLoaderMock.loadManyByFieldEqualityConjunctionAsync(anything(), anything())
|
||||
).thenResolve([result(resolved)]);
|
||||
const entityLoader = instance(entityLoaderMock);
|
||||
const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
|
||||
@@ -271,11 +255,7 @@ describe(EnforcingEntityLoader, () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const rejection = new Error();
|
||||
when(
|
||||
entityLoaderMock.resultLoader.loadManyByRawWhereClauseAsync(
|
||||
anything(),
|
||||
anything(),
|
||||
anything()
|
||||
)
|
||||
entityLoaderMock.loadManyByRawWhereClauseAsync(anything(), anything(), anything())
|
||||
).thenResolve([result(rejection)]);
|
||||
const entityLoader = instance(entityLoaderMock);
|
||||
const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
|
||||
@@ -288,11 +268,7 @@ describe(EnforcingEntityLoader, () => {
|
||||
const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
|
||||
const resolved = {};
|
||||
when(
|
||||
entityLoaderMock.resultLoader.loadManyByRawWhereClauseAsync(
|
||||
anything(),
|
||||
anything(),
|
||||
anything()
|
||||
)
|
||||
entityLoaderMock.loadManyByRawWhereClauseAsync(anything(), anything(), anything())
|
||||
).thenResolve([result(resolved)]);
|
||||
const entityLoader = instance(entityLoaderMock);
|
||||
const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
|
||||
@@ -312,7 +288,7 @@ describe(EnforcingEntityLoader, () => {
|
||||
'invalidateFieldsAsync',
|
||||
'invalidateEntityAsync',
|
||||
'tryConstructEntities',
|
||||
'validateFieldValues',
|
||||
'validateAndTransformFieldValues',
|
||||
'constructAndAuthorizeEntitiesAsync',
|
||||
];
|
||||
expect(loaderProperties).toEqual(expect.arrayContaining(knownLoaderOnlyDifferences));
|
||||
|
||||
@@ -129,15 +129,15 @@ it('runs through a common workflow', async () => {
|
||||
|
||||
// check that two people can't read each others data
|
||||
await expect(
|
||||
enforceAsyncResult(BlahEntity.loader(vc1).resultLoader.loadByIDAsync(blahOwner2.getID()))
|
||||
enforceAsyncResult(BlahEntity.loader(vc1).loadByIDAsync(blahOwner2.getID()))
|
||||
).rejects.toBeInstanceOf(EntityNotAuthorizedError);
|
||||
await expect(
|
||||
enforceAsyncResult(BlahEntity.loader(vc2).resultLoader.loadByIDAsync(blahOwner1.getID()))
|
||||
enforceAsyncResult(BlahEntity.loader(vc2).loadByIDAsync(blahOwner1.getID()))
|
||||
).rejects.toBeInstanceOf(EntityNotAuthorizedError);
|
||||
|
||||
// check that all of owner 1's objects can be loaded
|
||||
const results = await enforceResultsAsync(
|
||||
BlahEntity.loader(vc1).resultLoader.loadManyByFieldEqualingAsync('ownerID', vc1.getUserID()!)
|
||||
BlahEntity.loader(vc1).loadManyByFieldEqualingAsync('ownerID', vc1.getUserID()!)
|
||||
);
|
||||
expect(results).toHaveLength(2);
|
||||
|
||||
@@ -149,10 +149,7 @@ it('runs through a common workflow', async () => {
|
||||
).rejects.toBeInstanceOf(EntityNotAuthorizedError);
|
||||
|
||||
// check that empty load many returns nothing
|
||||
const results2 = await BlahEntity.loader(vc1).resultLoader.loadManyByFieldEqualingManyAsync(
|
||||
'ownerID',
|
||||
[]
|
||||
);
|
||||
const results2 = await BlahEntity.loader(vc1).loadManyByFieldEqualingManyAsync('ownerID', []);
|
||||
for (const value in results2.values) {
|
||||
expect(value).toHaveLength(0);
|
||||
}
|
||||
|
||||
@@ -374,13 +374,13 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
|
||||
.enforceCreateAsync();
|
||||
|
||||
await expect(
|
||||
ParentEntity.loader(viewerContext).loadByIDNullableAsync(parent.getID())
|
||||
ParentEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parent.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
ChildEntity.loader(viewerContext).loadByIDNullableAsync(child.getID())
|
||||
ChildEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(child.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
GrandChildEntity.loader(viewerContext).loadByIDNullableAsync(grandchild.getID())
|
||||
GrandChildEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(grandchild.getID())
|
||||
).resolves.not.toBeNull();
|
||||
|
||||
privacyPolicyEvaluationRecords.shouldRecord = true;
|
||||
@@ -388,13 +388,13 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
|
||||
privacyPolicyEvaluationRecords.shouldRecord = false;
|
||||
|
||||
await expect(
|
||||
ParentEntity.loader(viewerContext).loadByIDNullableAsync(parent.getID())
|
||||
ParentEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parent.getID())
|
||||
).resolves.toBeNull();
|
||||
await expect(
|
||||
ChildEntity.loader(viewerContext).loadByIDNullableAsync(child.getID())
|
||||
ChildEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(child.getID())
|
||||
).resolves.toBeNull();
|
||||
await expect(
|
||||
GrandChildEntity.loader(viewerContext).loadByIDNullableAsync(grandchild.getID())
|
||||
GrandChildEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(grandchild.getID())
|
||||
).resolves.toBeNull();
|
||||
|
||||
// two calls for each trigger, one beforeDelete, one afterDelete
|
||||
@@ -488,13 +488,13 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
|
||||
.enforceCreateAsync();
|
||||
|
||||
await expect(
|
||||
ParentEntity.loader(viewerContext).loadByIDNullableAsync(parent.getID())
|
||||
ParentEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parent.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
ChildEntity.loader(viewerContext).loadByIDNullableAsync(child.getID())
|
||||
ChildEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(child.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
GrandChildEntity.loader(viewerContext).loadByIDNullableAsync(grandchild.getID())
|
||||
GrandChildEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(grandchild.getID())
|
||||
).resolves.not.toBeNull();
|
||||
|
||||
privacyPolicyEvaluationRecords.shouldRecord = true;
|
||||
@@ -502,16 +502,16 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
|
||||
privacyPolicyEvaluationRecords.shouldRecord = false;
|
||||
|
||||
await expect(
|
||||
ParentEntity.loader(viewerContext).loadByIDNullableAsync(parent.getID())
|
||||
ParentEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parent.getID())
|
||||
).resolves.toBeNull();
|
||||
|
||||
const loadedChild = await ChildEntity.loader(viewerContext)
|
||||
|
||||
.enforcing()
|
||||
.loadByIDAsync(child.getID());
|
||||
expect(loadedChild.getField('parent_id')).toBeNull();
|
||||
|
||||
const loadedGrandchild = await GrandChildEntity.loader(viewerContext)
|
||||
|
||||
.enforcing()
|
||||
.loadByIDAsync(grandchild.getID());
|
||||
expect(loadedGrandchild.getField('parent_id')).toEqual(loadedChild.getID());
|
||||
|
||||
@@ -595,16 +595,16 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
|
||||
.enforceCreateAsync();
|
||||
|
||||
await expect(
|
||||
ParentEntity.loader(viewerContext).loadByIDNullableAsync(parent.getID())
|
||||
ParentEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parent.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
ChildEntity.loader(viewerContext)
|
||||
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('parent_id', parent.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
GrandChildEntity.loader(viewerContext)
|
||||
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('parent_id', child.getID())
|
||||
).resolves.not.toBeNull();
|
||||
|
||||
@@ -639,13 +639,13 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
|
||||
expect(grandChildCachedAfter.get(child.getID())?.status).toEqual(CacheStatus.MISS);
|
||||
|
||||
await expect(
|
||||
ParentEntity.loader(viewerContext).loadByIDNullableAsync(parent.getID())
|
||||
ParentEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parent.getID())
|
||||
).resolves.toBeNull();
|
||||
await expect(
|
||||
ChildEntity.loader(viewerContext).loadByIDNullableAsync(child.getID())
|
||||
ChildEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(child.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
GrandChildEntity.loader(viewerContext).loadByIDNullableAsync(grandchild.getID())
|
||||
GrandChildEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(grandchild.getID())
|
||||
).resolves.not.toBeNull();
|
||||
|
||||
// two calls for each trigger, one beforeDelete, one afterDelete
|
||||
|
||||
@@ -13,12 +13,15 @@ import {
|
||||
EnumField,
|
||||
JSONArrayField,
|
||||
MaybeJSONArrayField,
|
||||
LowercaseStringField,
|
||||
} from '../EntityFields';
|
||||
import describeFieldTestCase from '../utils/testing/describeFieldTestCase';
|
||||
|
||||
class TestFieldDefinition extends EntityFieldDefinition<string> {
|
||||
protected validateInputValueInternal(value: string): boolean {
|
||||
return value === 'helloworld';
|
||||
protected validateAndTransformInputValueInternal(
|
||||
value: string
|
||||
): { isValid: false } | { isValid: true; transformedValue: string } {
|
||||
return value === 'helloworld' ? { isValid: true, transformedValue: value } : { isValid: false };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -35,49 +38,97 @@ describe(EntityFieldDefinition, () => {
|
||||
|
||||
test('validator returns true when value is null', () => {
|
||||
const fieldDefinition = new TestFieldDefinition({ columnName: 'wat', cache: true });
|
||||
expect(fieldDefinition.validateInputValue(null)).toBe(true);
|
||||
expect(fieldDefinition.validateAndTransformInputValue(null).isValid).toBe(true);
|
||||
});
|
||||
|
||||
test('validator returns true when value is undefined', () => {
|
||||
const fieldDefinition = new TestFieldDefinition({ columnName: 'wat', cache: true });
|
||||
expect(fieldDefinition.validateInputValue(undefined)).toBe(true);
|
||||
expect(fieldDefinition.validateAndTransformInputValue(undefined).isValid).toBe(true);
|
||||
});
|
||||
|
||||
test('validator returns false when value is invalid', () => {
|
||||
const fieldDefinition = new TestFieldDefinition({ columnName: 'wat', cache: true });
|
||||
expect(fieldDefinition.validateInputValue('nothelloworld')).toBe(false);
|
||||
expect(fieldDefinition.validateAndTransformInputValue('nothelloworld').isValid).toBe(false);
|
||||
});
|
||||
|
||||
test('validator returns true when value is valid', () => {
|
||||
const fieldDefinition = new TestFieldDefinition({ columnName: 'wat', cache: true });
|
||||
expect(fieldDefinition.validateInputValue('helloworld')).toBe(true);
|
||||
expect(fieldDefinition.validateAndTransformInputValue('helloworld').isValid).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describeFieldTestCase(new StringField({ columnName: 'wat' }), ['hello', ''], [1, true, {}, [[]]]);
|
||||
describeFieldTestCase(
|
||||
new StringField({ columnName: 'wat' }),
|
||||
['hello', ''],
|
||||
[1, true, {}, [[]]],
|
||||
[{ in: 'hello', out: 'hello' }]
|
||||
);
|
||||
describeFieldTestCase(
|
||||
new LowercaseStringField({ columnName: 'wat' }),
|
||||
['HELLO', 'hello'],
|
||||
[1, true, {}, [[]]],
|
||||
[
|
||||
{ in: 'low', out: 'low' },
|
||||
{ in: 'UP', out: 'up' },
|
||||
]
|
||||
);
|
||||
describeFieldTestCase(
|
||||
new UUIDField({ columnName: 'wat' }),
|
||||
[uuidv1(), uuidv3('wat', uuidv3.DNS), uuidv4(), uuidv5('wat', uuidv5.DNS)],
|
||||
[uuidv4().replace('-', ''), '', 'hello']
|
||||
[uuidv4().replace('-', ''), '', 'hello'],
|
||||
[uuidv4()].map((u) => ({ in: u, out: u }))
|
||||
);
|
||||
describeFieldTestCase(
|
||||
new DateField({ columnName: 'wat' }),
|
||||
[new Date()],
|
||||
[Date.now()],
|
||||
[new Date()].map((u) => ({ in: u, out: u }))
|
||||
);
|
||||
describeFieldTestCase(
|
||||
new BooleanField({ columnName: 'wat' }),
|
||||
[true, false],
|
||||
[0, 1, ''],
|
||||
[{ in: true, out: true }]
|
||||
);
|
||||
describeFieldTestCase(
|
||||
new IntField({ columnName: 'wat' }),
|
||||
[1],
|
||||
['1', 0.5, true],
|
||||
[{ in: 1, out: 1 }]
|
||||
);
|
||||
describeFieldTestCase(
|
||||
new FloatField({ columnName: 'wat' }),
|
||||
[1, 0.5, -0.5],
|
||||
['1'],
|
||||
[{ in: 3.5, out: 3.5 }]
|
||||
);
|
||||
describeFieldTestCase(new DateField({ columnName: 'wat' }), [new Date()], [Date.now()]);
|
||||
describeFieldTestCase(new BooleanField({ columnName: 'wat' }), [true, false], [0, 1, '']);
|
||||
describeFieldTestCase(new IntField({ columnName: 'wat' }), [1], ['1', 0.5, true]);
|
||||
describeFieldTestCase(new FloatField({ columnName: 'wat' }), [1, 0.5, -0.5], ['1']);
|
||||
describeFieldTestCase(
|
||||
new StringArrayField({ columnName: 'wat' }),
|
||||
[[['what']] as any, [[]] as any], // jest test cases need extra wrapping array
|
||||
['hello']
|
||||
['hello'],
|
||||
[{ in: ['hello'], out: ['hello'] }]
|
||||
);
|
||||
describeFieldTestCase(
|
||||
new JSONObjectField({ columnName: 'wat' }),
|
||||
[{}],
|
||||
[true, 'hello'],
|
||||
[{ in: { hello: 1 }, out: { hello: 1 } }]
|
||||
);
|
||||
describeFieldTestCase(
|
||||
new EnumField({ columnName: 'wat' }),
|
||||
['hello', 1],
|
||||
[true],
|
||||
[{ in: 1, out: 1 }]
|
||||
);
|
||||
describeFieldTestCase(new JSONObjectField({ columnName: 'wat' }), [{}], [true, 'hello']);
|
||||
describeFieldTestCase(new EnumField({ columnName: 'wat' }), ['hello', 1], [true]);
|
||||
describeFieldTestCase(
|
||||
new JSONArrayField({ columnName: 'wat' }),
|
||||
[[[1, 2]] as any, [['hello']] as any], // jest test cases need extra wrapping array
|
||||
[1, 'hello']
|
||||
[1, 'hello'],
|
||||
[{ in: [1, 2], out: [1, 2] }]
|
||||
);
|
||||
describeFieldTestCase(
|
||||
new MaybeJSONArrayField({ columnName: 'wat' }),
|
||||
[1, 'hello', [['hello']]], // jest test cases need extra wrapping array
|
||||
[]
|
||||
[],
|
||||
[{ in: 1, out: 1 }]
|
||||
);
|
||||
@@ -165,14 +165,14 @@ describe(EntityLoader, () => {
|
||||
|
||||
let capturedThrownThing1: any;
|
||||
try {
|
||||
await entityLoader.resultLoader.loadByIDAsync(ID_SENTINEL_THROW_LITERAL);
|
||||
await entityLoader.loadByIDAsync(ID_SENTINEL_THROW_LITERAL);
|
||||
} catch (e) {
|
||||
capturedThrownThing1 = e;
|
||||
}
|
||||
expect(capturedThrownThing1).not.toBeInstanceOf(Error);
|
||||
expect(capturedThrownThing1).toEqual('hello');
|
||||
|
||||
const result = await entityLoader.resultLoader.loadByIDAsync(ID_SENTINEL_THROW_ERROR);
|
||||
const result = await entityLoader.loadByIDAsync(ID_SENTINEL_THROW_ERROR);
|
||||
expect(result.ok).toBe(false);
|
||||
expect(result.enforceError().message).toEqual('world');
|
||||
});
|
||||
|
||||
@@ -41,6 +41,7 @@ describe(EntityLoader, () => {
|
||||
testIndexedField: 'h1',
|
||||
intField: 5,
|
||||
stringField: 'huh',
|
||||
lowercasedField: 'lw1',
|
||||
dateField: dateToInsert,
|
||||
nullableField: null,
|
||||
},
|
||||
@@ -49,6 +50,7 @@ describe(EntityLoader, () => {
|
||||
testIndexedField: 'h2',
|
||||
intField: 3,
|
||||
stringField: 'huh',
|
||||
lowercasedField: 'lw2',
|
||||
dateField: dateToInsert,
|
||||
nullableField: null,
|
||||
},
|
||||
@@ -78,39 +80,41 @@ describe(EntityLoader, () => {
|
||||
dataManager,
|
||||
metricsAdapter
|
||||
);
|
||||
const entity = await enforceAsyncResult(entityLoader.resultLoader.loadByIDAsync(id1));
|
||||
const entity = await enforceAsyncResult(entityLoader.loadByIDAsync(id1));
|
||||
expect(entity.getID()).toEqual(id1);
|
||||
expect(entity.getField('dateField')).toEqual(dateToInsert);
|
||||
|
||||
const entities = await enforceResultsAsync(
|
||||
entityLoader.resultLoader.loadManyByFieldEqualingAsync('stringField', 'huh')
|
||||
entityLoader.loadManyByFieldEqualingAsync('stringField', 'huh')
|
||||
);
|
||||
expect(entities.map((m) => m.getID())).toEqual([id1, id2]);
|
||||
|
||||
const entityResultNumber3 = await entityLoader.resultLoader.loadByFieldEqualingAsync('intField', 3);
|
||||
const entitiesLoadedTransformedField = await enforceResultsAsync(
|
||||
entityLoader.loadManyByFieldEqualingAsync('lowercasedField', 'LW1')
|
||||
);
|
||||
expect(entitiesLoadedTransformedField.map((m) => m.getID())).toEqual([id1]);
|
||||
|
||||
const entityResultNumber3 = await entityLoader.loadByFieldEqualingAsync('intField', 3);
|
||||
expect(entityResultNumber3).not.toBeNull();
|
||||
expect(entityResultNumber3!.enforceValue().getID()).toEqual(id2);
|
||||
|
||||
const entityResultNumber4 = await entityLoader.resultLoader.loadByFieldEqualingAsync('intField', 4);
|
||||
const entityResultNumber4 = await entityLoader.loadByFieldEqualingAsync('intField', 4);
|
||||
expect(entityResultNumber4).toBeNull();
|
||||
|
||||
const entityResultDuplicateValues = await entityLoader.loadManyByFieldEqualingManyAsync(
|
||||
'stringField',
|
||||
['huh', 'huh']
|
||||
);
|
||||
const entityResultDuplicateValues = await entityLoader
|
||||
.enforcing()
|
||||
.loadManyByFieldEqualingManyAsync('stringField', ['huh', 'huh']);
|
||||
expect(entityResultDuplicateValues.size).toBe(1);
|
||||
expect(entityResultDuplicateValues.get('huh')?.map((m) => m.getID())).toEqual([id1, id2]);
|
||||
|
||||
await expect(
|
||||
entityLoader.resultLoader.loadByFieldEqualingAsync('stringField', 'huh')
|
||||
).rejects.toThrowError(
|
||||
await expect(entityLoader.loadByFieldEqualingAsync('stringField', 'huh')).rejects.toThrowError(
|
||||
'loadByFieldEqualing: Multiple entities of type TestEntity found for stringField=huh'
|
||||
);
|
||||
|
||||
await expect(entityLoader.resultLoader.loadByIDNullableAsync(uuidv4())).resolves.toBeNull();
|
||||
await expect(entityLoader.resultLoader.loadByIDNullableAsync(id1)).resolves.not.toBeNull();
|
||||
await expect(entityLoader.loadByIDNullableAsync(uuidv4())).resolves.toBeNull();
|
||||
await expect(entityLoader.loadByIDNullableAsync(id1)).resolves.not.toBeNull();
|
||||
|
||||
await expect(entityLoader.resultLoader.loadByIDAsync('not-a-uuid')).rejects.toThrowError(
|
||||
await expect(entityLoader.loadByIDAsync('not-a-uuid')).rejects.toThrowError(
|
||||
'Entity field not valid: TestEntity (customIdField = not-a-uuid)'
|
||||
);
|
||||
});
|
||||
@@ -137,6 +141,7 @@ describe(EntityLoader, () => {
|
||||
{
|
||||
customIdField: id1,
|
||||
stringField: 'huh',
|
||||
lowercasedField: 'lw1',
|
||||
intField: 4,
|
||||
testIndexedField: '4',
|
||||
dateField: new Date(),
|
||||
@@ -145,6 +150,7 @@ describe(EntityLoader, () => {
|
||||
{
|
||||
customIdField: id2,
|
||||
stringField: 'huh',
|
||||
lowercasedField: 'lw2',
|
||||
intField: 4,
|
||||
testIndexedField: '5',
|
||||
dateField: new Date(),
|
||||
@@ -153,6 +159,7 @@ describe(EntityLoader, () => {
|
||||
{
|
||||
customIdField: id3,
|
||||
stringField: 'huh2',
|
||||
lowercasedField: 'lw3',
|
||||
intField: 4,
|
||||
testIndexedField: '6',
|
||||
dateField: new Date(),
|
||||
@@ -184,7 +191,7 @@ describe(EntityLoader, () => {
|
||||
metricsAdapter
|
||||
);
|
||||
const entities = await enforceResultsAsync(
|
||||
entityLoader.resultLoader.loadManyByFieldEqualityConjunctionAsync([
|
||||
entityLoader.loadManyByFieldEqualityConjunctionAsync([
|
||||
{
|
||||
fieldName: 'stringField',
|
||||
fieldValue: 'huh',
|
||||
@@ -207,7 +214,7 @@ describe(EntityLoader, () => {
|
||||
).twice();
|
||||
|
||||
await expect(
|
||||
entityLoader.resultLoader.loadManyByFieldEqualityConjunctionAsync([
|
||||
entityLoader.loadManyByFieldEqualityConjunctionAsync([
|
||||
{ fieldName: 'customIdField', fieldValue: 'not-a-uuid' },
|
||||
])
|
||||
).rejects.toThrowError('Entity field not valid: TestEntity (customIdField = not-a-uuid)');
|
||||
@@ -234,6 +241,7 @@ describe(EntityLoader, () => {
|
||||
{
|
||||
customIdField: id1,
|
||||
stringField: 'huh',
|
||||
lowercasedField: 'lw1',
|
||||
testIndexedField: '1',
|
||||
intField: 3,
|
||||
dateField: new Date(),
|
||||
@@ -264,7 +272,7 @@ describe(EntityLoader, () => {
|
||||
dataManager,
|
||||
metricsAdapter
|
||||
);
|
||||
const entity = await enforceAsyncResult(entityLoader.resultLoader.loadByIDAsync(id1));
|
||||
const entity = await enforceAsyncResult(entityLoader.loadByIDAsync(id1));
|
||||
verify(
|
||||
spiedPrivacyPolicy.authorizeReadAsync(
|
||||
viewerContext,
|
||||
@@ -398,7 +406,7 @@ describe(EntityLoader, () => {
|
||||
metricsAdapter
|
||||
);
|
||||
|
||||
const entityResult = await entityLoader.resultLoader.loadByIDAsync(id1);
|
||||
const entityResult = await entityLoader.loadByIDAsync(id1);
|
||||
expect(entityResult.ok).toBe(false);
|
||||
expect(entityResult.reason).toEqual(rejectionError);
|
||||
expect(entityResult.value).toBe(undefined);
|
||||
@@ -433,21 +441,21 @@ describe(EntityLoader, () => {
|
||||
|
||||
const loadByValue = uuidv4();
|
||||
|
||||
await expect(entityLoader.resultLoader.loadByIDAsync(loadByValue)).rejects.toEqual(error);
|
||||
await expect(entityLoader.loadByIDAsync(loadByValue)).rejects.toEqual(error);
|
||||
await expect(entityLoader.resultLoader.loadManyByIDsAsync([loadByValue])).rejects.toEqual(error);
|
||||
await expect(entityLoader.resultLoader.loadManyByIDsAsync([loadByValue])).rejects.toEqual(error);
|
||||
await expect(
|
||||
entityLoader.resultLoader.loadManyByFieldEqualingAsync('customIdField', loadByValue)
|
||||
).rejects.toEqual(error);
|
||||
await expect(entityLoader.enforcing().loadByIDAsync(loadByValue)).rejects.toEqual(error);
|
||||
await expect(entityLoader.loadManyByIDsAsync([loadByValue])).rejects.toEqual(error);
|
||||
await expect(entityLoader.loadManyByIDsAsync([loadByValue])).rejects.toEqual(error);
|
||||
await expect(
|
||||
entityLoader.loadManyByFieldEqualingAsync('customIdField', loadByValue)
|
||||
).rejects.toEqual(error);
|
||||
await expect(
|
||||
entityLoader.resultLoader.loadManyByFieldEqualingManyAsync('customIdField', [loadByValue])
|
||||
entityLoader.enforcing().loadManyByFieldEqualingAsync('customIdField', loadByValue)
|
||||
).rejects.toEqual(error);
|
||||
await expect(
|
||||
entityLoader.loadManyByFieldEqualingManyAsync('customIdField', [loadByValue])
|
||||
).rejects.toEqual(error);
|
||||
await expect(
|
||||
entityLoader.enforcing().loadManyByFieldEqualingManyAsync('customIdField', [loadByValue])
|
||||
).rejects.toEqual(error);
|
||||
});
|
||||
});
|
||||
@@ -78,7 +78,7 @@ class TestNonTransactionalMutationTrigger extends EntityNonTransactionalMutation
|
||||
): Promise<void> {
|
||||
if (mutationInfo.type === EntityMutationType.DELETE) {
|
||||
const entityLoaded = await BlahEntity.loader(viewerContext)
|
||||
|
||||
.enforcing()
|
||||
.loadByIDNullableAsync(entity.getID());
|
||||
if (entityLoaded) {
|
||||
throw new Error(
|
||||
@@ -97,7 +97,7 @@ describe('EntityMutator', () => {
|
||||
// put it in cache
|
||||
const entity = await BlahEntity.creator(viewerContext).enforceCreateAsync();
|
||||
const entityLoaded = await BlahEntity.loader(viewerContext)
|
||||
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity.getID());
|
||||
|
||||
await BlahEntity.enforceDeleteAsync(entityLoaded);
|
||||
|
||||
@@ -530,7 +530,7 @@ describe(EntityMutatorFactory, () => {
|
||||
const existingEntity = await enforceAsyncResult(
|
||||
entityLoaderFactory
|
||||
.forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
|
||||
.resultLoader.loadByIDAsync(id2)
|
||||
.loadByIDAsync(id2)
|
||||
);
|
||||
|
||||
const updatedEntity = await entityMutatorFactory
|
||||
@@ -545,7 +545,7 @@ describe(EntityMutatorFactory, () => {
|
||||
const reloadedEntity = await enforceAsyncResult(
|
||||
entityLoaderFactory
|
||||
.forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
|
||||
.resultLoader.loadByIDAsync(id2)
|
||||
.loadByIDAsync(id2)
|
||||
);
|
||||
expect(reloadedEntity.getAllFields()).toMatchObject(updatedEntity.getAllFields());
|
||||
});
|
||||
@@ -582,7 +582,7 @@ describe(EntityMutatorFactory, () => {
|
||||
const existingEntity = await enforceAsyncResult(
|
||||
entityLoaderFactory
|
||||
.forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
|
||||
.resultLoader.loadByIDAsync(id2)
|
||||
.loadByIDAsync(id2)
|
||||
);
|
||||
|
||||
await entityMutatorFactory
|
||||
@@ -633,7 +633,7 @@ describe(EntityMutatorFactory, () => {
|
||||
const existingEntity = await enforceAsyncResult(
|
||||
entityLoaderFactory
|
||||
.forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
|
||||
.resultLoader.loadByIDAsync(id2)
|
||||
.loadByIDAsync(id2)
|
||||
);
|
||||
|
||||
await entityMutatorFactory
|
||||
@@ -687,7 +687,7 @@ describe(EntityMutatorFactory, () => {
|
||||
const existingEntity = await enforceAsyncResult(
|
||||
entityLoaderFactory
|
||||
.forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
|
||||
.resultLoader.loadByIDAsync(id2)
|
||||
.loadByIDAsync(id2)
|
||||
);
|
||||
|
||||
await entityMutatorFactory
|
||||
@@ -723,7 +723,7 @@ describe(EntityMutatorFactory, () => {
|
||||
const existingEntity = await enforceAsyncResult(
|
||||
entityLoaderFactory
|
||||
.forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
|
||||
.resultLoader.loadByIDAsync(id1)
|
||||
.loadByIDAsync(id1)
|
||||
);
|
||||
expect(existingEntity).toBeTruthy();
|
||||
|
||||
@@ -735,7 +735,7 @@ describe(EntityMutatorFactory, () => {
|
||||
enforceAsyncResult(
|
||||
entityLoaderFactory
|
||||
.forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
|
||||
.resultLoader.loadByIDAsync(id1)
|
||||
.loadByIDAsync(id1)
|
||||
)
|
||||
).rejects.toBeInstanceOf(Error);
|
||||
});
|
||||
@@ -763,7 +763,7 @@ describe(EntityMutatorFactory, () => {
|
||||
const existingEntity = await enforceAsyncResult(
|
||||
entityLoaderFactory
|
||||
.forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
|
||||
.resultLoader.loadByIDAsync(id1)
|
||||
.loadByIDAsync(id1)
|
||||
);
|
||||
|
||||
await entityMutatorFactory
|
||||
@@ -804,7 +804,7 @@ describe(EntityMutatorFactory, () => {
|
||||
const existingEntity = await enforceAsyncResult(
|
||||
entityLoaderFactory
|
||||
.forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
|
||||
.resultLoader.loadByIDAsync(id1)
|
||||
.loadByIDAsync(id1)
|
||||
);
|
||||
|
||||
await entityMutatorFactory
|
||||
@@ -849,7 +849,7 @@ describe(EntityMutatorFactory, () => {
|
||||
const existingEntity = await enforceAsyncResult(
|
||||
entityLoaderFactory
|
||||
.forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
|
||||
.resultLoader.loadByIDAsync(id1)
|
||||
.loadByIDAsync(id1)
|
||||
);
|
||||
|
||||
await entityMutatorFactory
|
||||
@@ -882,7 +882,7 @@ describe(EntityMutatorFactory, () => {
|
||||
const entites1 = await enforceResultsAsync(
|
||||
entityLoaderFactory
|
||||
.forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
|
||||
.resultLoader.loadManyByFieldEqualingAsync('stringField', 'huh')
|
||||
.loadManyByFieldEqualingAsync('stringField', 'huh')
|
||||
);
|
||||
expect(entites1).toHaveLength(1);
|
||||
|
||||
@@ -896,7 +896,7 @@ describe(EntityMutatorFactory, () => {
|
||||
const entities2 = await enforceResultsAsync(
|
||||
entityLoaderFactory
|
||||
.forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
|
||||
.resultLoader.loadManyByFieldEqualingAsync('stringField', 'huh')
|
||||
.loadManyByFieldEqualingAsync('stringField', 'huh')
|
||||
);
|
||||
expect(entities2).toHaveLength(2);
|
||||
});
|
||||
|
||||
@@ -98,25 +98,25 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE', () => {
|
||||
.enforceCreateAsync();
|
||||
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subCategory.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subSubCategory.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subSubCategory.getID())
|
||||
).resolves.not.toBeNull();
|
||||
|
||||
await CategoryEntity.enforceDeleteAsync(parentCategory);
|
||||
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
|
||||
).resolves.toBeNull();
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subCategory.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID())
|
||||
).resolves.toBeNull();
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subSubCategory.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subSubCategory.getID())
|
||||
).resolves.toBeNull();
|
||||
});
|
||||
|
||||
@@ -137,10 +137,10 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE', () => {
|
||||
await CategoryEntity.enforceDeleteAsync(categoryA);
|
||||
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(categoryA.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryA.getID())
|
||||
).resolves.toBeNull();
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(categoryB.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryB.getID())
|
||||
).resolves.toBeNull();
|
||||
});
|
||||
});
|
||||
@@ -161,29 +161,29 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
|
||||
.enforceCreateAsync();
|
||||
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subCategory.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subSubCategory.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subSubCategory.getID())
|
||||
).resolves.not.toBeNull();
|
||||
|
||||
await CategoryEntity.enforceDeleteAsync(parentCategory);
|
||||
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
|
||||
).resolves.toBeNull();
|
||||
|
||||
const loadedSubCategory = await CategoryEntity.loader(viewerContext).loadByIDAsync(
|
||||
subCategory.getID()
|
||||
);
|
||||
const loadedSubCategory = await CategoryEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByIDAsync(subCategory.getID());
|
||||
expect(loadedSubCategory.getField('parent_category_id')).toBeNull();
|
||||
|
||||
const loadedSubSubCategory = await CategoryEntity.loader(viewerContext).loadByIDAsync(
|
||||
subSubCategory.getID()
|
||||
);
|
||||
const loadedSubSubCategory = await CategoryEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByIDAsync(subSubCategory.getID());
|
||||
expect(loadedSubSubCategory.getField('parent_category_id')).not.toBeNull();
|
||||
});
|
||||
|
||||
@@ -203,9 +203,9 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
|
||||
|
||||
await CategoryEntity.enforceDeleteAsync(categoryA);
|
||||
|
||||
const loadedCategoryB = await CategoryEntity.loader(viewerContext).loadByIDAsync(
|
||||
categoryB.getID()
|
||||
);
|
||||
const loadedCategoryB = await CategoryEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByIDAsync(categoryB.getID());
|
||||
expect(loadedCategoryB.getField('parent_category_id')).toBeNull();
|
||||
});
|
||||
});
|
||||
@@ -228,19 +228,17 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
|
||||
.enforceCreateAsync();
|
||||
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByFieldEqualingAsync(
|
||||
'parent_category_id',
|
||||
parentCategory.getID()
|
||||
)
|
||||
CategoryEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('parent_category_id', parentCategory.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByFieldEqualingAsync(
|
||||
'parent_category_id',
|
||||
subCategory.getID()
|
||||
)
|
||||
CategoryEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('parent_category_id', subCategory.getID())
|
||||
).resolves.not.toBeNull();
|
||||
|
||||
const categoryCacheAdapter = viewerContext.getViewerScopedEntityCompanionForClass(
|
||||
@@ -273,13 +271,13 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
|
||||
expect(subSubCategoryCachedAfter.get(subCategory.getID())?.status).toEqual(CacheStatus.MISS);
|
||||
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
|
||||
).resolves.toBeNull();
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subCategory.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subSubCategory.getID())
|
||||
CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subSubCategory.getID())
|
||||
).resolves.not.toBeNull();
|
||||
});
|
||||
|
||||
@@ -300,16 +298,14 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
|
||||
.enforceUpdateAsync();
|
||||
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByFieldEqualingAsync(
|
||||
'parent_category_id',
|
||||
categoryA.getID()
|
||||
)
|
||||
CategoryEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('parent_category_id', categoryA.getID())
|
||||
).resolves.not.toBeNull();
|
||||
await expect(
|
||||
CategoryEntity.loader(viewerContext).loadByFieldEqualingAsync(
|
||||
'parent_category_id',
|
||||
categoryB.getID()
|
||||
)
|
||||
CategoryEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('parent_category_id', categoryB.getID())
|
||||
).resolves.not.toBeNull();
|
||||
|
||||
const categoryCacheAdapter = viewerContext.getViewerScopedEntityCompanionForClass(
|
||||
|
||||
@@ -28,16 +28,17 @@ describe('Two entities backed by the same table', () => {
|
||||
expect(two).toBeInstanceOf(TwoTestEntity);
|
||||
|
||||
await expect(
|
||||
TwoTestEntity.loader(viewerContext).loadByIDAsync(one.getID())
|
||||
TwoTestEntity.loader(viewerContext).enforcing().loadByIDAsync(one.getID())
|
||||
).rejects.toThrowError('TwoTestEntity must be instantiated with two data');
|
||||
|
||||
await expect(
|
||||
OneTestEntity.loader(viewerContext).loadByIDAsync(two.getID())
|
||||
OneTestEntity.loader(viewerContext).enforcing().loadByIDAsync(two.getID())
|
||||
).rejects.toThrowError('OneTestEntity must be instantiated with one data');
|
||||
|
||||
const manyResults = await OneTestEntity.loader(
|
||||
viewerContext
|
||||
).resultLoader.loadManyByFieldEqualingAsync('common_other_field', 'wat');
|
||||
const manyResults = await OneTestEntity.loader(viewerContext).loadManyByFieldEqualingAsync(
|
||||
'common_other_field',
|
||||
'wat'
|
||||
);
|
||||
const successfulManyResults = successfulResults(manyResults);
|
||||
const failedManyResults = failedResults(manyResults);
|
||||
|
||||
@@ -51,7 +52,7 @@ describe('Two entities backed by the same table', () => {
|
||||
|
||||
const fieldEqualityConjunctionResults = await OneTestEntity.loader(
|
||||
viewerContext
|
||||
).resultLoader.loadManyByFieldEqualityConjunctionAsync([
|
||||
).loadManyByFieldEqualityConjunctionAsync([
|
||||
{
|
||||
fieldName: 'common_other_field',
|
||||
fieldValue: 'wat',
|
||||
|
||||
@@ -18,7 +18,7 @@ describe('Two entities backed by the same table', () => {
|
||||
expect(entity1).toBeInstanceOf(OneTestEntity);
|
||||
|
||||
const entity2 = await TwoTestEntity.loader(viewerContext)
|
||||
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity1.getID());
|
||||
expect(entity2).toBeInstanceOf(TwoTestEntity);
|
||||
|
||||
@@ -33,7 +33,7 @@ describe('Two entities backed by the same table', () => {
|
||||
});
|
||||
|
||||
const loaded1 = await OneTestEntity.loader(viewerContext)
|
||||
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity1.getID());
|
||||
expect(loaded1.getAllFields()).toMatchObject({
|
||||
id: updated2.getID(),
|
||||
@@ -51,7 +51,7 @@ describe('Two entities backed by the same table', () => {
|
||||
.enforceCreateAsync();
|
||||
|
||||
const loadedEntity = await TwoTestEntity.loader(viewerContext)
|
||||
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('other_field', 'huh');
|
||||
expect(loadedEntity?.getAllFields()).toMatchObject({
|
||||
id: entity.getID(),
|
||||
@@ -60,12 +60,12 @@ describe('Two entities backed by the same table', () => {
|
||||
});
|
||||
|
||||
const loaded1 = await OneTestEntity.loader(viewerContext)
|
||||
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity.getID());
|
||||
await OneTestEntity.updater(loaded1).setField('fake_field', 'world').enforceUpdateAsync();
|
||||
|
||||
const loaded2 = await TwoTestEntity.loader(viewerContext)
|
||||
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('other_field', 'huh');
|
||||
expect(loaded2?.getAllFields()).toMatchObject({
|
||||
id: entity.getID(),
|
||||
@@ -74,7 +74,7 @@ describe('Two entities backed by the same table', () => {
|
||||
});
|
||||
|
||||
const loaded22 = await TwoTestEntity.loader(viewerContext)
|
||||
|
||||
.enforcing()
|
||||
.loadByFieldEqualingAsync('fake_field', 'world');
|
||||
expect(loaded22?.getAllFields()).toMatchObject({
|
||||
id: entity.getID(),
|
||||
|
||||
@@ -34,6 +34,6 @@ export default class EntityInvalidFieldValueError<
|
||||
fieldName: N,
|
||||
fieldValue?: TFields[N]
|
||||
) {
|
||||
super(`Entity field not valid: ${entityClass.name} (${fieldName} = ${fieldValue})`);
|
||||
super(`Entity field not valid: ${entityClass.name} (${String(fieldName)} = ${fieldValue})`);
|
||||
}
|
||||
}
|
||||
@@ -34,6 +34,6 @@ export default class EntityNotFoundError<
|
||||
fieldName: N,
|
||||
fieldValue: TFields[N]
|
||||
) {
|
||||
super(`Entity not found: ${entityClass.name} (${fieldName} = ${fieldValue})`);
|
||||
super(`Entity not found: ${entityClass.name} (${String(fieldName)} = ${fieldValue})`);
|
||||
}
|
||||
}
|
||||
@@ -7,7 +7,7 @@
|
||||
export { default as ComposedEntityCacheAdapter } from './ComposedEntityCacheAdapter';
|
||||
export { default as ComposedSecondaryEntityCache } from './ComposedSecondaryEntityCache';
|
||||
export { default as GenericSecondaryEntityCache } from './GenericSecondaryEntityCache';
|
||||
export { default as EntityResultLoader } from './EntityResultLoader';
|
||||
export { default as EnforcingEntityLoader } from './EnforcingEntityLoader';
|
||||
export { default as Entity } from './Entity';
|
||||
export * from './Entity';
|
||||
export { default as EntityAssociationLoader } from './EntityAssociationLoader';
|
||||
|
||||
@@ -11,7 +11,10 @@ import {
|
||||
timeAndLogLoadEventAsync,
|
||||
timeAndLogLoadMapEventAsync,
|
||||
} from '../metrics/EntityMetricsUtils';
|
||||
import IEntityMetricsAdapter, { EntityMetricsLoadType } from '../metrics/IEntityMetricsAdapter';
|
||||
import IEntityMetricsAdapter, {
|
||||
EntityMetricsLoadType,
|
||||
IncrementLoadCountEventType,
|
||||
} from '../metrics/IEntityMetricsAdapter';
|
||||
import { computeIfAbsent, zipToMap } from '../utils/collections/maps';
|
||||
import ReadThroughEntityCache from './ReadThroughEntityCache';
|
||||
|
||||
@@ -57,7 +60,8 @@ export default class EntityDataManager<TFields> {
|
||||
fieldName: N,
|
||||
fieldValues: readonly NonNullable<TFields[N]>[]
|
||||
): Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>> {
|
||||
this.metricsAdapter.incrementDataManagerCacheLoadCount({
|
||||
this.metricsAdapter.incrementDataManagerLoadCount({
|
||||
type: IncrementLoadCountEventType.CACHE,
|
||||
fieldValueCount: fieldValues.length,
|
||||
entityClassName: this.entityClassName,
|
||||
});
|
||||
@@ -65,7 +69,8 @@ export default class EntityDataManager<TFields> {
|
||||
fieldName,
|
||||
fieldValues,
|
||||
async (fetcherValues) => {
|
||||
this.metricsAdapter.incrementDataManagerDatabaseLoadCount({
|
||||
this.metricsAdapter.incrementDataManagerLoadCount({
|
||||
type: IncrementLoadCountEventType.DATABASE,
|
||||
fieldValueCount: fieldValues.length,
|
||||
entityClassName: this.entityClassName,
|
||||
});
|
||||
@@ -108,7 +113,9 @@ export default class EntityDataManager<TFields> {
|
||||
);
|
||||
if (nullOrUndefinedValueIndex >= 0) {
|
||||
throw new Error(
|
||||
`Invalid load: ${this.entityClassName} (${fieldName} = ${fieldValues[nullOrUndefinedValueIndex]})`
|
||||
`Invalid load: ${this.entityClassName} (${String(fieldName)} = ${
|
||||
fieldValues[nullOrUndefinedValueIndex]
|
||||
})`
|
||||
);
|
||||
}
|
||||
|
||||
@@ -117,7 +124,8 @@ export default class EntityDataManager<TFields> {
|
||||
return await this.databaseAdapter.fetchManyWhereAsync(queryContext, fieldName, fieldValues);
|
||||
}
|
||||
|
||||
this.metricsAdapter.incrementDataManagerDataloaderLoadCount({
|
||||
this.metricsAdapter.incrementDataManagerLoadCount({
|
||||
type: IncrementLoadCountEventType.DATALOADER,
|
||||
fieldValueCount: fieldValues.length,
|
||||
entityClassName: this.entityClassName,
|
||||
});
|
||||
|
||||
@@ -24,7 +24,7 @@ export const getDatabaseFieldForEntityField = <TFields>(
|
||||
entityField: keyof TFields
|
||||
): string => {
|
||||
const databaseField = entityConfiguration.entityToDBFieldsKeyMapping.get(entityField);
|
||||
invariant(databaseField, `database field mapping missing for ${entityField}`);
|
||||
invariant(databaseField, `database field mapping missing for ${String(entityField)}`);
|
||||
return databaseField!;
|
||||
};
|
||||
|
||||
|
||||
@@ -102,7 +102,9 @@ export default class ReadThroughEntityCache<TFields> {
|
||||
// TODO(wschurman): emit or throw here since console may not be available
|
||||
// eslint-disable-next-line no-console
|
||||
console.warn(
|
||||
`unique key ${fieldName} in ${this.entityConfiguration.tableName} returned multiple rows for ${fieldValue}`
|
||||
`unique key ${String(fieldName)} in ${
|
||||
this.entityConfiguration.tableName
|
||||
} returned multiple rows for ${fieldValue}`
|
||||
);
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -4,7 +4,6 @@ import {
|
||||
when,
|
||||
anything,
|
||||
verify,
|
||||
anyNumber,
|
||||
objectContaining,
|
||||
spy,
|
||||
anyString,
|
||||
@@ -13,7 +12,10 @@ import {
|
||||
} from 'ts-mockito';
|
||||
|
||||
import EntityDatabaseAdapter from '../../EntityDatabaseAdapter';
|
||||
import IEntityMetricsAdapter, { EntityMetricsLoadType } from '../../metrics/IEntityMetricsAdapter';
|
||||
import IEntityMetricsAdapter, {
|
||||
EntityMetricsLoadType,
|
||||
IncrementLoadCountEventType,
|
||||
} from '../../metrics/IEntityMetricsAdapter';
|
||||
import NoOpEntityMetricsAdapter from '../../metrics/NoOpEntityMetricsAdapter';
|
||||
import TestEntity, { testEntityConfiguration, TestFields } from '../../testfixtures/TestEntity';
|
||||
import {
|
||||
@@ -519,24 +521,27 @@ describe(EntityDataManager, () => {
|
||||
).once();
|
||||
|
||||
verify(
|
||||
metricsAdapterMock.incrementDataManagerDataloaderLoadCount(
|
||||
metricsAdapterMock.incrementDataManagerLoadCount(
|
||||
deepEqual({
|
||||
type: IncrementLoadCountEventType.DATALOADER,
|
||||
fieldValueCount: 1,
|
||||
entityClassName: TestEntity.name,
|
||||
})
|
||||
)
|
||||
).once();
|
||||
verify(
|
||||
metricsAdapterMock.incrementDataManagerCacheLoadCount(
|
||||
metricsAdapterMock.incrementDataManagerLoadCount(
|
||||
deepEqual({
|
||||
type: IncrementLoadCountEventType.CACHE,
|
||||
fieldValueCount: 1,
|
||||
entityClassName: TestEntity.name,
|
||||
})
|
||||
)
|
||||
).once();
|
||||
verify(
|
||||
metricsAdapterMock.incrementDataManagerDatabaseLoadCount(
|
||||
metricsAdapterMock.incrementDataManagerLoadCount(
|
||||
deepEqual({
|
||||
type: IncrementLoadCountEventType.DATABASE,
|
||||
fieldValueCount: 1,
|
||||
entityClassName: TestEntity.name,
|
||||
})
|
||||
@@ -565,9 +570,7 @@ describe(EntityDataManager, () => {
|
||||
)
|
||||
).once();
|
||||
|
||||
verify(metricsAdapterMock.incrementDataManagerDataloaderLoadCount(anyNumber())).never();
|
||||
verify(metricsAdapterMock.incrementDataManagerCacheLoadCount(anyNumber())).never();
|
||||
verify(metricsAdapterMock.incrementDataManagerDatabaseLoadCount(anyNumber())).never();
|
||||
verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).never();
|
||||
});
|
||||
|
||||
it('throws when a load-by value is null or undefined', async () => {
|
||||
|
||||
@@ -9,10 +9,28 @@ export enum EntityMetricsLoadType {
|
||||
LOAD_MANY_RAW,
|
||||
}
|
||||
|
||||
/**
|
||||
* Event about a single call to an {@link EntityLoader} method.
|
||||
*/
|
||||
export interface EntityMetricsLoadEvent {
|
||||
/**
|
||||
* {@link EntityMetricsLoadType} for this load.
|
||||
*/
|
||||
type: EntityMetricsLoadType;
|
||||
|
||||
/**
|
||||
* Class name of the {@link Entity} being loaded.
|
||||
*/
|
||||
entityClassName: string;
|
||||
|
||||
/**
|
||||
* Total duration of this load, including fetch and construction of entities.
|
||||
*/
|
||||
duration: number;
|
||||
|
||||
/**
|
||||
* Number of entities returned for this load.
|
||||
*/
|
||||
count: number;
|
||||
}
|
||||
|
||||
@@ -23,13 +41,57 @@ export enum EntityMetricsMutationType {
|
||||
}
|
||||
|
||||
export interface EntityMetricsMutationEvent {
|
||||
/**
|
||||
* {@link EntityMetricsMutationType} for this mutation.
|
||||
*/
|
||||
type: EntityMetricsMutationType;
|
||||
|
||||
/**
|
||||
* Class name of the {@link Entity} being mutated.
|
||||
*/
|
||||
entityClassName: string;
|
||||
|
||||
/**
|
||||
* Total duration of this mutation.
|
||||
*/
|
||||
duration: number;
|
||||
}
|
||||
|
||||
export enum IncrementLoadCountEventType {
|
||||
/**
|
||||
* Type for when a dataloader load is initiated via the standard load methods
|
||||
* since all loads go through a dataloader.
|
||||
*/
|
||||
DATALOADER,
|
||||
|
||||
/**
|
||||
* Type for when a cache load is initiated due to a dataloader miss.
|
||||
*/
|
||||
CACHE,
|
||||
|
||||
/**
|
||||
* Type for when a database load is initiated due to a dataloader and cache miss, when an entity query doesn't support caching, or during a transaction.
|
||||
*/
|
||||
DATABASE,
|
||||
}
|
||||
|
||||
/**
|
||||
* Event used to record dataloader, cache, and database load counts in {@link EntityDataManager}.
|
||||
*/
|
||||
export interface IncrementLoadCountEvent {
|
||||
/**
|
||||
* Type of this event.
|
||||
*/
|
||||
type: IncrementLoadCountEventType;
|
||||
|
||||
/**
|
||||
* Number of field values being loaded for this call.
|
||||
*/
|
||||
fieldValueCount: number;
|
||||
|
||||
/**
|
||||
* Class name of the {@link Entity} being loaded.
|
||||
*/
|
||||
entityClassName: string;
|
||||
}
|
||||
|
||||
@@ -38,7 +100,13 @@ export enum EntityMetricsAuthorizationResult {
|
||||
ALLOW,
|
||||
}
|
||||
|
||||
/**
|
||||
* Event used to record a singe {@link EntityPrivacyPolicy} authorization.
|
||||
*/
|
||||
export interface EntityMetricsAuthorizationEvent {
|
||||
/**
|
||||
* Class name of the {@link Entity} being authorized.
|
||||
*/
|
||||
entityClassName: string;
|
||||
action: EntityAuthorizationAction;
|
||||
evaluationResult: EntityMetricsAuthorizationResult;
|
||||
@@ -69,25 +137,10 @@ export default interface IEntityMetricsAdapter {
|
||||
logMutatorMutationEvent(mutationEvent: EntityMetricsMutationEvent): void;
|
||||
|
||||
/**
|
||||
* Called when a dataloader load is initiated via the standard
|
||||
* load methods (not equality conjunction or raw).
|
||||
* Called when a dataloader, cache, or database load is initiated via the standard
|
||||
* load methods (not equality conjunction or raw). Most commonly used for logging
|
||||
* a waterfall to determine dataloader and cache hit rates and ratios.
|
||||
* @param fieldValueCount - count of field values being loaded for a field
|
||||
*/
|
||||
incrementDataManagerDataloaderLoadCount(incrementLoadCountEvent: IncrementLoadCountEvent): void;
|
||||
|
||||
/**
|
||||
* Called when a cache load is initiated via the standard
|
||||
* load methods (not equality conjunction or raw). Occurs upon a dataloader
|
||||
* miss.
|
||||
* @param fieldValueCount - count of field values being loaded for a field
|
||||
*/
|
||||
incrementDataManagerCacheLoadCount(incrementLoadCountEvent: IncrementLoadCountEvent): void;
|
||||
|
||||
/**
|
||||
* Called when a database load is initiated via the standard
|
||||
* load methods (not equality conjunction or raw). Occurs upon a cache
|
||||
* miss or when fetching an uncacheable field.
|
||||
* @param fieldValueCount - count of field values being loaded for a field
|
||||
*/
|
||||
incrementDataManagerDatabaseLoadCount(incrementLoadCountEvent: IncrementLoadCountEvent): void;
|
||||
incrementDataManagerLoadCount(incrementLoadCountEvent: IncrementLoadCountEvent): void;
|
||||
}
|
||||
@@ -9,9 +9,5 @@ export default class NoOpEntityMetricsAdapter implements IEntityMetricsAdapter {
|
||||
logAuthorizationEvent(_authorizationEvent: EntityMetricsAuthorizationEvent): void {}
|
||||
logDataManagerLoadEvent(_loadEvent: EntityMetricsLoadEvent): void {}
|
||||
logMutatorMutationEvent(_mutationEvent: EntityMetricsMutationEvent): void {}
|
||||
incrementDataManagerDataloaderLoadCount(
|
||||
_incrementLoadCountEvent: IncrementLoadCountEvent
|
||||
): void {}
|
||||
incrementDataManagerCacheLoadCount(_incrementLoadCountEvent: IncrementLoadCountEvent): void {}
|
||||
incrementDataManagerDatabaseLoadCount(_incrementLoadCountEvent: IncrementLoadCountEvent): void {}
|
||||
incrementDataManagerLoadCount(_incrementLoadCountEvent: IncrementLoadCountEvent): void {}
|
||||
}
|
||||
@@ -3,7 +3,7 @@ import { result, Result } from '@expo/results';
|
||||
import Entity from '../Entity';
|
||||
import { EntityCompanionDefinition } from '../EntityCompanionProvider';
|
||||
import EntityConfiguration from '../EntityConfiguration';
|
||||
import { UUIDField, StringField, DateField, IntField } from '../EntityFields';
|
||||
import { UUIDField, StringField, DateField, IntField, LowercaseStringField } from '../EntityFields';
|
||||
import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
|
||||
import ViewerContext from '../ViewerContext';
|
||||
import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
|
||||
@@ -12,6 +12,7 @@ export type TestFields = {
|
||||
customIdField: string;
|
||||
testIndexedField: string;
|
||||
stringField: string;
|
||||
lowercasedField: string;
|
||||
intField: number;
|
||||
dateField: Date;
|
||||
nullableField: string | null;
|
||||
@@ -31,6 +32,9 @@ export const testEntityConfiguration = new EntityConfiguration<TestFields>({
|
||||
stringField: new StringField({
|
||||
columnName: 'string_field',
|
||||
}),
|
||||
lowercasedField: new LowercaseStringField({
|
||||
columnName: 'lowercase_field',
|
||||
}),
|
||||
intField: new IntField({
|
||||
columnName: 'number_field',
|
||||
}),
|
||||
@@ -86,6 +90,7 @@ export default class TestEntity extends Entity<TestFields, string, ViewerContext
|
||||
customIdField: testValue,
|
||||
testIndexedField: 'hello',
|
||||
stringField: 'hello',
|
||||
lowercasedField: 'hello',
|
||||
intField: 1,
|
||||
dateField: new Date(),
|
||||
nullableField: null,
|
||||
|
||||
@@ -158,7 +158,10 @@ export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
|
||||
|
||||
private generateRandomID(): any {
|
||||
const idSchemaField = this.entityConfiguration2.schema.get(this.entityConfiguration2.idField);
|
||||
invariant(idSchemaField, `No schema field found for ${this.entityConfiguration2.idField}`);
|
||||
invariant(
|
||||
idSchemaField,
|
||||
`No schema field found for ${String(this.entityConfiguration2.idField)}`
|
||||
);
|
||||
if (idSchemaField instanceof StringField) {
|
||||
return uuidv4();
|
||||
} else if (idSchemaField instanceof IntField) {
|
||||
|
||||
@@ -3,18 +3,32 @@ import { EntityFieldDefinition } from '../../EntityFieldDefinition';
|
||||
export default function describeFieldTestCase<T>(
|
||||
fieldDefinition: EntityFieldDefinition<T>,
|
||||
validValues: T[],
|
||||
invalidValues: any[]
|
||||
invalidValues: any[],
|
||||
transformValues: {
|
||||
in: T;
|
||||
out: T;
|
||||
}[]
|
||||
): void {
|
||||
describe(fieldDefinition.constructor.name, () => {
|
||||
if (validValues.length > 0) {
|
||||
test.each(validValues)(`${fieldDefinition.constructor.name}.valid %p`, (value) => {
|
||||
expect(fieldDefinition.validateInputValue(value)).toBe(true);
|
||||
expect(fieldDefinition.validateAndTransformInputValue(value).isValid).toBe(true);
|
||||
});
|
||||
}
|
||||
|
||||
if (invalidValues.length > 0) {
|
||||
test.each(invalidValues)(`${fieldDefinition.constructor.name}.invalid %p`, (value) => {
|
||||
expect(fieldDefinition.validateInputValue(value)).toBe(false);
|
||||
expect(fieldDefinition.validateAndTransformInputValue(value).isValid).toBe(false);
|
||||
});
|
||||
}
|
||||
|
||||
if (transformValues.length > 0) {
|
||||
test.each(transformValues)(`${fieldDefinition.constructor.name}.transformed %p`, (value) => {
|
||||
const result = fieldDefinition.validateAndTransformInputValue(value.in);
|
||||
expect(result.isValid).toBe(true);
|
||||
if (result.isValid) {
|
||||
expect(result.transformedValue).toEqual(value.out);
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
Reference in new issue
Block a user