Implemented redisio v5, removed custom redis type

.gitignore

@@ -5,6 +5,7 @@ config/db.config.js
 config/flags.js
 src/censusSocket/api_key.ts
 npm-debug.log
+yarn-error.log
 temp
 
 vars.local.yml

package.json

@@ -37,7 +37,7 @@
     "cors": "^2.8.5",
     "express": "^4.18.1",
     "inversify": "^6.0.1",
-    "ioredis": "^4.28.5",
+    "ioredis": "^5.2.2",
     "lodash": "^4.17.21",
     "logform": "^2.4.2",
     "moment": "^2.29.4",
@@ -50,7 +50,6 @@
   },
   "devDependencies": {
     "@types/amqplib": "^0.8.2",
-    "@types/ioredis": "^4.28.8",
     "@types/lodash": "^4.14.182",
     "@types/node": "^18.6.2",
     "@types/ws": "^8.5.3",

src/actions/MetagameInstanceTerritoryStartAction.ts

@@ -9,7 +9,7 @@ import {censusOldFacilities} from '../ps2alerts-constants/censusOldFacilities';
 import {Rest} from 'ps2census';
 import {AxiosInstance} from 'axios';
 import {ps2AlertsApiEndpoints} from '../ps2alerts-constants/ps2AlertsApiEndpoints';
-import {Redis} from 'ioredis';
+import Redis from 'ioredis';
 import ZoneDataParser from '../parsers/ZoneDataParser';
 
 export default class MetagameInstanceTerritoryStartAction implements ActionInterface<boolean> {

src/authorities/TimingStatisticsAuthority.ts

@@ -1,5 +1,5 @@
 import {getLogger} from '../logger';
-import {Redis} from 'ioredis';
+import Redis from 'ioredis';
 import {injectable} from 'inversify';
 import config from '../config';
 

src/authorities/index.ts

@@ -3,8 +3,8 @@ import OverdueInstanceAuthority from './OverdueInstanceAuthority';
 import PopulationAuthority from './PopulationAuthority';
 import InstanceAuthority from './InstanceAuthority';
 import TimingStatisticsAuthority from './TimingStatisticsAuthority';
-import {TYPES} from '../constants/types';
 import QueueAuthority from './QueueAuthority';
+import Redis from 'ioredis';
 
 export default new ContainerModule((bind) => {
     bind(InstanceAuthority)
@@ -24,6 +24,6 @@ export default new ContainerModule((bind) => {
         .inSingletonScope();
 
     bind(TimingStatisticsAuthority).toDynamicValue(async (context) => {
-        return new TimingStatisticsAuthority(await context.container.getAsync(TYPES.redis));
+        return new TimingStatisticsAuthority(await context.container.getAsync(Redis));
     }).inSingletonScope();
 });

src/brokers/FacilityDataBroker.ts

@@ -1,22 +1,21 @@
-import {inject, injectable} from 'inversify';
+import {injectable} from 'inversify';
 import {getLogger} from '../logger';
-import {Redis} from 'ioredis';
 import {FacilityDataInterface} from '../interfaces/FacilityDataInterface';
 import FacilityData from '../data/FacilityData';
 import FakeMapRegionFactory from '../constants/fakeMapRegion';
 import {CensusApiRetryDriver} from '../drivers/CensusApiRetryDriver';
 import {FacilityControl, Rest} from 'ps2census';
-import {TYPES} from '../constants/types';
 import config from '../config';
 import PS2EventQueueMessage from '../handlers/messages/PS2EventQueueMessage';
 import Parser from '../utils/parser';
+import Redis from 'ioredis';
 
 @injectable()
 export default class FacilityDataBroker {
     private static readonly logger = getLogger('FacilityDataBroker');
 
     constructor(
-        @inject(TYPES.redis) private readonly cacheClient: Redis,
+        private readonly cacheClient: Redis,
         private readonly restClient: Rest.Client,
     ) {}
 

src/brokers/ItemBroker.ts

@@ -8,21 +8,21 @@ import Item from '../data/Item';
 import FakeItemFactory from '../factories/FakeItemFactory';
 import {Vehicle} from '../ps2alerts-constants/vehicle';
 import {CensusApiRetryDriver} from '../drivers/CensusApiRetryDriver';
-import {Redis} from 'ioredis';
 import {Rest} from 'ps2census';
 import config from '../config';
 import {AxiosInstance} from 'axios';
 import ApplicationException from '../exceptions/ApplicationException';
 import {lithafalconEndpoints} from '../ps2alerts-constants/lithafalconEndpoints';
 import {CensusEnvironment} from '../types/CensusEnvironment';
+import Redis from 'ioredis';
 
 @injectable()
 export default class ItemBroker implements ItemBrokerInterface {
     private static readonly logger = getLogger('ItemBroker');
 
     constructor(
         private readonly restClient: Rest.Client,
-        @inject(TYPES.redis) private readonly cacheClient: Redis,
+        private readonly cacheClient: Redis,
         @inject(TYPES.falconApiClient) private readonly falconApiClient: AxiosInstance,
     ) {}
 

src/calculators/TerritoryCalculator.ts

@@ -16,7 +16,7 @@ import {ps2AlertsApiEndpoints} from '../ps2alerts-constants/ps2AlertsApiEndpoint
 import {AxiosInstance, AxiosResponse} from 'axios';
 import PS2AlertsInstanceEntriesInstanceFacilityResponseInterface
     from '../interfaces/PS2AlertsInstanceEntriesInstanceFacilityResponseInterface';
-import {Redis} from 'ioredis';
+import Redis from 'ioredis';
 import ZoneDataParser from '../parsers/ZoneDataParser';
 
 interface PercentagesInterface extends FactionNumbersInterface {

src/constants/types.ts

@@ -1,6 +1,4 @@
 const TYPES = {
-    redis: Symbol.for('redis'),
-
     // Cache Drivers
     censusCharacterCacheDriver: Symbol('censusCharacterCacheDriver'),
 

src/drivers/CensusCacheDriver.ts

@@ -1,14 +1,13 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-explicit-any,@typescript-eslint/explicit-module-boundary-types */
 
-import {inject, injectable} from 'inversify';
+import {injectable} from 'inversify';
 import {CacheContract} from 'ps2census';
-import {Redis} from 'ioredis';
-import {TYPES} from '../constants/types';
+import Redis from 'ioredis';
 
 @injectable()
 export default class CensusCacheDriver implements CacheContract {
     constructor(
-        @inject(TYPES.redis) private readonly cacheClient: Redis,
+        private readonly cacheClient: Redis,
         private readonly namespace: string = 'census',
         private readonly expiry: number = 86400,
     ) {}

src/drivers/index.ts

@@ -3,12 +3,13 @@ import CensusCacheDriver from './CensusCacheDriver';
 import {TYPES} from '../constants/types';
 import {CensusClient} from 'ps2census';
 import config from '../config';
+import Redis from 'ioredis';
 
 export default new ContainerModule((bind) => {
     // Boot the Census Stream services
     bind<CensusCacheDriver>(TYPES.censusCharacterCacheDriver)
         .toDynamicValue(async ({container}) => new CensusCacheDriver(
-            await container.getAsync(TYPES.redis),
+            await container.getAsync(Redis),
             'character',
             86400,
         )).inSingletonScope();

src/factories/InstanceActionFactory.ts

@@ -15,7 +15,7 @@ import {AxiosInstance} from 'axios';
 import FacilityControlEvent from '../handlers/ps2census/events/FacilityControlEvent';
 import MetagameInstanceTerritoryResultAction from '../actions/MetagameInstanceTerritoryResultAction';
 import TerritoryResultInterface from '../interfaces/TerritoryResultInterface';
-import {Redis} from 'ioredis';
+import Redis from 'ioredis';
 import ZoneDataParser from '../parsers/ZoneDataParser';
 
 @injectable()
@@ -26,7 +26,7 @@ export default class InstanceActionFactory {
         private readonly outfitParticipantCacheHandler: OutfitParticipantCacheHandler,
         private readonly restClient: Rest.Client,
         @inject(TYPES.ps2AlertsApiClient) private readonly ps2AlertsApiClient: AxiosInstance,
-        @inject(TYPES.redis) private readonly cacheClient: Redis,
+        private readonly cacheClient: Redis,
         private readonly zoneDataParser: ZoneDataParser,
     ) {}
 

src/factories/TerritoryCalculatorFactory.ts

@@ -4,14 +4,14 @@ import MetagameTerritoryInstance from '../instances/MetagameTerritoryInstance';
 import TerritoryCalculator from '../calculators/TerritoryCalculator';
 import {Rest} from 'ps2census';
 import {AxiosInstance} from 'axios';
-import {Redis} from 'ioredis';
+import Redis from 'ioredis';
 import ZoneDataParser from '../parsers/ZoneDataParser';
 
 @injectable()
 export default class TerritoryCalculatorFactory {
     constructor(
         @inject(TYPES.ps2AlertsApiClient) private readonly ps2AlertsApiClient: AxiosInstance,
-        @inject(TYPES.redis) private readonly cacheClient: Redis,
+        private readonly cacheClient: Redis,
         private readonly zoneDataParser: ZoneDataParser,
     ) {}
 

src/handlers/CharacterPresenceHandler.ts

@@ -1,21 +1,20 @@
-import {inject, injectable} from 'inversify';
+import {injectable} from 'inversify';
 import {Zone, zoneArray} from '../ps2alerts-constants/zone';
 import {getLogger} from '../logger';
 import CharacterPresenceHandlerInterface from '../interfaces/CharacterPresenceHandlerInterface';
 import PopulationData from '../data/PopulationData';
 import {Faction, factionArray} from '../ps2alerts-constants/faction';
 import Character from '../data/Character';
-import {Redis} from 'ioredis';
 import {World, worldArray} from '../ps2alerts-constants/world';
 import FactionUtils from '../utils/FactionUtils';
-import {TYPES} from '../constants/types';
 import PS2AlertsInstanceInterface from '../interfaces/PS2AlertsInstanceInterface';
+import Redis from 'ioredis';
 
 @injectable()
 export default class CharacterPresenceHandler implements CharacterPresenceHandlerInterface {
     private static readonly logger = getLogger('CharacterPresenceHandler');
 
-    constructor(@inject(TYPES.redis) private readonly cacheClient: Redis) {}
+    constructor(private readonly cacheClient: Redis) {}
 
     // Updates / adds characters presence, setting a Redis key with expiry.
     public async update(character: Character, instance: PS2AlertsInstanceInterface): Promise<boolean> {

src/handlers/OutfitParticipantCacheHandler.ts

@@ -1,13 +1,12 @@
-import {inject, injectable} from 'inversify';
-import {Redis} from 'ioredis';
+import {injectable} from 'inversify';
 import {getLogger} from '../logger';
-import {TYPES} from '../constants/types';
+import Redis from 'ioredis';
 
 @injectable()
 export default class OutfitParticipantCacheHandler {
     private static readonly logger = getLogger('OutfitParticipantCacheHandler');
 
-    constructor(@inject(TYPES.redis) private readonly cacheClient: Redis) {}
+    constructor(private readonly cacheClient: Redis) {}
 
     public async addOutfit(outfitId: string, characterId: string, instanceId: string): Promise<boolean> {
         await this.cacheClient.sadd(`OutfitParticipants-${instanceId}-${outfitId}`, characterId);

src/middlewares/TimingMiddlewareHandler.ts

@@ -3,16 +3,15 @@
 // This class is usually called in front of ZoneMessageQueueHandler, not the actual handlers themselves.
 import {injectable} from 'inversify';
 import {ChannelActionsInterface, QueueMessageHandlerInterface} from '../interfaces/QueueMessageHandlerInterface';
-import {Redis} from 'ioredis';
+import Redis from 'ioredis';
 import {PS2Event} from 'ps2census';
 import config from '../config';
 
 @injectable()
 export default class TimingMiddlewareHandler {
     private readonly runId = config.app.runId;
-    constructor(
-        private readonly cacheClient: Redis,
-    ) {}
+
+    constructor(private readonly cacheClient: Redis) {}
 
     public async handle(
         message: PS2Event,

src/middlewares/index.ts

@@ -1,11 +1,11 @@
 import {ContainerModule} from 'inversify';
 import TimingMiddlewareHandler from './TimingMiddlewareHandler';
-import {TYPES} from '../constants/types';
+import Redis from 'ioredis';
 
 export default new ContainerModule((bind) => {
     // This is required as the uniqueID would change every time it's called, which is not what we want as we want it unique for the duration of the app's life.
     // Additionally, it means only one TimingMiddleware exists rather than multiple.
     bind(TimingMiddlewareHandler).toDynamicValue(async ({container}) => {
-        return new TimingMiddlewareHandler(await container.getAsync(TYPES.redis));
+        return new TimingMiddlewareHandler(await container.getAsync(Redis));
     }).inSingletonScope();
 });

src/parsers/CensusMapRegionQueryParser.ts

@@ -5,7 +5,7 @@ import MetagameTerritoryInstance from '../instances/MetagameTerritoryInstance';
 import {Zone} from '../ps2alerts-constants/zone';
 import {Rest} from 'ps2census';
 import {getLogger} from '../logger';
-import {Redis} from 'ioredis';
+import Redis from 'ioredis';
 import {
     CensusFacilityRegion,
     CensusRegionMapJoinQueryInterface,

src/services/redis/index.ts

@@ -1,11 +1,11 @@
 import {ContainerModule} from 'inversify';
 import {RedisConnectionFactory} from './RedisConnectionFactory';
-import {TYPES} from '../../constants/types';
+import Redis from 'ioredis';
 
 export default new ContainerModule((bind) => {
     bind(RedisConnectionFactory).toSelf().inSingletonScope();
 
-    bind(TYPES.redis).toDynamicValue(async ({container}) => {
+    bind(Redis).toDynamicValue(async ({container}) => {
         const factory = await container.getAsync(RedisConnectionFactory);
         return factory.createClient();
     });