Compare commits

..
Author SHA1 Message Date
Will Schurman 7f102ef29d feat: add EntityField transformation 2022-07-01 13:00:43 -04:00
James Ide 0dbf5e98bb [tests] Run tests on Node 18 instead of Node 12 (#174)
Node 16 is LTS now and 12 is unsupported. 18 is also now released and we will one day run on it so this makes sure one of our major dependencies works on Node 18.

All tests pass, no changes needed.
2022-06-28 17:24:42 -07:00
James Ide 4347d9d577 [npm][ts] Upgrade all minor npm deps incl. TS 4.7 (#176)
Why
---
There were some automated security notices about outdated npm package versions, many of which often can be addressed with minor dependency upgrades.

How
---
Deleted and regenerated yarn.lock, which affects this repo but not consumers of these packages. However, TypeScript 4.7 has a change where it considers stringifying a Symbol to be a potential error. This commit explicitly stringifies keys (entity field names).

I opted for `String(fieldName)` over constraining the field name with `N extends string & keyof TFields` because adding `string &` is "viral" in the sense that lots of files including users of Entity would need to add `string &`. Also, using Symbol field names probably would work fine, they just need to be stringified before printing them.

There were also some Koa router type changes that treat params as `string | undefined` so we need to use `!` in the Entity example router.

Test Plan
---
tsc + unit tests
2022-06-21 00:18:15 -07:00
Will Schurman 9a91b19466 chore: clean up metrics API a bit and add docblocks (#175) 2022-06-08 17:32:07 -07:00
Will Schurman cb7aaad979 docs: update docblock for EntityQueryContext classes (#173) 2022-05-11 11:22:49 -07:00
James Ide 9fcfbf746a feat: update ioredis to v5, make it a devDependency of the cache packages (#172)
Why: ioredis v5 ships with its own TypeScript declarations. The breaking changes from v4 to v5 affect the code that instantiates ioredis, not the code that uses it. As such, I believe that entity is still technically compatible with ioredis v4, but for the sake of keeping our test matrix smaller, this commit uses just ioredis v5 in tests and makes v5 a peer dependency of `entity-cache-adapter-redis`.

Additionally ioredis was a dependency of `entity-cache-adapter-redis`. I changed it to a devDependency and changed the import to `import type` since the package is used only for type checking.

ioredis v5.0.0 changelog: https://github.com/luin/ioredis/releases/tag/v5.0.0. Notable it drops support for Node 10 and for custom Promise libraries, neither of which we use.

Test Plan: building all packages and testing them with Lerna succeeds
2022-04-11 09:44:57 -07:00
James Ide 9c44e8e8d4 Upgrade TS to 4.6.x, use knex 1.0.5 during testing (#171)
Why: Expo's API server will use TS 4.6 and knex 1.0.5. This change makes it so that we run entity's CI tests against these new dependencies.

How: Upgraded the version of typescript in the root package.json. Modified yarn.lock to use knex 1.0.5 instead of updating the db adapter's package.json since knex 1.0.2 still works fine.

Test Plan: Lerna runs tsc in every package (no errors). Unit tests in CI.
2022-04-11 09:16:19 -07:00
57 changed files with 3665 additions and 3969 deletions

No files matched your search

+1 -1
View File
@@ -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
View File
@@ -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}`,
@@ -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),
},
],
]);
@@ -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),
},
],
]);
}
@@ -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);
}
+10 -4
View File
@@ -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;
},
@@ -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');
@@ -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();
});
});
@@ -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 };
}
}
@@ -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';
@@ -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"
}
}
@@ -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
);
+12 -4
View File
@@ -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;
}
+78 -22
View File
@@ -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 };
}
}
+215 -70
View File
@@ -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);
}
});
}
}
+35 -16
View File
@@ -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,
}
+11
View File
@@ -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[] = [];
-326
View File
@@ -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})`);
}
}
+1 -1
View File
@@ -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);
}
});
}
});
+2570 -3116
View File
File diff suppressed because it is too large. Load diff