mirror of
https://github.com/expo/entity.git
synced 2026-11-13 20:28:06 -10:00
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Quinlan Jung
|
a38e77e9af | ||
|
Quinlan Jung
|
9ba1d430e0 |
No files matched your search
@@ -3,30 +3,6 @@
|
||||
All notable changes to this project will be documented in this file.
|
||||
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
|
||||
|
||||
# [0.24.0](https://github.com/expo/entity/compare/v0.23.0...v0.24.0) (2022-02-16)
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* add local memory cache package ([#158](https://github.com/expo/entity/issues/158)) ([85d3575](https://github.com/expo/entity/commit/85d35752fa0919a62efb776a762a6829e83ca7af))
|
||||
|
||||
### Chores
|
||||
|
||||
* Refactor cachers to use an abstract class and interface ([#157](https://github.com/expo/entity/pull/157))
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# [0.23.0](https://github.com/expo/entity/compare/v0.22.0...v0.23.0) (2022-02-09)
|
||||
|
||||
### Breaking changes
|
||||
|
||||
* Move data transforming responsibilities to the CacheAdapter instead of the ReadThroughEntityCache. Affects any classes extending the EntityCacheAdapter and relying on the transformation behavior of the ReadThroughEntityCache. ([#153](https://github.com/expo/entity/pull/153))
|
||||
|
||||
|
||||
|
||||
|
||||
# [0.22.0](https://github.com/expo/entity/compare/v0.21.0...v0.22.0) (2022-02-04)
|
||||
|
||||
|
||||
|
||||
+1
-1
@@ -4,5 +4,5 @@
|
||||
],
|
||||
"npmClient": "yarn",
|
||||
"useWorkspaces": true,
|
||||
"version": "0.24.0"
|
||||
"version": "0.22.0"
|
||||
}
|
||||
@@ -18,7 +18,6 @@
|
||||
"devDependencies": {
|
||||
"@expo/entity": "file:packages/entity",
|
||||
"@expo/results": "^1.0.0",
|
||||
"@types/lru-cache": "^5.1.1",
|
||||
"@types/invariant": "^2.2.33",
|
||||
"@types/ioredis": "^4.26.4",
|
||||
"@types/jest": "^26.0.10",
|
||||
@@ -44,7 +43,6 @@
|
||||
},
|
||||
"dependencies": {
|
||||
"@expo/entity": "file:packages/entity",
|
||||
"@expo/entity-cache-adapter-local-memory": "file:packages/entity-cache-adapter-local-memory",
|
||||
"@expo/entity-cache-adapter-redis": "file:packages/entity-cache-adapter-redis",
|
||||
"@expo/entity-database-adapter-knex": "file:packages/entity-database-adapter-knex",
|
||||
"@expo/entity-secondary-cache-redis": "file:packages/entity-secondary-cache-redis",
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
# Change Log
|
||||
|
||||
All notable changes to this project will be documented in this file.
|
||||
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
|
||||
|
||||
# [0.24.0](https://github.com/expo/entity/compare/v0.23.0...v0.24.0) (2022-02-16)
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* add local memory cache package ([#158](https://github.com/expo/entity/issues/158)) ([85d3575](https://github.com/expo/entity/commit/85d35752fa0919a62efb776a762a6829e83ca7af))
|
||||
@@ -1,44 +0,0 @@
|
||||
# `@expo/entity-cache-adapter-local-memory`
|
||||
|
||||
Cross-request [LRU](https://github.com/isaacs/node-lru-cache) cache adapter for `@expo/entity`. Use
|
||||
this cache with caution - it is nonstandard. The cache is shared between requests in the node process.
|
||||
|
||||
## Why NOT use this cache
|
||||
|
||||
Because this is an in-memory cache, cross-box invalidation is not possible. Do not use this cache
|
||||
if you have the following use cases:
|
||||
|
||||
- The objects stored have high mutability
|
||||
- Reading a stale object from the cache is not acceptable in your application
|
||||
- Cross-box invalidation is not possible
|
||||
|
||||
## Typical use cases
|
||||
|
||||
If your application sees many requests fetching the same objects, you can save a trip to your cache
|
||||
cluster and backing datastore by using this in-memory cache. Here are some good use cases:
|
||||
|
||||
- The objects stored are mostly immutable
|
||||
- You have a low TTL setting in your cache
|
||||
|
||||
## Usage
|
||||
|
||||
During `EntityCompanionProvider` instantiation:
|
||||
|
||||
```typescript
|
||||
export const createDefaultEntityCompanionProvider = (
|
||||
metricsAdapter: IEntityMetricsAdapter = new NoOpEntityMetricsAdapter()
|
||||
): EntityCompanionProvider => {
|
||||
return new EntityCompanionProvider(
|
||||
metricsAdapter,
|
||||
{
|
||||
...
|
||||
},
|
||||
{
|
||||
['local-memory']: {
|
||||
cacheAdapterProvider: new LocalMemoryCacheAdapterProvider.getProvider(),
|
||||
},
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
```
|
||||
@@ -1,38 +0,0 @@
|
||||
{
|
||||
"name": "@expo/entity-cache-adapter-local-memory",
|
||||
"version": "0.24.0",
|
||||
"description": "Cross-request local memory cache adapter for @expo/entity",
|
||||
"files": [
|
||||
"build",
|
||||
"src"
|
||||
],
|
||||
"main": "build/index.js",
|
||||
"types": "build/index.d.ts",
|
||||
"scripts": {
|
||||
"tsc": "tsc",
|
||||
"clean": "rm -rf build coverage coverage-integration",
|
||||
"lint": "eslint src",
|
||||
"lint-fix": "eslint src --fix",
|
||||
"test": "jest --rootDir . --config ../../resources/jest.config.js",
|
||||
"integration": "../../resources/run-with-docker yarn integration-no-setup",
|
||||
"integration-no-setup": "jest --config ../../resources/jest-integration.config.js --rootDir . --runInBand --passWithNoTests",
|
||||
"barrelsby": "barrelsby --directory src --location top --exclude tests__ --singleQuotes --exportDefault --delete"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=12"
|
||||
},
|
||||
"keywords": [
|
||||
"entity"
|
||||
],
|
||||
"author": "Expo",
|
||||
"license": "MIT",
|
||||
"peerDependencies": {
|
||||
"@expo/entity": "*"
|
||||
},
|
||||
"dependencies": {
|
||||
"lru-cache": "^7.3.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@expo/entity": "^0.24.0"
|
||||
}
|
||||
}
|
||||
@@ -1,154 +0,0 @@
|
||||
import { CacheLoadResult, CacheStatus, IEntityGenericCacher } from '@expo/entity';
|
||||
import LRUCache from 'lru-cache';
|
||||
|
||||
// Sentinel value we store in local memory to negatively cache a database miss.
|
||||
// The sentinel value is distinct from any (positively) cached value.
|
||||
export const DOES_NOT_EXIST_LOCAL_MEMORY_CACHE = Symbol('doesNotExist');
|
||||
type LocalMemoryCacheValue<TFields> = Readonly<TFields> | typeof DOES_NOT_EXIST_LOCAL_MEMORY_CACHE;
|
||||
export type LocalMemoryCache<TFields> = LRUCache<string, LocalMemoryCacheValue<TFields>>;
|
||||
|
||||
type LRUCacheOptionsV7<K, V> = {
|
||||
/**
|
||||
* the number of most recently used items to keep.
|
||||
* note that we may store fewer items than this if maxSize is hit.
|
||||
*/
|
||||
max: number;
|
||||
|
||||
/**
|
||||
* if you wish to track item size, you must provide a maxSize
|
||||
* note that we still will only keep up to max *actual items*,
|
||||
* so size tracking may cause fewer than max items to be stored.
|
||||
* At the extreme, a single item of maxSize size will cause everything
|
||||
* else in the cache to be dropped when it is added. Use with caution!
|
||||
* Note also that size tracking can negatively impact performance,
|
||||
* though for most cases, only minimally.
|
||||
*/
|
||||
|
||||
maxSize?: number;
|
||||
|
||||
/**
|
||||
* function to calculate size of items. useful if storing strings or
|
||||
* buffers or other items where memory size depends on the object itself.
|
||||
* also note that oversized items do NOT immediately get dropped from
|
||||
* the cache, though they will cause faster turnover in the storage.
|
||||
*/
|
||||
sizeCalculation?: (value: V, key: K) => number;
|
||||
|
||||
/**
|
||||
* function to call when the item is removed from the cache
|
||||
* Note that using this can negatively impact performance.
|
||||
*/
|
||||
dispose?: (value: V, key: K) => void;
|
||||
|
||||
/**
|
||||
* max time to live for items before they are considered stale
|
||||
* note that stale items are NOT preemptively removed by default,
|
||||
* and MAY live in the cache, contributing to its LRU max, long after
|
||||
* they have expired.
|
||||
* Also, as this cache is optimized for LRU/MRU operations, some of
|
||||
* the staleness/TTL checks will reduce performance, as they will incur
|
||||
* overhead by deleting items.
|
||||
* Must be a positive integer in ms, defaults to 0, which means "no TTL"
|
||||
*/
|
||||
ttl?: number;
|
||||
|
||||
/**
|
||||
* return stale items from cache.get() before disposing of them
|
||||
* boolean, default false
|
||||
*/
|
||||
allowStale?: boolean;
|
||||
|
||||
/**
|
||||
* update the age of items on cache.get(), renewing their TTL
|
||||
* boolean, default false
|
||||
*/
|
||||
updateAgeOnGet?: boolean;
|
||||
|
||||
/**
|
||||
* update the age of items on cache.has(), renewing their TTL
|
||||
* boolean, default false
|
||||
*/
|
||||
updateAgeOnHas?: boolean;
|
||||
|
||||
/**
|
||||
* update the "recently-used"-ness of items on cache.has()
|
||||
* boolean, default false
|
||||
*/
|
||||
updateRecencyOnHas?: boolean;
|
||||
};
|
||||
|
||||
export default class GenericLocalMemoryCacher<TFields> implements IEntityGenericCacher<TFields> {
|
||||
constructor(private readonly localMemoryCache: LocalMemoryCache<TFields>) {}
|
||||
|
||||
static createLRUCache<TFields>(
|
||||
options: { maxSize?: number; ttlSeconds?: number } = {}
|
||||
): LocalMemoryCache<TFields> {
|
||||
const DEFAULT_LRU_CACHE_MAX_AGE_SECONDS = 10;
|
||||
const DEFAULT_LRU_CACHE_SIZE = 10000;
|
||||
const maxAgeSeconds = options.ttlSeconds ?? DEFAULT_LRU_CACHE_MAX_AGE_SECONDS;
|
||||
const lruCacheOptions: LRUCacheOptionsV7<string, TFields> = {
|
||||
max: options.maxSize ?? DEFAULT_LRU_CACHE_SIZE,
|
||||
sizeCalculation: (value: LocalMemoryCacheValue<TFields>) =>
|
||||
value === DOES_NOT_EXIST_LOCAL_MEMORY_CACHE ? 0 : 1,
|
||||
ttl: maxAgeSeconds * 1000, // convert to ms
|
||||
};
|
||||
return new LRUCache<string, LocalMemoryCacheValue<TFields>>(lruCacheOptions as any);
|
||||
}
|
||||
|
||||
static createNoOpCache<TFields>(): LocalMemoryCache<TFields> {
|
||||
return new LRUCache<string, LocalMemoryCacheValue<TFields>>({
|
||||
max: 0,
|
||||
maxAge: -1,
|
||||
});
|
||||
}
|
||||
|
||||
public async loadManyAsync(
|
||||
keys: readonly string[]
|
||||
): Promise<ReadonlyMap<string, CacheLoadResult<TFields>>> {
|
||||
const cacheResults = new Map<string, CacheLoadResult<TFields>>();
|
||||
for (const key of keys) {
|
||||
const cacheResult = this.localMemoryCache.get(key);
|
||||
if (cacheResult === DOES_NOT_EXIST_LOCAL_MEMORY_CACHE) {
|
||||
cacheResults.set(key, {
|
||||
status: CacheStatus.NEGATIVE,
|
||||
});
|
||||
} else if (cacheResult) {
|
||||
cacheResults.set(key, {
|
||||
status: CacheStatus.HIT,
|
||||
item: cacheResult as unknown as TFields,
|
||||
});
|
||||
} else {
|
||||
cacheResults.set(key, {
|
||||
status: CacheStatus.MISS,
|
||||
});
|
||||
}
|
||||
}
|
||||
return cacheResults;
|
||||
}
|
||||
|
||||
public async cacheManyAsync(objectMap: ReadonlyMap<string, Readonly<TFields>>): Promise<void> {
|
||||
for (const [key, item] of objectMap) {
|
||||
this.localMemoryCache.set(key, item);
|
||||
}
|
||||
}
|
||||
|
||||
public async cacheDBMissesAsync(keys: readonly string[]): Promise<void> {
|
||||
for (const key of keys) {
|
||||
this.localMemoryCache.set(key, DOES_NOT_EXIST_LOCAL_MEMORY_CACHE);
|
||||
}
|
||||
}
|
||||
|
||||
public async invalidateManyAsync(keys: readonly string[]): Promise<void> {
|
||||
for (const key of keys) {
|
||||
this.localMemoryCache.del(key);
|
||||
}
|
||||
}
|
||||
|
||||
public makeCacheKey(parts: string[]): string {
|
||||
const delimiter = ':';
|
||||
const escapedParts = parts.map((part) =>
|
||||
part.replace('\\', '\\\\').replace(delimiter, `\\${delimiter}`)
|
||||
);
|
||||
return escapedParts.join(delimiter);
|
||||
}
|
||||
}
|
||||
@@ -1,80 +0,0 @@
|
||||
import { EntityCacheAdapter, CacheLoadResult, EntityConfiguration, mapKeys } from '@expo/entity';
|
||||
import invariant from 'invariant';
|
||||
|
||||
import GenericLocalMemoryCacher, { LocalMemoryCache } from './GenericLocalMemoryCacher';
|
||||
|
||||
export default class LocalMemoryCacheAdapter<TFields> extends EntityCacheAdapter<TFields> {
|
||||
private readonly genericLocalMemoryCacher: GenericLocalMemoryCacher<TFields>;
|
||||
|
||||
constructor(
|
||||
entityConfiguration: EntityConfiguration<TFields>,
|
||||
localMemoryCache: LocalMemoryCache<TFields>
|
||||
) {
|
||||
super(entityConfiguration);
|
||||
this.genericLocalMemoryCacher = new GenericLocalMemoryCacher(localMemoryCache);
|
||||
}
|
||||
|
||||
public async loadManyAsync<N extends keyof TFields>(
|
||||
fieldName: N,
|
||||
fieldValues: readonly NonNullable<TFields[N]>[]
|
||||
): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>> {
|
||||
const localMemoryCacheKeyToFieldValueMapping = new Map(
|
||||
fieldValues.map((fieldValue) => [this.makeCacheKey(fieldName, fieldValue), fieldValue])
|
||||
);
|
||||
const cacheResults = await this.genericLocalMemoryCacher.loadManyAsync(
|
||||
Array.from(localMemoryCacheKeyToFieldValueMapping.keys())
|
||||
);
|
||||
|
||||
return mapKeys(cacheResults, (cacheKey) => {
|
||||
const fieldValue = localMemoryCacheKeyToFieldValueMapping.get(cacheKey);
|
||||
invariant(
|
||||
fieldValue !== undefined,
|
||||
'Unspecified cache key %s returned from generic local memory cacher',
|
||||
cacheKey
|
||||
);
|
||||
return fieldValue;
|
||||
});
|
||||
}
|
||||
|
||||
public async cacheManyAsync<N extends keyof TFields>(
|
||||
fieldName: N,
|
||||
objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>
|
||||
): Promise<void> {
|
||||
await this.genericLocalMemoryCacher.cacheManyAsync(
|
||||
mapKeys(objectMap, (fieldValue) => this.makeCacheKey(fieldName, fieldValue))
|
||||
);
|
||||
}
|
||||
|
||||
public async cacheDBMissesAsync<N extends keyof TFields>(
|
||||
fieldName: N,
|
||||
fieldValues: readonly NonNullable<TFields[N]>[]
|
||||
): Promise<void> {
|
||||
await this.genericLocalMemoryCacher.cacheDBMissesAsync(
|
||||
fieldValues.map((fieldValue) => this.makeCacheKey(fieldName, fieldValue))
|
||||
);
|
||||
}
|
||||
|
||||
public async invalidateManyAsync<N extends keyof TFields>(
|
||||
fieldName: N,
|
||||
fieldValues: readonly NonNullable<TFields[N]>[]
|
||||
): Promise<void> {
|
||||
await this.genericLocalMemoryCacher.invalidateManyAsync(
|
||||
fieldValues.map((fieldValue) => this.makeCacheKey(fieldName, fieldValue))
|
||||
);
|
||||
}
|
||||
|
||||
private makeCacheKey<N extends keyof TFields>(
|
||||
fieldName: N,
|
||||
fieldValue: NonNullable<TFields[N]>
|
||||
): string {
|
||||
const columnName = this.entityConfiguration.entityToDBFieldsKeyMapping.get(fieldName);
|
||||
invariant(columnName, `database field mapping missing for ${fieldName}`);
|
||||
const parts = [
|
||||
this.entityConfiguration.tableName,
|
||||
`${this.entityConfiguration.cacheKeyVersion}`,
|
||||
columnName,
|
||||
String(fieldValue),
|
||||
];
|
||||
return this.genericLocalMemoryCacher.makeCacheKey(parts);
|
||||
}
|
||||
}
|
||||
@@ -1,45 +0,0 @@
|
||||
import {
|
||||
computeIfAbsent,
|
||||
EntityCacheAdapter,
|
||||
EntityConfiguration,
|
||||
IEntityCacheAdapterProvider,
|
||||
} from '@expo/entity';
|
||||
|
||||
import GenericLocalMemoryCacher, { LocalMemoryCache } from './GenericLocalMemoryCacher';
|
||||
import LocalMemoryCacheAdapter from './LocalMemoryCacheAdapter';
|
||||
|
||||
export default class LocalMemoryCacheAdapterProvider implements IEntityCacheAdapterProvider {
|
||||
// local memory cache adapters should be shared/reused across requests
|
||||
static localMemoryCacheAdapterMap = new Map<string, LocalMemoryCacheAdapter<any>>();
|
||||
|
||||
static getNoOpProvider(): IEntityCacheAdapterProvider {
|
||||
return new LocalMemoryCacheAdapterProvider(<TFields>() =>
|
||||
GenericLocalMemoryCacher.createNoOpCache<TFields>()
|
||||
);
|
||||
}
|
||||
|
||||
static getProvider(
|
||||
options: { maxSize?: number; ttlSeconds?: number } = {}
|
||||
): IEntityCacheAdapterProvider {
|
||||
return new LocalMemoryCacheAdapterProvider(<TFields>() =>
|
||||
GenericLocalMemoryCacher.createLRUCache<TFields>(options)
|
||||
);
|
||||
}
|
||||
|
||||
private constructor(
|
||||
private readonly localMemoryCacheCreator: <TFields>() => LocalMemoryCache<TFields>
|
||||
) {}
|
||||
|
||||
public getCacheAdapter<TFields>(
|
||||
entityConfiguration: EntityConfiguration<TFields>
|
||||
): EntityCacheAdapter<TFields> {
|
||||
return computeIfAbsent(
|
||||
LocalMemoryCacheAdapterProvider.localMemoryCacheAdapterMap,
|
||||
entityConfiguration.tableName,
|
||||
() => {
|
||||
const localMemoryCache = this.localMemoryCacheCreator<TFields>();
|
||||
return new LocalMemoryCacheAdapter(entityConfiguration, localMemoryCache);
|
||||
}
|
||||
);
|
||||
}
|
||||
}
|
||||
-180
@@ -1,180 +0,0 @@
|
||||
import { CacheStatus, ViewerContext } from '@expo/entity';
|
||||
import { v4 as uuidv4 } from 'uuid';
|
||||
|
||||
import GenericLocalMemoryCacher from '../GenericLocalMemoryCacher';
|
||||
import LocalMemoryCacheAdapter from '../LocalMemoryCacheAdapter';
|
||||
import { LocalMemoryCacheAdapterProvider } from '../LocalMemoryCacheAdapterProvider';
|
||||
import LocalMemoryTestEntity from '../testfixtures/LocalMemoryTestEntity';
|
||||
import {
|
||||
createLocalMemoryIntegrationTestEntityCompanionProvider,
|
||||
createNoopLocalMemoryIntegrationTestEntityCompanionProvider,
|
||||
} from '../testfixtures/createLocalMemoryIntegrationTestEntityCompanionProvider';
|
||||
|
||||
class TestViewerContext extends ViewerContext {}
|
||||
|
||||
describe(LocalMemoryCacheAdapter, () => {
|
||||
beforeEach(async () => {
|
||||
LocalMemoryCacheAdapterProvider.localMemoryCacheAdapterMap.clear();
|
||||
});
|
||||
|
||||
it('has correct caching behavior', async () => {
|
||||
const viewerContext = new TestViewerContext(
|
||||
createLocalMemoryIntegrationTestEntityCompanionProvider()
|
||||
);
|
||||
const cacheAdapter = viewerContext.entityCompanionProvider.getCompanionForEntity(
|
||||
LocalMemoryTestEntity,
|
||||
LocalMemoryTestEntity.getCompanionDefinition()
|
||||
)['tableDataCoordinator']['cacheAdapter'];
|
||||
const cacheKeyMaker = cacheAdapter['makeCacheKey'].bind(cacheAdapter);
|
||||
|
||||
const date = new Date();
|
||||
const entity1Created = await LocalMemoryTestEntity.creator(viewerContext)
|
||||
.setField('name', 'blah')
|
||||
.setField('dateField', date)
|
||||
.enforceCreateAsync();
|
||||
|
||||
// loading an entity should put it in cache
|
||||
const entity1 = await LocalMemoryTestEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity1Created.getID());
|
||||
|
||||
const entitySpecificGenericCacher =
|
||||
LocalMemoryCacheAdapterProvider.localMemoryCacheAdapterMap.get(
|
||||
LocalMemoryTestEntity.getCompanionDefinition().entityConfiguration.tableName
|
||||
)!['genericLocalMemoryCacher'];
|
||||
const cachedResult = await entitySpecificGenericCacher.loadManyAsync([
|
||||
cacheKeyMaker('id', entity1.getID()),
|
||||
]);
|
||||
const cachedValue = cachedResult.get(cacheKeyMaker('id', entity1.getID()))!;
|
||||
expect(cachedValue).toMatchObject({
|
||||
status: CacheStatus.HIT,
|
||||
item: {
|
||||
id: entity1.getID(),
|
||||
name: 'blah',
|
||||
dateField: date,
|
||||
},
|
||||
});
|
||||
|
||||
// simulate non existent db fetch, should write negative result ('') to cache
|
||||
const nonExistentId = uuidv4();
|
||||
|
||||
const entityNonExistentResult = await LocalMemoryTestEntity.loader(viewerContext).loadByIDAsync(
|
||||
nonExistentId
|
||||
);
|
||||
expect(entityNonExistentResult.ok).toBe(false);
|
||||
|
||||
const nonExistentCachedResult = await entitySpecificGenericCacher.loadManyAsync([
|
||||
cacheKeyMaker('id', nonExistentId),
|
||||
]);
|
||||
expect(nonExistentCachedResult.get(cacheKeyMaker('id', nonExistentId))).toMatchObject({
|
||||
status: CacheStatus.NEGATIVE,
|
||||
});
|
||||
|
||||
// load again through entities framework to ensure it reads negative result
|
||||
const entityNonExistentResult2 = await LocalMemoryTestEntity.loader(
|
||||
viewerContext
|
||||
).loadByIDAsync(nonExistentId);
|
||||
expect(entityNonExistentResult2.ok).toBe(false);
|
||||
|
||||
// invalidate from cache to ensure it invalidates correctly
|
||||
await LocalMemoryTestEntity.loader(viewerContext).invalidateFieldsAsync(entity1.getAllFields());
|
||||
const cachedResultMiss = await entitySpecificGenericCacher.loadManyAsync([
|
||||
cacheKeyMaker('id', entity1.getID()),
|
||||
]);
|
||||
const cachedValueMiss = cachedResultMiss.get(cacheKeyMaker('id', entity1.getID()));
|
||||
expect(cachedValueMiss).toMatchObject({ status: CacheStatus.MISS });
|
||||
});
|
||||
|
||||
it('shares the cache between different requests', async () => {
|
||||
const genericLocalMemoryCacherLoadManySpy = jest.spyOn(
|
||||
GenericLocalMemoryCacher.prototype as unknown as any,
|
||||
'loadManyAsync'
|
||||
);
|
||||
const viewerContext = new TestViewerContext(
|
||||
createLocalMemoryIntegrationTestEntityCompanionProvider()
|
||||
);
|
||||
|
||||
const date = new Date();
|
||||
const entity1Created = await LocalMemoryTestEntity.creator(viewerContext)
|
||||
.setField('name', 'blah')
|
||||
.setField('dateField', date)
|
||||
.enforceCreateAsync();
|
||||
|
||||
// loading an entity should put it in cache
|
||||
await LocalMemoryTestEntity.loader(viewerContext)
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity1Created.getID());
|
||||
|
||||
// load entity with a different request
|
||||
const viewerContext2 = new TestViewerContext(
|
||||
createLocalMemoryIntegrationTestEntityCompanionProvider()
|
||||
);
|
||||
const entity1WithVc2 = await LocalMemoryTestEntity.loader(viewerContext2)
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity1Created.getID());
|
||||
|
||||
const cacheAdapter = viewerContext.entityCompanionProvider.getCompanionForEntity(
|
||||
LocalMemoryTestEntity,
|
||||
LocalMemoryTestEntity.getCompanionDefinition()
|
||||
)['tableDataCoordinator']['cacheAdapter'];
|
||||
const cacheKeyMaker = cacheAdapter['makeCacheKey'].bind(cacheAdapter);
|
||||
expect(entity1WithVc2.getAllFields()).toMatchObject({
|
||||
id: entity1WithVc2.getID(),
|
||||
name: 'blah',
|
||||
dateField: date,
|
||||
});
|
||||
expect(genericLocalMemoryCacherLoadManySpy).toBeCalledWith([
|
||||
cacheKeyMaker('id', entity1WithVc2.getID()),
|
||||
]);
|
||||
expect(genericLocalMemoryCacherLoadManySpy).toBeCalledTimes(2);
|
||||
});
|
||||
|
||||
it('respects the parameters of a noop cache', async () => {
|
||||
const viewerContext = new TestViewerContext(
|
||||
createNoopLocalMemoryIntegrationTestEntityCompanionProvider()
|
||||
);
|
||||
const cacheAdapter = viewerContext.entityCompanionProvider.getCompanionForEntity(
|
||||
LocalMemoryTestEntity,
|
||||
LocalMemoryTestEntity.getCompanionDefinition()
|
||||
)['tableDataCoordinator']['cacheAdapter'];
|
||||
const cacheKeyMaker = cacheAdapter['makeCacheKey'].bind(cacheAdapter);
|
||||
|
||||
const date = new Date();
|
||||
const entity1Created = await LocalMemoryTestEntity.creator(viewerContext)
|
||||
.setField('name', 'blah')
|
||||
.setField('dateField', date)
|
||||
.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)
|
||||
.enforcing()
|
||||
.loadByIDAsync(entity1Created.getID());
|
||||
|
||||
const entitySpecificGenericCacher =
|
||||
LocalMemoryCacheAdapterProvider.localMemoryCacheAdapterMap.get(
|
||||
LocalMemoryTestEntity.getCompanionDefinition().entityConfiguration.tableName
|
||||
)!['genericLocalMemoryCacher'];
|
||||
const cachedResult = await entitySpecificGenericCacher.loadManyAsync([
|
||||
cacheKeyMaker('id', entity1.getID()),
|
||||
]);
|
||||
const cachedValue = cachedResult.get(cacheKeyMaker('id', entity1.getID()))!;
|
||||
expect(cachedValue).toMatchObject({
|
||||
status: CacheStatus.MISS,
|
||||
});
|
||||
|
||||
// a non existent db fetch should try to write negative result ('') but it's a noop cache, so it should be a miss
|
||||
const nonExistentId = uuidv4();
|
||||
|
||||
const entityNonExistentResult = await LocalMemoryTestEntity.loader(viewerContext).loadByIDAsync(
|
||||
nonExistentId
|
||||
);
|
||||
expect(entityNonExistentResult.ok).toBe(false);
|
||||
|
||||
const nonExistentCachedResult = await entitySpecificGenericCacher.loadManyAsync([
|
||||
cacheKeyMaker('id', nonExistentId),
|
||||
]);
|
||||
expect(nonExistentCachedResult.get(cacheKeyMaker('id', nonExistentId))).toMatchObject({
|
||||
status: CacheStatus.MISS,
|
||||
});
|
||||
});
|
||||
});
|
||||
-125
@@ -1,125 +0,0 @@
|
||||
import { CacheStatus, UUIDField, EntityConfiguration } from '@expo/entity';
|
||||
|
||||
import GenericLocalMemoryCacher, {
|
||||
DOES_NOT_EXIST_LOCAL_MEMORY_CACHE,
|
||||
} from '../GenericLocalMemoryCacher';
|
||||
import LocalMemoryCacheAdapter from '../LocalMemoryCacheAdapter';
|
||||
|
||||
type BlahFields = {
|
||||
id: string;
|
||||
};
|
||||
|
||||
const entityConfiguration = new EntityConfiguration<BlahFields>({
|
||||
idField: 'id',
|
||||
tableName: 'blah',
|
||||
schema: {
|
||||
id: new UUIDField({ columnName: 'id', cache: true }),
|
||||
},
|
||||
databaseAdapterFlavor: 'postgres',
|
||||
cacheAdapterFlavor: 'local-memory',
|
||||
});
|
||||
|
||||
describe(LocalMemoryCacheAdapter, () => {
|
||||
describe('loadManyAsync', () => {
|
||||
it('returns appropriate cache results', async () => {
|
||||
const cacheAdapter = new LocalMemoryCacheAdapter(
|
||||
entityConfiguration,
|
||||
GenericLocalMemoryCacher.createLRUCache({
|
||||
maxSize: Number.MAX_SAFE_INTEGER,
|
||||
ttlSeconds: Number.MAX_SAFE_INTEGER,
|
||||
})
|
||||
);
|
||||
|
||||
const cacheHits = new Map<string, Readonly<BlahFields>>([['test-id-1', { id: 'test-id-1' }]]);
|
||||
await cacheAdapter.cacheManyAsync('id', cacheHits);
|
||||
await cacheAdapter.cacheDBMissesAsync('id', ['test-id-2']);
|
||||
|
||||
const results = await cacheAdapter.loadManyAsync('id', [
|
||||
'test-id-1',
|
||||
'test-id-2',
|
||||
'test-id-3',
|
||||
]);
|
||||
|
||||
expect(results.get('test-id-1')).toMatchObject({
|
||||
status: CacheStatus.HIT,
|
||||
item: { id: 'test-id-1' },
|
||||
});
|
||||
expect(results.get('test-id-2')).toMatchObject({ status: CacheStatus.NEGATIVE });
|
||||
expect(results.get('test-id-3')).toMatchObject({ status: CacheStatus.MISS });
|
||||
expect(results.size).toBe(3);
|
||||
});
|
||||
|
||||
it('returns empty map when passed empty array of fieldValues', async () => {
|
||||
const cacheAdapter = new LocalMemoryCacheAdapter(
|
||||
entityConfiguration,
|
||||
GenericLocalMemoryCacher.createLRUCache({
|
||||
maxSize: Number.MAX_SAFE_INTEGER,
|
||||
ttlSeconds: Number.MAX_SAFE_INTEGER,
|
||||
})
|
||||
);
|
||||
const results = await cacheAdapter.loadManyAsync('id', []);
|
||||
expect(results).toEqual(new Map());
|
||||
});
|
||||
});
|
||||
|
||||
describe('cacheManyAsync', () => {
|
||||
it('correctly caches all objects', async () => {
|
||||
const localMemoryCache = GenericLocalMemoryCacher.createLRUCache<BlahFields>({
|
||||
maxSize: Number.MAX_SAFE_INTEGER,
|
||||
ttlSeconds: Number.MAX_SAFE_INTEGER,
|
||||
});
|
||||
|
||||
const cacheAdapter = new LocalMemoryCacheAdapter(entityConfiguration, localMemoryCache);
|
||||
await cacheAdapter.cacheManyAsync('id', new Map([['test-id-1', { id: 'test-id-1' }]]));
|
||||
|
||||
const cacheKey = cacheAdapter['makeCacheKey']('id', 'test-id-1');
|
||||
expect(localMemoryCache.get(cacheKey)).toMatchObject({
|
||||
id: 'test-id-1',
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('cacheDBMissesAsync', () => {
|
||||
it('correctly caches misses', async () => {
|
||||
const localMemoryCache = GenericLocalMemoryCacher.createLRUCache<BlahFields>({
|
||||
maxSize: Number.MAX_SAFE_INTEGER,
|
||||
ttlSeconds: Number.MAX_SAFE_INTEGER,
|
||||
});
|
||||
|
||||
const cacheAdapter = new LocalMemoryCacheAdapter(entityConfiguration, localMemoryCache);
|
||||
await cacheAdapter.cacheDBMissesAsync('id', ['test-id-1']);
|
||||
|
||||
const cacheKey = cacheAdapter['makeCacheKey']('id', 'test-id-1');
|
||||
expect(localMemoryCache.get(cacheKey)).toEqual(DOES_NOT_EXIST_LOCAL_MEMORY_CACHE);
|
||||
});
|
||||
});
|
||||
|
||||
describe('invalidateManyAsync', () => {
|
||||
it('invalidates correctly', async () => {
|
||||
const localMemoryCache = GenericLocalMemoryCacher.createLRUCache<BlahFields>({
|
||||
maxSize: Number.MAX_SAFE_INTEGER,
|
||||
ttlSeconds: Number.MAX_SAFE_INTEGER,
|
||||
});
|
||||
|
||||
const cacheAdapter = new LocalMemoryCacheAdapter(entityConfiguration, localMemoryCache);
|
||||
await cacheAdapter.cacheManyAsync('id', new Map([['test-id-1', { id: 'test-id-1' }]]));
|
||||
await cacheAdapter.cacheDBMissesAsync('id', ['test-id-2']);
|
||||
await cacheAdapter.invalidateManyAsync('id', ['test-id-1', 'test-id-2']);
|
||||
|
||||
const results = await cacheAdapter.loadManyAsync('id', ['test-id-1', 'test-id-2']);
|
||||
expect(results.get('test-id-1')).toMatchObject({ status: CacheStatus.MISS });
|
||||
expect(results.get('test-id-2')).toMatchObject({ status: CacheStatus.MISS });
|
||||
});
|
||||
|
||||
it('returns when passed empty array of fieldValues', async () => {
|
||||
const cacheAdapter = new LocalMemoryCacheAdapter(
|
||||
entityConfiguration,
|
||||
GenericLocalMemoryCacher.createLRUCache<BlahFields>({
|
||||
maxSize: Number.MAX_SAFE_INTEGER,
|
||||
ttlSeconds: Number.MAX_SAFE_INTEGER,
|
||||
})
|
||||
);
|
||||
await cacheAdapter.invalidateManyAsync('id', []);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,10 +0,0 @@
|
||||
/* eslint-disable tsdoc/syntax */
|
||||
/**
|
||||
* @packageDocumentation
|
||||
* @module @expo/entity-cache-adapter-local-memory
|
||||
*/
|
||||
|
||||
export { default as LocalMemoryCacheAdapter } from './LocalMemoryCacheAdapter';
|
||||
export { default as LocalMemoryCacheAdapterProvider } from './LocalMemoryCacheAdapterProvider';
|
||||
export { default as GenericLocalMemoryCacher } from './GenericLocalMemoryCacher';
|
||||
export * from './GenericLocalMemoryCacher';
|
||||
@@ -1,100 +0,0 @@
|
||||
import {
|
||||
AlwaysAllowPrivacyPolicyRule,
|
||||
EntityPrivacyPolicy,
|
||||
ViewerContext,
|
||||
UUIDField,
|
||||
DateField,
|
||||
StringField,
|
||||
EntityConfiguration,
|
||||
EntityCompanionDefinition,
|
||||
Entity,
|
||||
} from '@expo/entity';
|
||||
|
||||
export type LocalMemoryTestEntityFields = {
|
||||
id: string;
|
||||
name: string;
|
||||
dateField: Date | null;
|
||||
};
|
||||
|
||||
export default class LocalMemoryTestEntity extends Entity<
|
||||
LocalMemoryTestEntityFields,
|
||||
string,
|
||||
ViewerContext
|
||||
> {
|
||||
static getCompanionDefinition(): EntityCompanionDefinition<
|
||||
LocalMemoryTestEntityFields,
|
||||
string,
|
||||
ViewerContext,
|
||||
LocalMemoryTestEntity,
|
||||
LocalMemoryTestEntityPrivacyPolicy
|
||||
> {
|
||||
return localMemoryTestEntityCompanionDefinition;
|
||||
}
|
||||
}
|
||||
|
||||
export class LocalMemoryTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
|
||||
LocalMemoryTestEntityFields,
|
||||
string,
|
||||
ViewerContext,
|
||||
LocalMemoryTestEntity
|
||||
> {
|
||||
protected override readonly createRules = [
|
||||
new AlwaysAllowPrivacyPolicyRule<
|
||||
LocalMemoryTestEntityFields,
|
||||
string,
|
||||
ViewerContext,
|
||||
LocalMemoryTestEntity
|
||||
>(),
|
||||
];
|
||||
protected override readonly readRules = [
|
||||
new AlwaysAllowPrivacyPolicyRule<
|
||||
LocalMemoryTestEntityFields,
|
||||
string,
|
||||
ViewerContext,
|
||||
LocalMemoryTestEntity
|
||||
>(),
|
||||
];
|
||||
protected override readonly updateRules = [
|
||||
new AlwaysAllowPrivacyPolicyRule<
|
||||
LocalMemoryTestEntityFields,
|
||||
string,
|
||||
ViewerContext,
|
||||
LocalMemoryTestEntity
|
||||
>(),
|
||||
];
|
||||
protected override readonly deleteRules = [
|
||||
new AlwaysAllowPrivacyPolicyRule<
|
||||
LocalMemoryTestEntityFields,
|
||||
string,
|
||||
ViewerContext,
|
||||
LocalMemoryTestEntity
|
||||
>(),
|
||||
];
|
||||
}
|
||||
|
||||
export const localMemoryTestEntityConfiguration =
|
||||
new EntityConfiguration<LocalMemoryTestEntityFields>({
|
||||
idField: 'id',
|
||||
tableName: 'local_memory_test_entities',
|
||||
schema: {
|
||||
id: new UUIDField({
|
||||
columnName: 'id',
|
||||
cache: true,
|
||||
}),
|
||||
name: new StringField({
|
||||
columnName: 'name',
|
||||
cache: true,
|
||||
}),
|
||||
dateField: new DateField({
|
||||
columnName: 'date_field',
|
||||
}),
|
||||
},
|
||||
databaseAdapterFlavor: 'postgres',
|
||||
cacheAdapterFlavor: 'local-memory',
|
||||
});
|
||||
|
||||
const localMemoryTestEntityCompanionDefinition = new EntityCompanionDefinition({
|
||||
entityClass: LocalMemoryTestEntity,
|
||||
entityConfiguration: localMemoryTestEntityConfiguration,
|
||||
privacyPolicyClass: LocalMemoryTestEntityPrivacyPolicy,
|
||||
});
|
||||
-48
@@ -1,48 +0,0 @@
|
||||
import {
|
||||
NoOpEntityMetricsAdapter,
|
||||
IEntityMetricsAdapter,
|
||||
EntityCompanionProvider,
|
||||
StubQueryContextProvider,
|
||||
StubDatabaseAdapterProvider,
|
||||
} from '@expo/entity';
|
||||
|
||||
import { LocalMemoryCacheAdapterProvider } from '../LocalMemoryCacheAdapterProvider';
|
||||
|
||||
export const createLocalMemoryIntegrationTestEntityCompanionProvider = (
|
||||
localMemoryOptions: { maxSize?: number; ttlSeconds?: number } = {},
|
||||
metricsAdapter: IEntityMetricsAdapter = new NoOpEntityMetricsAdapter()
|
||||
): EntityCompanionProvider => {
|
||||
const localMemoryCacheAdapterProvider =
|
||||
localMemoryOptions.maxSize === 0 && localMemoryOptions.ttlSeconds === 0
|
||||
? LocalMemoryCacheAdapterProvider.getNoOpProvider()
|
||||
: LocalMemoryCacheAdapterProvider.getProvider(localMemoryOptions);
|
||||
return new EntityCompanionProvider(
|
||||
metricsAdapter,
|
||||
new Map([
|
||||
[
|
||||
'postgres',
|
||||
{
|
||||
adapterProvider: new StubDatabaseAdapterProvider(),
|
||||
queryContextProvider: StubQueryContextProvider,
|
||||
},
|
||||
],
|
||||
]),
|
||||
new Map([
|
||||
[
|
||||
'local-memory',
|
||||
{
|
||||
cacheAdapterProvider: localMemoryCacheAdapterProvider,
|
||||
},
|
||||
],
|
||||
])
|
||||
);
|
||||
};
|
||||
|
||||
export const createNoopLocalMemoryIntegrationTestEntityCompanionProvider = (
|
||||
metricsAdapter: IEntityMetricsAdapter = new NoOpEntityMetricsAdapter()
|
||||
): EntityCompanionProvider => {
|
||||
return createLocalMemoryIntegrationTestEntityCompanionProvider(
|
||||
{ maxSize: 0, ttlSeconds: 0 },
|
||||
metricsAdapter
|
||||
);
|
||||
};
|
||||
@@ -1,7 +0,0 @@
|
||||
{
|
||||
"extends": "../../tsconfig.json",
|
||||
"compilerOptions": {
|
||||
"outDir": "build",
|
||||
},
|
||||
"include": ["src"]
|
||||
}
|
||||
@@ -3,25 +3,6 @@
|
||||
All notable changes to this project will be documented in this file.
|
||||
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
|
||||
|
||||
# [0.24.0](https://github.com/expo/entity/compare/v0.23.0...v0.24.0) (2022-02-16)
|
||||
|
||||
### Chores
|
||||
|
||||
* Refactor cachers to use an abstract class and interface ([#157](https://github.com/expo/entity/pull/157))
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# [0.23.0](https://github.com/expo/entity/compare/v0.22.0...v0.23.0) (2022-02-09)
|
||||
|
||||
### Chores
|
||||
|
||||
* Move data transforming responsibilities to the CacheAdapter instead of the ReadThroughEntityCache. ([#153](https://github.com/expo/entity/pull/153))
|
||||
|
||||
|
||||
|
||||
|
||||
# [0.22.0](https://github.com/expo/entity/compare/v0.21.0...v0.22.0) (2022-02-04)
|
||||
|
||||
**Note:** Version bump only for package @expo/entity-cache-adapter-redis
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@expo/entity-cache-adapter-redis",
|
||||
"version": "0.24.0",
|
||||
"version": "0.22.0",
|
||||
"description": "Redis cache adapter for @expo/entity",
|
||||
"files": [
|
||||
"build",
|
||||
@@ -33,6 +33,6 @@
|
||||
"ioredis": "^4.27.3"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@expo/entity": "^0.24.0"
|
||||
"@expo/entity": "^0.22.0"
|
||||
}
|
||||
}
|
||||
@@ -1,14 +1,6 @@
|
||||
import {
|
||||
CacheLoadResult,
|
||||
CacheStatus,
|
||||
EntityConfiguration,
|
||||
transformCacheObjectToFields,
|
||||
transformFieldsToCacheObject,
|
||||
IEntityGenericCacher,
|
||||
} from '@expo/entity';
|
||||
import { CacheLoadResult, CacheStatus } from '@expo/entity';
|
||||
import { Redis } from 'ioredis';
|
||||
|
||||
import { redisTransformerMap } from './RedisCommon';
|
||||
import wrapNativeRedisCallAsync from './errors/wrapNativeRedisCallAsync';
|
||||
|
||||
// Sentinel value we store in Redis to negatively cache a database miss.
|
||||
@@ -34,15 +26,12 @@ export interface GenericRedisCacheContext {
|
||||
ttlSecondsNegative: number;
|
||||
}
|
||||
|
||||
export default class GenericRedisCacher<TFields> implements IEntityGenericCacher<TFields> {
|
||||
constructor(
|
||||
private readonly context: GenericRedisCacheContext,
|
||||
private readonly entityConfiguration: EntityConfiguration<TFields>
|
||||
) {}
|
||||
export default class GenericRedisCacher {
|
||||
constructor(private readonly context: GenericRedisCacheContext) {}
|
||||
|
||||
public async loadManyAsync(
|
||||
keys: readonly string[]
|
||||
): Promise<ReadonlyMap<string, CacheLoadResult<TFields>>> {
|
||||
): Promise<ReadonlyMap<string, CacheLoadResult>> {
|
||||
if (keys.length === 0) {
|
||||
return new Map();
|
||||
}
|
||||
@@ -51,7 +40,7 @@ export default class GenericRedisCacher<TFields> implements IEntityGenericCacher
|
||||
this.context.redisClient.mget(...keys)
|
||||
);
|
||||
|
||||
const results = new Map<string, CacheLoadResult<TFields>>();
|
||||
const results = new Map<string, CacheLoadResult>();
|
||||
for (let i = 0; i < keys.length; i++) {
|
||||
const key = keys[i]!;
|
||||
const redisResult = redisResults[i];
|
||||
@@ -63,11 +52,7 @@ export default class GenericRedisCacher<TFields> implements IEntityGenericCacher
|
||||
} else if (redisResult) {
|
||||
results.set(key, {
|
||||
status: CacheStatus.HIT,
|
||||
item: transformCacheObjectToFields(
|
||||
this.entityConfiguration,
|
||||
redisTransformerMap,
|
||||
JSON.parse(redisResult)
|
||||
),
|
||||
item: JSON.parse(redisResult),
|
||||
});
|
||||
} else {
|
||||
results.set(key, {
|
||||
@@ -78,7 +63,7 @@ export default class GenericRedisCacher<TFields> implements IEntityGenericCacher
|
||||
return results;
|
||||
}
|
||||
|
||||
public async cacheManyAsync(objectMap: ReadonlyMap<string, Readonly<TFields>>): Promise<void> {
|
||||
public async cacheManyAsync(objectMap: ReadonlyMap<string, object>): Promise<void> {
|
||||
if (objectMap.size === 0) {
|
||||
return;
|
||||
}
|
||||
@@ -87,9 +72,7 @@ export default class GenericRedisCacher<TFields> implements IEntityGenericCacher
|
||||
objectMap.forEach((object, key) => {
|
||||
redisTransaction = redisTransaction.set(
|
||||
key,
|
||||
JSON.stringify(
|
||||
transformFieldsToCacheObject(this.entityConfiguration, redisTransformerMap, object)
|
||||
),
|
||||
JSON.stringify(object),
|
||||
'EX',
|
||||
this.context.ttlSecondsPositive
|
||||
);
|
||||
@@ -97,7 +80,7 @@ export default class GenericRedisCacher<TFields> implements IEntityGenericCacher
|
||||
await wrapNativeRedisCallAsync(() => redisTransaction.exec());
|
||||
}
|
||||
|
||||
public async cacheDBMissesAsync(keys: readonly string[]): Promise<void> {
|
||||
public async cacheDBMissesAsync(keys: string[]): Promise<void> {
|
||||
if (keys.length === 0) {
|
||||
return;
|
||||
}
|
||||
@@ -114,7 +97,7 @@ export default class GenericRedisCacher<TFields> implements IEntityGenericCacher
|
||||
await wrapNativeRedisCallAsync(() => redisTransaction.exec());
|
||||
}
|
||||
|
||||
public async invalidateManyAsync(keys: readonly string[]): Promise<void> {
|
||||
public async invalidateManyAsync(keys: string[]): Promise<void> {
|
||||
if (keys.length === 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -1,8 +1,18 @@
|
||||
import { EntityCacheAdapter, EntityConfiguration, CacheLoadResult, mapKeys } from '@expo/entity';
|
||||
import {
|
||||
EntityCacheAdapter,
|
||||
EntityConfiguration,
|
||||
CacheLoadResult,
|
||||
FieldTransformerMap,
|
||||
mapKeys,
|
||||
transformCacheObjectToFields,
|
||||
CacheStatus,
|
||||
transformFieldsToCacheObject,
|
||||
} from '@expo/entity';
|
||||
import invariant from 'invariant';
|
||||
import { Redis } from 'ioredis';
|
||||
|
||||
import GenericRedisCacher from './GenericRedisCacher';
|
||||
import { redisTransformerMap } from './RedisCommon';
|
||||
|
||||
export interface RedisCacheAdapterContext {
|
||||
/**
|
||||
@@ -42,33 +52,51 @@ export interface RedisCacheAdapterContext {
|
||||
}
|
||||
|
||||
export default class RedisCacheAdapter<TFields> extends EntityCacheAdapter<TFields> {
|
||||
private readonly genericRedisCacher: GenericRedisCacher<TFields>;
|
||||
/**
|
||||
* Transformer definitions for field types. Used to modify values as they are read from or written to
|
||||
* the cache. Override in concrete subclasses to change transformation behavior.
|
||||
* If a field type is not present in the map, then fields of that type will not be transformed.
|
||||
*/
|
||||
private readonly redisFieldTransformer: FieldTransformerMap = redisTransformerMap;
|
||||
private readonly genericRedisCacher: GenericRedisCacher;
|
||||
constructor(
|
||||
entityConfiguration: EntityConfiguration<TFields>,
|
||||
private readonly context: RedisCacheAdapterContext
|
||||
) {
|
||||
super(entityConfiguration);
|
||||
|
||||
this.genericRedisCacher = new GenericRedisCacher(
|
||||
{
|
||||
redisClient: context.redisClient,
|
||||
ttlSecondsNegative: context.ttlSecondsNegative,
|
||||
ttlSecondsPositive: context.ttlSecondsPositive,
|
||||
},
|
||||
entityConfiguration
|
||||
);
|
||||
this.genericRedisCacher = new GenericRedisCacher({
|
||||
redisClient: context.redisClient,
|
||||
ttlSecondsNegative: context.ttlSecondsNegative,
|
||||
ttlSecondsPositive: context.ttlSecondsPositive,
|
||||
});
|
||||
}
|
||||
|
||||
public async loadManyAsync<N extends keyof TFields>(
|
||||
fieldName: N,
|
||||
fieldValues: readonly NonNullable<TFields[N]>[]
|
||||
): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>> {
|
||||
): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult>> {
|
||||
const redisCacheKeyToFieldValueMapping = new Map(
|
||||
fieldValues.map((fieldValue) => [this.makeCacheKey(fieldName, fieldValue), fieldValue])
|
||||
);
|
||||
const cacheResults = await this.genericRedisCacher.loadManyAsync(
|
||||
const rawCacheResults = await this.genericRedisCacher.loadManyAsync(
|
||||
Array.from(redisCacheKeyToFieldValueMapping.keys())
|
||||
);
|
||||
const cacheResults = new Map<string, CacheLoadResult>();
|
||||
for (const [redisCacheKey, rawCacheResult] of rawCacheResults) {
|
||||
if (rawCacheResult.status === CacheStatus.HIT) {
|
||||
cacheResults.set(redisCacheKey, {
|
||||
status: CacheStatus.HIT,
|
||||
item: transformCacheObjectToFields(
|
||||
this.entityConfiguration,
|
||||
this.redisFieldTransformer,
|
||||
rawCacheResult.item
|
||||
),
|
||||
});
|
||||
} else {
|
||||
cacheResults.set(redisCacheKey, rawCacheResult);
|
||||
}
|
||||
}
|
||||
|
||||
return mapKeys(cacheResults, (redisCacheKey) => {
|
||||
const fieldValue = redisCacheKeyToFieldValueMapping.get(redisCacheKey);
|
||||
@@ -83,10 +111,21 @@ export default class RedisCacheAdapter<TFields> extends EntityCacheAdapter<TFiel
|
||||
|
||||
public async cacheManyAsync<N extends keyof TFields>(
|
||||
fieldName: N,
|
||||
objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>
|
||||
objectMap: ReadonlyMap<NonNullable<TFields[N]>, object>
|
||||
): Promise<void> {
|
||||
const cacheObjectMap = new Map<NonNullable<TFields[N]>, object>();
|
||||
for (const [fieldValue, object] of objectMap) {
|
||||
cacheObjectMap.set(
|
||||
fieldValue,
|
||||
transformFieldsToCacheObject(
|
||||
this.entityConfiguration,
|
||||
this.redisFieldTransformer,
|
||||
object as Readonly<TFields>
|
||||
)
|
||||
);
|
||||
}
|
||||
await this.genericRedisCacher.cacheManyAsync(
|
||||
mapKeys(objectMap, (fieldValue) => this.makeCacheKey(fieldName, fieldValue))
|
||||
mapKeys(cacheObjectMap, (fieldValue) => this.makeCacheKey(fieldName, fieldValue))
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
-125
@@ -1,125 +0,0 @@
|
||||
import { CacheStatus, ViewerContext } from '@expo/entity';
|
||||
import Redis from 'ioredis';
|
||||
import { URL } from 'url';
|
||||
|
||||
import GenericRedisCacher from '../GenericRedisCacher';
|
||||
import { RedisCacheAdapterContext } from '../RedisCacheAdapter';
|
||||
import RedisTestEntity, {
|
||||
redisTestEntityConfiguration,
|
||||
RedisTestEntityFields,
|
||||
} from '../testfixtures/RedisTestEntity';
|
||||
import { createRedisIntegrationTestEntityCompanionProvider } from '../testfixtures/createRedisIntegrationTestEntityCompanionProvider';
|
||||
|
||||
class TestViewerContext extends ViewerContext {}
|
||||
|
||||
describe(GenericRedisCacher, () => {
|
||||
let redisCacheAdapterContext: RedisCacheAdapterContext;
|
||||
|
||||
beforeAll(() => {
|
||||
redisCacheAdapterContext = {
|
||||
redisClient: new Redis(new URL(process.env['REDIS_URL']!).toString()),
|
||||
makeKeyFn(...parts: string[]): string {
|
||||
const delimiter = ':';
|
||||
const escapedParts = parts.map((part) =>
|
||||
part.replace('\\', '\\\\').replace(delimiter, `\\${delimiter}`)
|
||||
);
|
||||
return escapedParts.join(delimiter);
|
||||
},
|
||||
cacheKeyPrefix: 'test-',
|
||||
cacheKeyVersion: 1,
|
||||
ttlSecondsPositive: 86400, // 1 day
|
||||
ttlSecondsNegative: 600, // 10 minutes
|
||||
};
|
||||
});
|
||||
|
||||
beforeEach(async () => {
|
||||
await redisCacheAdapterContext.redisClient.flushdb();
|
||||
});
|
||||
afterAll(async () => {
|
||||
redisCacheAdapterContext.redisClient.disconnect();
|
||||
});
|
||||
|
||||
it('has correct caching and loading behavior', async () => {
|
||||
const viewerContext = new TestViewerContext(
|
||||
createRedisIntegrationTestEntityCompanionProvider(redisCacheAdapterContext)
|
||||
);
|
||||
const genericRedisCacher = new GenericRedisCacher(
|
||||
{
|
||||
redisClient: redisCacheAdapterContext.redisClient,
|
||||
ttlSecondsNegative: redisCacheAdapterContext.ttlSecondsNegative,
|
||||
ttlSecondsPositive: redisCacheAdapterContext.ttlSecondsPositive,
|
||||
},
|
||||
redisTestEntityConfiguration
|
||||
);
|
||||
const date = new Date();
|
||||
const entity1Created = await RedisTestEntity.creator(viewerContext)
|
||||
.setField('name', 'blah')
|
||||
.setField('dateField', date)
|
||||
.enforceCreateAsync();
|
||||
const testKey = `test-id-key-${entity1Created.getID()}`;
|
||||
const objectMap = new Map<string, Readonly<RedisTestEntityFields>>([
|
||||
[testKey, entity1Created.getAllFields()],
|
||||
]);
|
||||
await genericRedisCacher.cacheManyAsync(objectMap);
|
||||
|
||||
const cachedJSON = await redisCacheAdapterContext.redisClient.get(testKey);
|
||||
const cachedValue = JSON.parse(cachedJSON!);
|
||||
expect(cachedValue).toMatchObject({
|
||||
id: entity1Created.getID(),
|
||||
dateField: date.toISOString(),
|
||||
});
|
||||
|
||||
const loadedObjectMap = await genericRedisCacher.loadManyAsync([testKey]);
|
||||
const cacheLoadResult = loadedObjectMap.get(testKey)!;
|
||||
expect(cacheLoadResult).toMatchObject({
|
||||
status: CacheStatus.HIT,
|
||||
item: entity1Created.getAllFields(),
|
||||
});
|
||||
expect(loadedObjectMap.size).toBe(1);
|
||||
});
|
||||
it('has correct negative caching behaviour', async () => {
|
||||
const genericRedisCacher = new GenericRedisCacher(
|
||||
{
|
||||
redisClient: redisCacheAdapterContext.redisClient,
|
||||
ttlSecondsNegative: redisCacheAdapterContext.ttlSecondsNegative,
|
||||
ttlSecondsPositive: redisCacheAdapterContext.ttlSecondsPositive,
|
||||
},
|
||||
redisTestEntityConfiguration
|
||||
);
|
||||
|
||||
const testKey = `test-id-key-non-existent-id`;
|
||||
await genericRedisCacher.cacheDBMissesAsync([testKey]);
|
||||
const loadedObjectMap = await genericRedisCacher.loadManyAsync([testKey]);
|
||||
const cacheLoadResult = loadedObjectMap.get(testKey)!;
|
||||
expect(cacheLoadResult.status).toBe(CacheStatus.NEGATIVE);
|
||||
});
|
||||
it('has correct invalidation behaviour', async () => {
|
||||
const viewerContext = new TestViewerContext(
|
||||
createRedisIntegrationTestEntityCompanionProvider(redisCacheAdapterContext)
|
||||
);
|
||||
const genericRedisCacher = new GenericRedisCacher(
|
||||
{
|
||||
redisClient: redisCacheAdapterContext.redisClient,
|
||||
ttlSecondsNegative: redisCacheAdapterContext.ttlSecondsNegative,
|
||||
ttlSecondsPositive: redisCacheAdapterContext.ttlSecondsPositive,
|
||||
},
|
||||
redisTestEntityConfiguration
|
||||
);
|
||||
const date = new Date();
|
||||
const entity1Created = await RedisTestEntity.creator(viewerContext)
|
||||
.setField('name', 'blah')
|
||||
.setField('dateField', date)
|
||||
.enforceCreateAsync();
|
||||
const testKey = `test-id-key-${entity1Created.getID()}`;
|
||||
const objectMap = new Map<string, Readonly<RedisTestEntityFields>>([
|
||||
[testKey, entity1Created.getAllFields()],
|
||||
]);
|
||||
await genericRedisCacher.cacheManyAsync(objectMap);
|
||||
|
||||
await genericRedisCacher.invalidateManyAsync([testKey]);
|
||||
|
||||
const loadedObjectMap = await genericRedisCacher.loadManyAsync([testKey]);
|
||||
const cacheLoadResult = loadedObjectMap.get(testKey)!;
|
||||
expect(cacheLoadResult.status).toBe(CacheStatus.MISS);
|
||||
});
|
||||
});
|
||||
@@ -1,4 +1,4 @@
|
||||
import { CacheStatus, UUIDField, EntityConfiguration } from '@expo/entity';
|
||||
import { CacheStatus, UUIDField, EntityConfiguration, DateField } from '@expo/entity';
|
||||
import { Redis, Pipeline } from 'ioredis';
|
||||
import { mock, when, instance, anything, verify } from 'ts-mockito';
|
||||
|
||||
@@ -6,6 +6,7 @@ import RedisCacheAdapter from '../RedisCacheAdapter';
|
||||
|
||||
type BlahFields = {
|
||||
id: string;
|
||||
date: Date | null;
|
||||
};
|
||||
|
||||
const entityConfiguration = new EntityConfiguration<BlahFields>({
|
||||
@@ -13,6 +14,7 @@ const entityConfiguration = new EntityConfiguration<BlahFields>({
|
||||
tableName: 'blah',
|
||||
schema: {
|
||||
id: new UUIDField({ columnName: 'id', cache: true }),
|
||||
date: new DateField({ columnName: 'date' }),
|
||||
},
|
||||
databaseAdapterFlavor: 'postgres',
|
||||
cacheAdapterFlavor: 'redis',
|
||||
@@ -62,6 +64,40 @@ describe(RedisCacheAdapter, () => {
|
||||
const results = await cacheAdapter.loadManyAsync('id', []);
|
||||
expect(results).toEqual(new Map());
|
||||
});
|
||||
|
||||
it('transforms a cache object to an Entity object', async () => {
|
||||
const redisResults = new Map();
|
||||
|
||||
const mockRedisClient = mock<Redis>();
|
||||
|
||||
// need to have one anything() for each element of spread, in this case 1
|
||||
when(mockRedisClient.mget(anything())).thenCall(async (...keys) =>
|
||||
keys.map((k) => redisResults.get(k) ?? null)
|
||||
);
|
||||
|
||||
const cacheAdapter = new RedisCacheAdapter(entityConfiguration, {
|
||||
redisClient: instance(mockRedisClient),
|
||||
makeKeyFn: (...parts) => parts.join(':'),
|
||||
cacheKeyVersion: 1,
|
||||
cacheKeyPrefix: 'hello-',
|
||||
ttlSecondsPositive: 1,
|
||||
ttlSecondsNegative: 2,
|
||||
});
|
||||
|
||||
const date = new Date();
|
||||
redisResults.set(
|
||||
cacheAdapter['makeCacheKey']('id', 'wat'),
|
||||
JSON.stringify({ id: 'wat', date: date.toISOString() })
|
||||
);
|
||||
|
||||
const results = await cacheAdapter.loadManyAsync('id', ['wat']);
|
||||
|
||||
expect(results.get('wat')).toMatchObject({
|
||||
status: CacheStatus.HIT,
|
||||
item: { id: 'wat', date },
|
||||
});
|
||||
expect(results.size).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('cacheManyAsync', () => {
|
||||
@@ -98,6 +134,41 @@ describe(RedisCacheAdapter, () => {
|
||||
ttl: 1,
|
||||
});
|
||||
});
|
||||
|
||||
it('transforms an Entity object to a cache object', async () => {
|
||||
const redisResults = new Map();
|
||||
|
||||
const mockPipeline = mock<Pipeline>();
|
||||
when(mockPipeline.set(anything(), anything(), anything(), anything())).thenCall(
|
||||
(key, value, code, ttl) => {
|
||||
redisResults.set(key, { value, code, ttl });
|
||||
return pipeline;
|
||||
}
|
||||
);
|
||||
when(mockPipeline.exec()).thenResolve({} as any);
|
||||
const pipeline = instance(mockPipeline);
|
||||
|
||||
const mockRedisClient = mock<Redis>();
|
||||
when(mockRedisClient.multi()).thenReturn(pipeline);
|
||||
|
||||
const cacheAdapter = new RedisCacheAdapter(entityConfiguration, {
|
||||
redisClient: instance(mockRedisClient),
|
||||
makeKeyFn: (...parts) => parts.join(':'),
|
||||
cacheKeyVersion: 1,
|
||||
cacheKeyPrefix: 'hello-',
|
||||
ttlSecondsPositive: 1,
|
||||
ttlSecondsNegative: 2,
|
||||
});
|
||||
const date = new Date();
|
||||
await cacheAdapter.cacheManyAsync('id', new Map([['wat', { id: 'wat', date }]]));
|
||||
|
||||
const cacheKey = cacheAdapter['makeCacheKey']('id', 'wat');
|
||||
expect(redisResults.get(cacheKey)).toMatchObject({
|
||||
value: JSON.stringify({ id: 'wat', date: date.toISOString() }),
|
||||
code: 'EX',
|
||||
ttl: 1,
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('cacheDBMissesAsync', () => {
|
||||
|
||||
@@ -3,22 +3,6 @@
|
||||
All notable changes to this project will be documented in this file.
|
||||
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
|
||||
|
||||
# [0.24.0](https://github.com/expo/entity/compare/v0.23.0...v0.24.0) (2022-02-16)
|
||||
|
||||
**Note:** Version bump only for package @expo/entity-database-adapter-knex
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# [0.23.0](https://github.com/expo/entity/compare/v0.22.0...v0.23.0) (2022-02-09)
|
||||
|
||||
**Note:** Version bump only for package @expo/entity-database-adapter-knex
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# [0.22.0](https://github.com/expo/entity/compare/v0.21.0...v0.22.0) (2022-02-04)
|
||||
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@expo/entity-database-adapter-knex",
|
||||
"version": "0.24.0",
|
||||
"version": "0.22.0",
|
||||
"description": "Knex database adapter for @expo/entity",
|
||||
"files": [
|
||||
"build",
|
||||
@@ -33,7 +33,7 @@
|
||||
"knex": "^1.0.2"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@expo/entity": "^0.24.0",
|
||||
"@expo/entity": "^0.22.0",
|
||||
"pg": "^8.7.1"
|
||||
}
|
||||
}
|
||||
@@ -3,22 +3,6 @@
|
||||
All notable changes to this project will be documented in this file.
|
||||
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
|
||||
|
||||
# [0.24.0](https://github.com/expo/entity/compare/v0.23.0...v0.24.0) (2022-02-16)
|
||||
|
||||
**Note:** Version bump only for package @expo/entity-example
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# [0.23.0](https://github.com/expo/entity/compare/v0.22.0...v0.23.0) (2022-02-09)
|
||||
|
||||
**Note:** Version bump only for package @expo/entity-example
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# [0.22.0](https://github.com/expo/entity/compare/v0.21.0...v0.22.0) (2022-02-04)
|
||||
|
||||
**Note:** Version bump only for package @expo/entity-example
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"name": "@expo/entity-example",
|
||||
"private": true,
|
||||
"version": "0.24.0",
|
||||
"version": "0.22.0",
|
||||
"description": "An example integration of the @expo/entity framework",
|
||||
"scripts": {
|
||||
"tsc": "tsc",
|
||||
@@ -23,7 +23,7 @@
|
||||
"author": "Expo",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@expo/entity": "^0.24.0",
|
||||
"@expo/entity": "^0.22.0",
|
||||
"apollo-server-koa": "^2.16.1",
|
||||
"graphql": "^15.3.0",
|
||||
"koa": "^2.13.0",
|
||||
|
||||
@@ -3,22 +3,6 @@
|
||||
All notable changes to this project will be documented in this file.
|
||||
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
|
||||
|
||||
# [0.24.0](https://github.com/expo/entity/compare/v0.23.0...v0.24.0) (2022-02-16)
|
||||
|
||||
**Note:** Version bump only for package @expo/entity-full-integration-tests
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# [0.23.0](https://github.com/expo/entity/compare/v0.22.0...v0.23.0) (2022-02-09)
|
||||
|
||||
**Note:** Version bump only for package @expo/entity-full-integration-tests
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# [0.22.0](https://github.com/expo/entity/compare/v0.21.0...v0.22.0) (2022-02-04)
|
||||
|
||||
**Note:** Version bump only for package @expo/entity-full-integration-tests
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"name": "@expo/entity-full-integration-tests",
|
||||
"private": true,
|
||||
"version": "0.24.0",
|
||||
"version": "0.22.0",
|
||||
"description": "Full redis and knex integration tests for the entity framework",
|
||||
"scripts": {
|
||||
"tsc": "tsc",
|
||||
@@ -27,8 +27,8 @@
|
||||
"@expo/entity-database-adapter-knex": "*"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@expo/entity": "^0.24.0",
|
||||
"@expo/entity-cache-adapter-redis": "^0.24.0",
|
||||
"@expo/entity-database-adapter-knex": "^0.24.0"
|
||||
"@expo/entity": "^0.22.0",
|
||||
"@expo/entity-cache-adapter-redis": "^0.22.0",
|
||||
"@expo/entity-database-adapter-knex": "^0.22.0"
|
||||
}
|
||||
}
|
||||
@@ -3,22 +3,6 @@
|
||||
All notable changes to this project will be documented in this file.
|
||||
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
|
||||
|
||||
# [0.24.0](https://github.com/expo/entity/compare/v0.23.0...v0.24.0) (2022-02-16)
|
||||
|
||||
**Note:** Version bump only for package @expo/entity-ip-address-field
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# [0.23.0](https://github.com/expo/entity/compare/v0.22.0...v0.23.0) (2022-02-09)
|
||||
|
||||
**Note:** Version bump only for package @expo/entity-ip-address-field
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# [0.22.0](https://github.com/expo/entity/compare/v0.21.0...v0.22.0) (2022-02-04)
|
||||
|
||||
**Note:** Version bump only for package @expo/entity-ip-address-field
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@expo/entity-ip-address-field",
|
||||
"version": "0.24.0",
|
||||
"version": "0.22.0",
|
||||
"description": "IP address EntityField definitions for @expo/entity",
|
||||
"files": [
|
||||
"build",
|
||||
@@ -28,7 +28,7 @@
|
||||
"ip-address": "^8.1.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@expo/entity": "^0.24.0",
|
||||
"@expo/entity": "^0.22.0",
|
||||
"@types/jsbn": "^1.2.29"
|
||||
},
|
||||
"peerDependencies": {
|
||||
|
||||
@@ -3,24 +3,6 @@
|
||||
All notable changes to this project will be documented in this file.
|
||||
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
|
||||
|
||||
# [0.24.0](https://github.com/expo/entity/compare/v0.23.0...v0.24.0) (2022-02-16)
|
||||
|
||||
### Chores
|
||||
|
||||
* Refactor cachers to use an abstract class and interface ([#157](https://github.com/expo/entity/pull/157))
|
||||
|
||||
|
||||
|
||||
|
||||
# [0.23.0](https://github.com/expo/entity/compare/v0.22.0...v0.23.0) (2022-02-09)
|
||||
|
||||
### Chores
|
||||
|
||||
* Move data transforming responsibilities to the CacheAdapter instead of the RedisSecondaryEntityCache. ([#153](https://github.com/expo/entity/pull/153))
|
||||
|
||||
|
||||
|
||||
|
||||
# [0.22.0](https://github.com/expo/entity/compare/v0.21.0...v0.22.0) (2022-02-04)
|
||||
|
||||
**Note:** Version bump only for package @expo/entity-secondary-cache-redis
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@expo/entity-secondary-cache-redis",
|
||||
"version": "0.24.0",
|
||||
"version": "0.22.0",
|
||||
"description": "Redis secondary cache for @expo/entity",
|
||||
"files": [
|
||||
"build",
|
||||
@@ -34,8 +34,8 @@
|
||||
"ioredis": "^4.17.3"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@expo/entity": "^0.24.0",
|
||||
"@expo/entity-cache-adapter-redis": "^0.24.0",
|
||||
"@expo/entity": "^0.22.0",
|
||||
"@expo/entity-cache-adapter-redis": "^0.22.0",
|
||||
"nullthrows": "^1.1.1"
|
||||
}
|
||||
}
|
||||
@@ -1,20 +1,136 @@
|
||||
import { EntityConfiguration, GenericSecondaryEntityCache } from '@expo/entity';
|
||||
import { GenericRedisCacheContext, GenericRedisCacher } from '@expo/entity-cache-adapter-redis';
|
||||
import {
|
||||
CacheStatus,
|
||||
EntityConfiguration,
|
||||
filterMap,
|
||||
ISecondaryEntityCache,
|
||||
transformCacheObjectToFields,
|
||||
transformFieldsToCacheObject,
|
||||
zipToMap,
|
||||
} from '@expo/entity';
|
||||
import {
|
||||
GenericRedisCacheContext,
|
||||
GenericRedisCacher,
|
||||
redisTransformerMap,
|
||||
} from '@expo/entity-cache-adapter-redis';
|
||||
import invariant from 'invariant';
|
||||
|
||||
/**
|
||||
* A custom secondary read-through entity cache is a way to add a custom second layer of caching for a particular
|
||||
* single entity load. One common way this may be used is to add a second layer of caching in a hot path that makes
|
||||
* a call to {@link EntityLoader.loadManyByFieldEqualityConjunctionAsync} is guaranteed to return at most one entity.
|
||||
*/
|
||||
export default class RedisSecondaryEntityCache<
|
||||
TFields,
|
||||
TLoadParams
|
||||
> extends GenericSecondaryEntityCache<TFields, TLoadParams> {
|
||||
export default class RedisSecondaryEntityCache<TFields, TLoadParams>
|
||||
implements ISecondaryEntityCache<TFields, TLoadParams>
|
||||
{
|
||||
private readonly genericRedisCacher: GenericRedisCacher;
|
||||
|
||||
constructor(
|
||||
entityConfiguration: EntityConfiguration<TFields>,
|
||||
private readonly entityConfiguration: EntityConfiguration<TFields>,
|
||||
genericRedisCacheContext: GenericRedisCacheContext,
|
||||
constructRedisKey: (params: Readonly<TLoadParams>) => string
|
||||
private readonly constructRedisKey: (params: Readonly<TLoadParams>) => string
|
||||
) {
|
||||
super(new GenericRedisCacher(genericRedisCacheContext, entityConfiguration), constructRedisKey);
|
||||
this.genericRedisCacher = new GenericRedisCacher(genericRedisCacheContext);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read-through cache function. Steps:
|
||||
*
|
||||
* 1. Check for cached objects
|
||||
* 2. Query the fetcher for loadParams not in the cache
|
||||
* 3. Cache the results from the fetcher
|
||||
* 4. Negatively cache anything missing from the fetcher
|
||||
* 5. Return the full set of data for the query.
|
||||
*
|
||||
* @param loadParamsArray - array of loadParams to load from the cache
|
||||
* @param fetcher - closure used to provide underlying data source objects for loadParams
|
||||
* @returns map from loadParams to the entity field object
|
||||
*/
|
||||
public async loadManyThroughAsync(
|
||||
loadParamsArray: readonly Readonly<TLoadParams>[],
|
||||
fetcher: (
|
||||
fetcherLoadParamsArray: readonly Readonly<TLoadParams>[]
|
||||
) => Promise<ReadonlyMap<Readonly<TLoadParams>, Readonly<TFields> | null>>
|
||||
): Promise<ReadonlyMap<Readonly<TLoadParams>, Readonly<TFields> | null>> {
|
||||
const redisKeys = loadParamsArray.map(this.constructRedisKey);
|
||||
const redisKeyToLoadParamsMap = zipToMap(redisKeys, loadParamsArray);
|
||||
|
||||
const cacheLoadResults = await this.genericRedisCacher.loadManyAsync(redisKeys);
|
||||
|
||||
invariant(
|
||||
cacheLoadResults.size === loadParamsArray.length,
|
||||
`${this.constructor.name} loadMany should return a result for each key`
|
||||
);
|
||||
|
||||
const redisKeysToFetch = Array.from(
|
||||
filterMap(
|
||||
cacheLoadResults,
|
||||
(cacheLoadResult) => cacheLoadResult.status === CacheStatus.MISS
|
||||
).keys()
|
||||
);
|
||||
|
||||
// put transformed cache hits in result map
|
||||
const results: Map<Readonly<TLoadParams>, Readonly<TFields> | null> = new Map();
|
||||
cacheLoadResults.forEach((cacheLoadResult, redisKey) => {
|
||||
if (cacheLoadResult.status === CacheStatus.HIT) {
|
||||
const loadParams = redisKeyToLoadParamsMap.get(redisKey);
|
||||
invariant(loadParams !== undefined, 'load params should be in redis key map');
|
||||
results.set(
|
||||
loadParams,
|
||||
transformCacheObjectToFields(
|
||||
this.entityConfiguration,
|
||||
redisTransformerMap,
|
||||
cacheLoadResult.item
|
||||
)
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
// fetch any misses from DB, add DB objects to results, cache DB results, inform cache of any missing DB results
|
||||
if (redisKeysToFetch.length > 0) {
|
||||
const loadParamsToFetch = redisKeysToFetch.map((redisKey) => {
|
||||
const loadParams = redisKeyToLoadParamsMap.get(redisKey);
|
||||
invariant(loadParams !== undefined, 'load params should be in redis key map');
|
||||
return loadParams;
|
||||
});
|
||||
const fetchResults = await fetcher(loadParamsToFetch);
|
||||
|
||||
const fetchMisses = loadParamsToFetch.filter((loadParams) => {
|
||||
// all values of fetchResults should be field objects or undefined
|
||||
return !fetchResults.get(loadParams);
|
||||
});
|
||||
|
||||
for (const fetchMiss of fetchMisses) {
|
||||
results.set(fetchMiss, null);
|
||||
}
|
||||
|
||||
const objectsToCache: Map<string, object> = new Map();
|
||||
for (const [loadParams, object] of fetchResults.entries()) {
|
||||
if (object) {
|
||||
objectsToCache.set(
|
||||
this.constructRedisKey(loadParams),
|
||||
transformFieldsToCacheObject(this.entityConfiguration, redisTransformerMap, object)
|
||||
);
|
||||
results.set(loadParams, object);
|
||||
}
|
||||
}
|
||||
|
||||
await Promise.all([
|
||||
this.genericRedisCacher.cacheManyAsync(objectsToCache),
|
||||
this.genericRedisCacher.cacheDBMissesAsync(fetchMisses.map(this.constructRedisKey)),
|
||||
]);
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
/**
|
||||
* Invalidate the cache for objects cached by constructRedisKey(loadParams).
|
||||
*
|
||||
* @param loadParamsArray - load params to invalidate
|
||||
*/
|
||||
public async invalidateManyAsync(
|
||||
loadParamsArray: readonly Readonly<TLoadParams>[]
|
||||
): Promise<void> {
|
||||
await this.genericRedisCacher.invalidateManyAsync(loadParamsArray.map(this.constructRedisKey));
|
||||
}
|
||||
}
|
||||
@@ -3,27 +3,6 @@
|
||||
All notable changes to this project will be documented in this file.
|
||||
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
|
||||
|
||||
# [0.24.0](https://github.com/expo/entity/compare/v0.23.0...v0.24.0) (2022-02-16)
|
||||
|
||||
**Note:** Version bump only for package @expo/entity
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
### Chores
|
||||
|
||||
* Refactor cachers to use an abstract class and interface ([#157](https://github.com/expo/entity/pull/157))
|
||||
|
||||
# [0.23.0](https://github.com/expo/entity/compare/v0.22.0...v0.23.0) (2022-02-09)
|
||||
|
||||
### Breaking changes
|
||||
|
||||
* Move data transforming responsibilities to the CacheAdapter instead of the ReadThroughEntityCache. Affects any classes extending the EntityCacheAdapter and relying on the transformation behavior of the ReadThroughEntityCache. ([#153](https://github.com/expo/entity/pull/153))
|
||||
|
||||
|
||||
|
||||
|
||||
# [0.22.0](https://github.com/expo/entity/compare/v0.21.0...v0.22.0) (2022-02-04)
|
||||
|
||||
**Note:** Version bump only for package @expo/entity
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@expo/entity",
|
||||
"version": "0.24.0",
|
||||
"version": "0.22.0",
|
||||
"description": "A privacy-first data model",
|
||||
"files": [
|
||||
"build",
|
||||
|
||||
@@ -17,7 +17,7 @@ export default abstract class EntityCacheAdapter<TFields> {
|
||||
public abstract loadManyAsync<N extends keyof TFields>(
|
||||
fieldName: N,
|
||||
fieldValues: readonly NonNullable<TFields[N]>[]
|
||||
): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>>;
|
||||
): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult>>;
|
||||
|
||||
/**
|
||||
* Cache many objects fetched from the DB.
|
||||
@@ -26,7 +26,7 @@ export default abstract class EntityCacheAdapter<TFields> {
|
||||
*/
|
||||
public abstract cacheManyAsync<N extends keyof TFields>(
|
||||
fieldName: N,
|
||||
objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>
|
||||
objectMap: ReadonlyMap<NonNullable<TFields[N]>, object>
|
||||
): Promise<void>;
|
||||
|
||||
/**
|
||||
|
||||
@@ -28,9 +28,6 @@ export enum EntityEdgeDeletionBehavior {
|
||||
SET_NULL,
|
||||
}
|
||||
|
||||
/**
|
||||
* Defines an association between entities. An association is primarily used to define cascading deletion behavior.
|
||||
*/
|
||||
export interface EntityAssociationDefinition<
|
||||
TViewerContext extends ViewerContext,
|
||||
TAssociatedFields,
|
||||
@@ -86,10 +83,6 @@ export interface EntityAssociationDefinition<
|
||||
edgeDeletionBehavior?: EntityEdgeDeletionBehavior;
|
||||
}
|
||||
|
||||
/**
|
||||
* Definition for a field referencing a column in the underlying database. Specifies things like
|
||||
* cache behavior and associations, and handles input validation.
|
||||
*/
|
||||
export abstract class EntityFieldDefinition<T> {
|
||||
readonly columnName: string;
|
||||
readonly cache: boolean;
|
||||
@@ -100,7 +93,6 @@ export abstract class EntityFieldDefinition<T> {
|
||||
* @param cache - Whether or not to cache loaded instances of the entity by this field. The column name is
|
||||
* used to derive a cache key for the cache entry. If true, this column must be able uniquely
|
||||
* identify the entity.
|
||||
* @param association - Defines the association behavior for an entity that this column references.
|
||||
*/
|
||||
constructor({
|
||||
columnName,
|
||||
|
||||
@@ -2,104 +2,59 @@ import { validate as validateUUID } from 'uuid';
|
||||
|
||||
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';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@link EntityFieldDefinition} for a column with a JS string type.
|
||||
* Enforces that the string is a valid UUID.
|
||||
*/
|
||||
export class UUIDField extends StringField {
|
||||
protected override validateInputValueInternal(value: string): boolean {
|
||||
return validateUUID(value);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@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;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@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';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@link EntityFieldDefinition} for a column with a JS number type.
|
||||
* 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);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@link EntityFieldDefinition} for a column with a JS number type.
|
||||
* 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';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@link EntityFieldDefinition} for a column with a JS string array type.
|
||||
* 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');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@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);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@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';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@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);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@link EntityFieldDefinition} for a column that may be a JS JSON array type.
|
||||
* Does not do any validation.
|
||||
*/
|
||||
export class MaybeJSONArrayField extends EntityFieldDefinition<any | any[]> {
|
||||
protected validateInputValueInternal(_value: any): boolean {
|
||||
return true;
|
||||
|
||||
@@ -1,98 +0,0 @@
|
||||
import invariant from 'invariant';
|
||||
|
||||
import { ISecondaryEntityCache } from './EntitySecondaryCacheLoader';
|
||||
import IEntityGenericCacher from './IEntityGenericCacher';
|
||||
import { CacheStatus } from './internal/ReadThroughEntityCache';
|
||||
import { filterMap, zipToMap } from './utils/collections/maps';
|
||||
|
||||
/**
|
||||
* A custom secondary read-through entity cache is a way to add a custom second layer of caching for a particular
|
||||
* single entity load. One common way this may be used is to add a second layer of caching in a hot path that makes
|
||||
* a call to {@link EntityLoader.loadManyByFieldEqualityConjunctionAsync} is guaranteed to return at most one entity.
|
||||
*/
|
||||
export default abstract class GenericSecondaryEntityCache<TFields, TLoadParams>
|
||||
implements ISecondaryEntityCache<TFields, TLoadParams>
|
||||
{
|
||||
constructor(
|
||||
protected readonly cacher: IEntityGenericCacher<TFields>,
|
||||
protected readonly constructCacheKey: (params: Readonly<TLoadParams>) => string
|
||||
) {}
|
||||
|
||||
public async loadManyThroughAsync(
|
||||
loadParamsArray: readonly Readonly<TLoadParams>[],
|
||||
fetcher: (
|
||||
fetcherLoadParamsArray: readonly Readonly<TLoadParams>[]
|
||||
) => Promise<ReadonlyMap<Readonly<TLoadParams>, Readonly<TFields> | null>>
|
||||
): Promise<ReadonlyMap<Readonly<TLoadParams>, Readonly<TFields> | null>> {
|
||||
const cacheKeys = loadParamsArray.map(this.constructCacheKey);
|
||||
const cacheKeyToLoadParamsMap = zipToMap(cacheKeys, loadParamsArray);
|
||||
|
||||
const cacheLoadResults = await this.cacher.loadManyAsync(cacheKeys);
|
||||
|
||||
invariant(
|
||||
cacheLoadResults.size === loadParamsArray.length,
|
||||
`${this.constructor.name} loadMany should return a result for each key`
|
||||
);
|
||||
|
||||
const cacheKeysToFetch = Array.from(
|
||||
filterMap(
|
||||
cacheLoadResults,
|
||||
(cacheLoadResult) => cacheLoadResult.status === CacheStatus.MISS
|
||||
).keys()
|
||||
);
|
||||
|
||||
// put cache hits in result map
|
||||
const results: Map<Readonly<TLoadParams>, Readonly<TFields> | null> = new Map();
|
||||
cacheLoadResults.forEach((cacheLoadResult, cacheKey) => {
|
||||
if (cacheLoadResult.status === CacheStatus.HIT) {
|
||||
const loadParams = cacheKeyToLoadParamsMap.get(cacheKey);
|
||||
invariant(loadParams !== undefined, 'load params should be in cache key map');
|
||||
results.set(loadParams, cacheLoadResult.item);
|
||||
}
|
||||
});
|
||||
|
||||
// fetch any misses from DB, add DB objects to results, cache DB results, inform cache of any missing DB results
|
||||
if (cacheKeysToFetch.length > 0) {
|
||||
const loadParamsToFetch = cacheKeysToFetch.map((cacheKey) => {
|
||||
const loadParams = cacheKeyToLoadParamsMap.get(cacheKey);
|
||||
invariant(loadParams !== undefined, 'load params should be in cache key map');
|
||||
return loadParams;
|
||||
});
|
||||
const fetchResults = await fetcher(loadParamsToFetch);
|
||||
|
||||
const fetchMisses = loadParamsToFetch.filter((loadParams) => {
|
||||
// all values of fetchResults should be field objects or undefined
|
||||
return !fetchResults.get(loadParams);
|
||||
});
|
||||
|
||||
for (const fetchMiss of fetchMisses) {
|
||||
results.set(fetchMiss, null);
|
||||
}
|
||||
|
||||
const objectsToCache: Map<string, Readonly<TFields>> = new Map();
|
||||
for (const [loadParams, object] of fetchResults.entries()) {
|
||||
if (object) {
|
||||
objectsToCache.set(this.constructCacheKey(loadParams), object);
|
||||
results.set(loadParams, object);
|
||||
}
|
||||
}
|
||||
|
||||
await Promise.all([
|
||||
this.cacher.cacheManyAsync(objectsToCache),
|
||||
this.cacher.cacheDBMissesAsync(fetchMisses.map(this.constructCacheKey)),
|
||||
]);
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
/**
|
||||
* Invalidate the cache for objects cached by constructCacheKey(loadParams).
|
||||
*
|
||||
* @param loadParamsArray - load params to invalidate
|
||||
*/
|
||||
public invalidateManyAsync(loadParamsArray: readonly Readonly<TLoadParams>[]): Promise<void> {
|
||||
const cacheKeys = loadParamsArray.map(this.constructCacheKey);
|
||||
return this.cacher.invalidateManyAsync(cacheKeys);
|
||||
}
|
||||
}
|
||||
@@ -1,15 +0,0 @@
|
||||
import { CacheLoadResult } from './internal/ReadThroughEntityCache';
|
||||
|
||||
/**
|
||||
* A cacher stores and loads key-value pairs. It also supports negative caching - it stores the absence
|
||||
* of keys that don't exist in the backing datastore.
|
||||
*/
|
||||
export default interface IEntityGenericCacher<TFields> {
|
||||
loadManyAsync(keys: readonly string[]): Promise<ReadonlyMap<string, CacheLoadResult<TFields>>>;
|
||||
|
||||
cacheManyAsync(objectMap: ReadonlyMap<string, Readonly<TFields>>): Promise<void>;
|
||||
|
||||
cacheDBMissesAsync(keys: readonly string[]): Promise<void>;
|
||||
|
||||
invalidateManyAsync(keys: readonly string[]): Promise<void>;
|
||||
}
|
||||
@@ -4,7 +4,6 @@
|
||||
* @module @expo/entity
|
||||
*/
|
||||
|
||||
export { default as GenericSecondaryEntityCache } from './GenericSecondaryEntityCache';
|
||||
export { default as EnforcingEntityLoader } from './EnforcingEntityLoader';
|
||||
export { default as Entity } from './Entity';
|
||||
export * from './Entity';
|
||||
@@ -44,7 +43,6 @@ export * from './EntityQueryContext';
|
||||
export { default as IEntityCacheAdapterProvider } from './IEntityCacheAdapterProvider';
|
||||
export { default as IEntityDatabaseAdapterProvider } from './IEntityDatabaseAdapterProvider';
|
||||
export { default as EntityQueryContextProvider } from './EntityQueryContextProvider';
|
||||
export { default as IEntityGenericCacher } from './IEntityGenericCacher';
|
||||
export { default as ReadonlyEntity } from './ReadonlyEntity';
|
||||
export { default as ViewerContext } from './ViewerContext';
|
||||
export { default as ViewerScopedEntityCompanion } from './ViewerScopedEntityCompanion';
|
||||
|
||||
@@ -10,10 +10,10 @@ export enum CacheStatus {
|
||||
NEGATIVE,
|
||||
}
|
||||
|
||||
export type CacheLoadResult<TFields> =
|
||||
export type CacheLoadResult =
|
||||
| {
|
||||
status: CacheStatus.HIT;
|
||||
item: Readonly<TFields>;
|
||||
item: Readonly<object>;
|
||||
}
|
||||
| {
|
||||
status: CacheStatus.MISS;
|
||||
@@ -82,7 +82,7 @@ export default class ReadThroughEntityCache<TFields> {
|
||||
const results: Map<NonNullable<TFields[N]>, readonly Readonly<TFields>[]> = new Map();
|
||||
cacheLoadResults.forEach((cacheLoadResult, fieldValue) => {
|
||||
if (cacheLoadResult.status === CacheStatus.HIT) {
|
||||
results.set(fieldValue, [cacheLoadResult.item]);
|
||||
results.set(fieldValue, [cacheLoadResult.item as Readonly<TFields>]);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -95,7 +95,7 @@ export default class ReadThroughEntityCache<TFields> {
|
||||
return !objectsFromFulfillerForFv || objectsFromFulfillerForFv.length === 0;
|
||||
});
|
||||
|
||||
const objectsToCache: Map<NonNullable<TFields[N]>, Readonly<TFields>> = new Map();
|
||||
const objectsToCache: Map<NonNullable<TFields[N]>, object> = new Map();
|
||||
for (const [fieldValue, objects] of dbFetchResults.entries()) {
|
||||
if (objects.length > 1) {
|
||||
// multiple objects received for what was supposed to be a unique query, don't add to return map nor cache
|
||||
|
||||
@@ -3,6 +3,7 @@ import invariant from 'invariant';
|
||||
import EntityCacheAdapter from '../../EntityCacheAdapter';
|
||||
import EntityConfiguration from '../../EntityConfiguration';
|
||||
import IEntityCacheAdapterProvider from '../../IEntityCacheAdapterProvider';
|
||||
import { FieldTransformerMap } from '../../internal/EntityFieldTransformationUtils';
|
||||
import { CacheStatus, CacheLoadResult } from '../../internal/ReadThroughEntityCache';
|
||||
|
||||
export class NoCacheStubCacheAdapterProvider implements IEntityCacheAdapterProvider {
|
||||
@@ -14,11 +15,15 @@ export class NoCacheStubCacheAdapterProvider implements IEntityCacheAdapterProvi
|
||||
}
|
||||
|
||||
export class NoCacheStubCacheAdapter<TFields> extends EntityCacheAdapter<TFields> {
|
||||
public getFieldTransformerMap(): FieldTransformerMap {
|
||||
return new Map();
|
||||
}
|
||||
|
||||
public async loadManyAsync<N extends keyof TFields>(
|
||||
_fieldName: N,
|
||||
fieldValues: readonly NonNullable<TFields[N]>[]
|
||||
): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>> {
|
||||
return fieldValues.reduce((acc: Map<NonNullable<TFields[N]>, CacheLoadResult<TFields>>, v) => {
|
||||
): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult>> {
|
||||
return fieldValues.reduce((acc: Map<NonNullable<TFields[N]>, CacheLoadResult>, v) => {
|
||||
acc.set(v, {
|
||||
status: CacheStatus.MISS,
|
||||
});
|
||||
@@ -28,7 +33,7 @@ export class NoCacheStubCacheAdapter<TFields> extends EntityCacheAdapter<TFields
|
||||
|
||||
public async cacheManyAsync<N extends keyof TFields>(
|
||||
_fieldName: N,
|
||||
_objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>
|
||||
_objectMap: ReadonlyMap<NonNullable<TFields[N]>, object>
|
||||
): Promise<void> {}
|
||||
|
||||
public async cacheDBMissesAsync<N extends keyof TFields>(
|
||||
@@ -48,26 +53,27 @@ export class InMemoryFullCacheStubCacheAdapterProvider implements IEntityCacheAd
|
||||
getCacheAdapter<TFields>(
|
||||
entityConfiguration: EntityConfiguration<TFields>
|
||||
): EntityCacheAdapter<TFields> {
|
||||
return new InMemoryFullCacheStubCacheAdapter(
|
||||
entityConfiguration,
|
||||
this.cache as Map<string, Readonly<TFields>>
|
||||
);
|
||||
return new InMemoryFullCacheStubCacheAdapter(entityConfiguration, this.cache);
|
||||
}
|
||||
}
|
||||
|
||||
export class InMemoryFullCacheStubCacheAdapter<TFields> extends EntityCacheAdapter<TFields> {
|
||||
constructor(
|
||||
entityConfiguration: EntityConfiguration<TFields>,
|
||||
readonly cache: Map<string, Readonly<TFields>>
|
||||
readonly cache: Map<string, Readonly<object>>
|
||||
) {
|
||||
super(entityConfiguration);
|
||||
}
|
||||
|
||||
public getFieldTransformerMap(): FieldTransformerMap {
|
||||
return new Map();
|
||||
}
|
||||
|
||||
public async loadManyAsync<N extends keyof TFields>(
|
||||
fieldName: N,
|
||||
fieldValues: readonly NonNullable<TFields[N]>[]
|
||||
): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>> {
|
||||
const results = new Map<NonNullable<TFields[N]>, CacheLoadResult<TFields>>();
|
||||
): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult>> {
|
||||
const results = new Map<NonNullable<TFields[N]>, CacheLoadResult>();
|
||||
fieldValues.forEach((fieldValue) => {
|
||||
const cacheKey = this.createCacheKey(fieldName, fieldValue);
|
||||
if (!this.cache.has(cacheKey)) {
|
||||
@@ -88,7 +94,7 @@ export class InMemoryFullCacheStubCacheAdapter<TFields> extends EntityCacheAdapt
|
||||
|
||||
public async cacheManyAsync<N extends keyof TFields>(
|
||||
fieldName: N,
|
||||
objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>
|
||||
objectMap: ReadonlyMap<NonNullable<TFields[N]>, object>
|
||||
): Promise<void> {
|
||||
objectMap.forEach((obj, fieldValue) => {
|
||||
const cacheKey = this.createCacheKey(fieldName, fieldValue);
|
||||
|
||||
@@ -507,33 +507,28 @@
|
||||
exec-sh "^0.3.2"
|
||||
minimist "^1.2.0"
|
||||
|
||||
"@expo/entity-cache-adapter-local-memory@file:packages/entity-cache-adapter-local-memory":
|
||||
version "0.23.0"
|
||||
dependencies:
|
||||
lru-cache "^7.3.1"
|
||||
|
||||
"@expo/entity-cache-adapter-redis@file:packages/entity-cache-adapter-redis":
|
||||
version "0.23.0"
|
||||
version "0.21.0"
|
||||
dependencies:
|
||||
ioredis "^4.27.3"
|
||||
|
||||
"@expo/entity-database-adapter-knex@file:packages/entity-database-adapter-knex":
|
||||
version "0.23.0"
|
||||
version "0.21.0"
|
||||
dependencies:
|
||||
knex "^1.0.2"
|
||||
|
||||
"@expo/entity-ip-address-field@file:packages/entity-ip-address-field":
|
||||
version "0.23.0"
|
||||
version "0.21.0"
|
||||
dependencies:
|
||||
ip-address "^8.1.0"
|
||||
|
||||
"@expo/entity-secondary-cache-redis@file:packages/entity-secondary-cache-redis":
|
||||
version "0.23.0"
|
||||
version "0.21.0"
|
||||
dependencies:
|
||||
ioredis "^4.17.3"
|
||||
|
||||
"@expo/entity@file:packages/entity":
|
||||
version "0.23.0"
|
||||
version "0.21.0"
|
||||
dependencies:
|
||||
"@expo/results" "^1.0.0"
|
||||
dataloader "^2.0.0"
|
||||
@@ -2000,11 +1995,6 @@
|
||||
resolved "https://registry.yarnpkg.com/@types/long/-/long-4.0.1.tgz#459c65fa1867dafe6a8f322c4c51695663cc55e9"
|
||||
integrity sha512-5tXH6Bx/kNGd3MgffdmP4dy2Z+G4eaXw0SE81Tq3BNadtnMR5/ySMzX4SLEzHJzSmPNn4HIdpQsBvXMUykr58w==
|
||||
|
||||
"@types/lru-cache@^5.1.1":
|
||||
version "5.1.1"
|
||||
resolved "https://registry.yarnpkg.com/@types/lru-cache/-/lru-cache-5.1.1.tgz#c48c2e27b65d2a153b19bfc1a317e30872e01eef"
|
||||
integrity sha512-ssE3Vlrys7sdIzs5LOxCzTVMsU7i9oa/IaW92wF32JFb3CVczqOkru2xspuKczHEbG3nvmPY7IFqVmGGHdNbYw==
|
||||
|
||||
"@types/mime@*":
|
||||
version "2.0.1"
|
||||
resolved "https://registry.yarnpkg.com/@types/mime/-/mime-2.0.1.tgz#dc488842312a7f075149312905b5e3c0b054c79d"
|
||||
@@ -6575,11 +6565,6 @@ lru-cache@^6.0.0:
|
||||
dependencies:
|
||||
yallist "^4.0.0"
|
||||
|
||||
lru-cache@^7.3.1:
|
||||
version "7.3.1"
|
||||
resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-7.3.1.tgz#7702e80694ec2bf19865567a469f2b081fcf53f5"
|
||||
integrity sha512-nX1x4qUrKqwbIAhv4s9et4FIUVzNOpeY07bsjGUy8gwJrXH/wScImSQqXErmo/b2jZY2r0mohbLA9zVj7u1cNw==
|
||||
|
||||
lunr@^2.3.9:
|
||||
version "2.3.9"
|
||||
resolved "https://registry.yarnpkg.com/lunr/-/lunr-2.3.9.tgz#18b123142832337dd6e964df1a5a7707b25d35e1"
|
||||
|
||||
Reference in new issue
Block a user