75 lines
2.8 KiB
TypeScript
75 lines
2.8 KiB
TypeScript
/*
|
|
* SPDX-FileCopyrightText: hazelnoot and other Sharkey contributors
|
|
* SPDX-License-Identifier: AGPL-3.0-only
|
|
*/
|
|
|
|
import { Injectable } from '@nestjs/common';
|
|
import { GodOfTimeService } from './GodOfTimeService.js';
|
|
import { MockInternalEventService } from './MockInternalEventService.js';
|
|
import { MockRedis } from './MockRedis.js';
|
|
import type * as Redis from 'ioredis';
|
|
import type { QuantumKVOpts } from '@/misc/QuantumKVCache.js';
|
|
import type { RedisKVCacheOpts, RedisSingleCacheOpts, MemoryCacheOpts } from '@/misc/cache.js';
|
|
import type { TimeService } from '@/global/TimeService.js';
|
|
import type { InternalEventService } from '@/global/InternalEventService.js';
|
|
import {
|
|
CacheManagementService,
|
|
type ManagedMemoryKVCache,
|
|
type ManagedMemorySingleCache,
|
|
type ManagedRedisKVCache,
|
|
type ManagedRedisSingleCache,
|
|
type ManagedQuantumKVCache,
|
|
} from '@/global/CacheManagementService.js';
|
|
|
|
/**
|
|
* Fake implementation of cache management that suppresses all caching behavior.
|
|
* The returned cache instances are real and fully functional, but expiration is negative to ensure that data is immediately discarded and nothing is cached.
|
|
* Essentially, it strips out the caching behavior and converts caches into pure data accessors.
|
|
*/
|
|
@Injectable()
|
|
export class FakeCacheManagementService extends CacheManagementService {
|
|
constructor(opts?: {
|
|
redisClient?: Redis.Redis;
|
|
timeService?: TimeService;
|
|
internalEventService?: InternalEventService;
|
|
}) {
|
|
const timeService = opts?.timeService ?? new GodOfTimeService();
|
|
const redisClient = opts?.redisClient ?? new MockRedis(timeService);
|
|
const internalEventService = opts?.internalEventService ?? new MockInternalEventService();
|
|
|
|
super(redisClient, timeService, internalEventService);
|
|
}
|
|
|
|
createMemoryKVCache<T>(name: string, optsOrLifetime: number | MemoryCacheOpts): ManagedMemoryKVCache<T> {
|
|
const opts = typeof(optsOrLifetime) === 'number' ? { lifetime: -1 } : { ...optsOrLifetime, lifetime: -1 };
|
|
return super.createMemoryKVCache(name, opts);
|
|
}
|
|
|
|
createMemorySingleCache<T>(name: string, optsOrLifetime: number | MemoryCacheOpts): ManagedMemorySingleCache<T> {
|
|
const opts = typeof(optsOrLifetime) === 'number' ? { lifetime: -1 } : { ...optsOrLifetime, lifetime: -1 };
|
|
return super.createMemorySingleCache(name, opts);
|
|
}
|
|
|
|
createRedisKVCache<T>(name: string, opts: RedisKVCacheOpts<T>): ManagedRedisKVCache<T> {
|
|
return super.createRedisKVCache(name, {
|
|
...opts,
|
|
lifetime: -1,
|
|
memoryCacheLifetime: -1,
|
|
});
|
|
}
|
|
|
|
createRedisSingleCache<T>(name: string, opts: RedisSingleCacheOpts<T>): ManagedRedisSingleCache<T> {
|
|
return super.createRedisSingleCache(name, {
|
|
...opts,
|
|
lifetime: -1,
|
|
memoryCacheLifetime: -1,
|
|
});
|
|
}
|
|
|
|
createQuantumKVCache<T>(name: string, opts: QuantumKVOpts<T>): ManagedQuantumKVCache<T> {
|
|
return super.createQuantumKVCache(name, {
|
|
...opts,
|
|
lifetime: -1,
|
|
});
|
|
}
|
|
}
|