FoxxMD · FoxxMD · Oct 17, 2022 · Oct 17, 2022 · Oct 17, 2022
diff --git a/.nvmrc b/.nvmrc
@@ -1 +1 @@
-16.14.2
+16.18.0
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -24,7 +24,7 @@
     "initMigration": "npm run typeorm -- migration:generate -t 1642180264563 -d ormconfig.js \"src/Common/Migrations/Database/init\""
   },
   "engines": {
-    "node": ">=16"
+    "node": ">=16.18.0"
   },
   "keywords": [],
   "author": "",
@@ -49,7 +49,7 @@
     "autolinker": "^3.14.3",
     "body-parser": "^1.19.0",
     "cache-manager": "^3.4.4",
-    "cache-manager-redis-store": "^2.0.0",
+    "cache-manager-redis-store": "^3.0.1",
     "commander": "^8.0.0",
     "comment-json": "^4.1.1",
     "connect-typeorm": "^2.0.0",
@@ -115,7 +115,6 @@
     "@tsconfig/node14": "^1.0.0",
     "@types/async": "^3.2.7",
     "@types/cache-manager": "^3.4.2",
-    "@types/cache-manager-redis-store": "^2.0.0",
     "@types/chai": "^4.3.0",
     "@types/chai-as-promised": "^7.1.5",
     "@types/cookie-parser": "^1.4.2",

diff --git a/src/Common/Cache/index.ts b/src/Common/Cache/index.ts
@@ -0,0 +1,47 @@
+import {CacheOptions} from "../interfaces";
+import cacheManager, {Cache} from "cache-manager";
+import {redisStore} from "cache-manager-redis-store";
+import {create as createMemoryStore} from "../../Utils/memoryStore";
+import {CacheProvider} from "../Infrastructure/Atomic";
+import {cacheOptDefaults} from "../defaults";
+
+export const buildCacheOptionsFromProvider = (provider: CacheProvider | any): CacheOptions => {
+    if (typeof provider === 'string') {
+        return {
+            store: provider as CacheProvider,
+            ...cacheOptDefaults
+        }
+    }
+    return {
+        store: 'memory',
+        ...cacheOptDefaults,
+        ...provider,
+    }
+}
+export const createCacheManager = async (options: CacheOptions): Promise<Cache> => {
+    const {store, max, ttl = 60, host = 'localhost', port, auth_pass, db, ...rest} = options;
+    switch (store) {
+        case 'none':
+            return cacheManager.caching({store: 'none', max, ttl});
+        case 'redis':
+            const rStore = await redisStore(
+                {
+                    socket: {
+                        host,
+                        port
+                    },
+                    password: auth_pass,
+                    database: db,
+                }
+            );
+            return cacheManager.caching({
+                store: rStore,
+                ttl,
+                ...rest,
+            });
+        case 'memory':
+        default:
+            //return cacheManager.caching({store: 'memory', max, ttl});
+            return cacheManager.caching({store: {create: createMemoryStore}, max, ttl, shouldCloneBeforeSet: false});
+    }
+}
diff --git a/src/Common/Typings/support.d.ts b/src/Common/Typings/support.d.ts
@@ -163,3 +163,9 @@ declare module 'wink-sentiment' {
 
     export default sentiment;
 }
+
+declare module 'cache-manager-redis-store' {
+    import {RedisClientOptions} from "@redis/client";
+    import {Cache, CachingConfig} from "cache-manager";
+    export async function redisStore(config: RedisClientOptions & Partial<CachingConfig>): Cache;
+}
diff --git a/src/Subreddit/SubredditResources.ts b/src/Subreddit/SubredditResources.ts
@@ -14,10 +14,8 @@ import {
     asActivity,
     asSubmission,
     asUserNoteCriteria,
-    buildCacheOptionsFromProvider,
     buildCachePrefix,
     cacheStats,
-    createCacheManager,
     escapeRegex,
     FAIL,
     fetchExternalResult,
@@ -173,6 +171,7 @@ import ConfigParseError from "../Utils/ConfigParseError";
 import {ActivityReport} from "../Common/Entities/ActivityReport";
 import {ActionResultEntity} from "../Common/Entities/ActionResultEntity";
 import {ActivitySource} from "../Common/ActivitySource";
+import {buildCacheOptionsFromProvider, createCacheManager} from "../Common/Cache";
 
 export const DEFAULT_FOOTER = '\r\n*****\r\nThis action was performed by [a bot.]({{botLink}}) Mention a moderator or [send a modmail]({{modmailLink}}) if you have any ideas, questions, or concerns about this action.';
 
@@ -3545,7 +3544,7 @@ export class BotResourcesManager {
     authorTTL: number = 10000;
     enabled: boolean = true;
     modStreams: Map<string, SPoll<Snoowrap.Submission | Snoowrap.Comment>> = new Map();
-    defaultCache: Cache;
+    defaultCache: Promise<Cache>;
     defaultCacheConfig: StrongCache
     defaultCacheMigrated: boolean = false;
     cacheType: string = 'none';
@@ -3649,7 +3648,7 @@ export class BotResourcesManager {
         // });
 
         let opts: SubredditResourceOptions = {
-            cache: this.defaultCache,
+            cache: await this.defaultCache,
             cacheType: this.cacheType,
             cacheSettingsHash: hash,
             ttl: this.ttlDefaults,
@@ -3680,7 +3679,7 @@ export class BotResourcesManager {
                 trueProvider.prefix = subPrefix;
                 const eventsMax = this.actionedEventsMaxDefault !== undefined ? Math.min(actionedEventsMax, this.actionedEventsMaxDefault) : actionedEventsMax;
                 opts = {
-                    cache: createCacheManager(trueProvider),
+                    cache: await createCacheManager(trueProvider),
                     actionedEventsMax: eventsMax,
                     cacheType: trueProvider.store,
                     cacheSettingsHash: hash,
@@ -3695,7 +3694,7 @@ export class BotResourcesManager {
                 await runMigrations(opts.cache, opts.logger, trueProvider.prefix);
             }
         } else if(!this.defaultCacheMigrated) {
-            await runMigrations(this.defaultCache, this.logger, opts.prefix);
+            await runMigrations(await this.defaultCache, this.logger, opts.prefix);
             this.defaultCacheMigrated = true;
         }
 
@@ -3730,7 +3729,7 @@ export class BotResourcesManager {
     }
 
     async getPendingSubredditInvites(): Promise<(string[])> {
-        const subredditNames = await this.defaultCache.get(`modInvites`);
+        const subredditNames = await (await this.defaultCache).get(`modInvites`);
         if (subredditNames !== undefined && subredditNames !== null) {
             return subredditNames as string[];
         }
@@ -3741,7 +3740,7 @@ export class BotResourcesManager {
         if(subreddit === null || subreddit === undefined || subreddit == '') {
             throw new CMError('Subreddit name cannot be empty');
         }
-        let subredditNames = await this.defaultCache.get(`modInvites`) as (string[] | undefined | null);
+        let subredditNames = await (await this.defaultCache).get(`modInvites`) as (string[] | undefined | null);
         if (subredditNames === undefined || subredditNames === null) {
             subredditNames = [];
         }
@@ -3751,22 +3750,22 @@ export class BotResourcesManager {
             throw new CMError(`An invite for the Subreddit '${subreddit}' already exists`);
         }
         subredditNames.push(cleanName);
-        await this.defaultCache.set(`modInvites`, subredditNames, {ttl: 0});
+        await (await this.defaultCache).set(`modInvites`, subredditNames, {ttl: 0});
         return;
     }
 
     async deletePendingSubredditInvite(subreddit: string): Promise<void> {
-        let subredditNames = await this.defaultCache.get(`modInvites`) as (string[] | undefined | null);
+        let subredditNames = await (await this.defaultCache).get(`modInvites`) as (string[] | undefined | null);
         if (subredditNames === undefined || subredditNames === null) {
             subredditNames = [];
         }
         subredditNames = subredditNames.filter(x => x.toLowerCase() !== subreddit.trim().toLowerCase());
-        await this.defaultCache.set(`modInvites`, subredditNames, {ttl: 0});
+        await (await this.defaultCache).set(`modInvites`, subredditNames, {ttl: 0});
         return;
     }
 
     async clearPendingSubredditInvites(): Promise<void> {
-        await this.defaultCache.del(`modInvites`);
+        await (await this.defaultCache).del(`modInvites`);
         return;
     }
 }

diff --git a/src/Web/Client/StorageProvider.ts b/src/Web/Client/StorageProvider.ts
@@ -1,7 +1,7 @@
 import {SessionOptions, Store} from "express-session";
 import {TypeormStore} from "connect-typeorm";
 import {InviteData} from "../Common/interfaces";
-import {buildCachePrefix, createCacheManager, mergeArr} from "../../util";
+import {buildCachePrefix, mergeArr} from "../../util";
 import {Cache} from "cache-manager";
 // @ts-ignore
 import CacheManagerStore from 'express-session-cache-manager'
@@ -11,6 +11,7 @@ import {ClientSession} from "../../Common/WebEntities/ClientSession";
 import {Logger} from "winston";
 import {WebSetting} from "../../Common/WebEntities/WebSetting";
 import {ErrorWithCause} from "pony-cause";
+import {createCacheManager} from "../../Common/Cache";
 
 export interface CacheManagerStoreOptions {
     prefix?: string
@@ -24,7 +25,7 @@ export type TypeormStoreOptions = Partial<SessionOptions & {
 }>;
 
 interface IWebStorageProvider {
-    createSessionStore(options?: CacheManagerStoreOptions | TypeormStoreOptions): Store
+    createSessionStore(options?: CacheManagerStoreOptions | TypeormStoreOptions): Promise<Store>
 
     getSessionSecret(): Promise<string | undefined>
 
@@ -48,7 +49,7 @@ abstract class StorageProvider implements IWebStorageProvider {
         this.logger = logger.child({labels: ['Web', 'Storage', ...loggerLabels]}, mergeArr);
     }
 
-    abstract createSessionStore(options?: CacheManagerStoreOptions | TypeormStoreOptions): Store;
+    abstract createSessionStore(options?: CacheManagerStoreOptions | TypeormStoreOptions): Promise<Store>;
 
     abstract getSessionSecret(): Promise<string | undefined>;
 
@@ -57,32 +58,32 @@ abstract class StorageProvider implements IWebStorageProvider {
 
 export class CacheStorageProvider extends StorageProvider {
 
-    protected cache: Cache;
+    protected cache: Promise<Cache>;
 
     constructor(caching: CacheOptions & StorageProviderOptions) {
         super(caching);
         const {logger, invitesMaxAge, loggerLabels, ...restCache } = caching;
-        this.cache = createCacheManager({...restCache, prefix: buildCachePrefix(['web'])}) as Cache;
+        this.cache = createCacheManager({...restCache, prefix: buildCachePrefix(['web'])}) as Promise<Cache>;
         this.logger.debug('Using CACHE');
         if (caching.store === 'none') {
             this.logger.warn(`Using 'none' as cache provider means no one will be able to access the interface since sessions will never be persisted!`);
         }
     }
 
-    createSessionStore(options?: CacheManagerStoreOptions): Store {
-        return new CacheManagerStore(this.cache, {prefix: 'sess:'});
+    async createSessionStore(options?: CacheManagerStoreOptions): Promise<Store> {
+        return new CacheManagerStore((await this.cache), {prefix: 'sess:'});
     }
 
     async getSessionSecret() {
-        const val = await this.cache.get(`sessionSecret`);
+        const val = await (await this.cache).get(`sessionSecret`);
         if (val === null || val === undefined) {
             return undefined;
         }
         return val as string;
     }
 
     async setSessionSecret(secret: string) {
-        await this.cache.set('sessionSecret', secret, {ttl: 0});
+        await (await this.cache).set('sessionSecret', secret, {ttl: 0});
     }
 
 }
@@ -101,7 +102,7 @@ export class DatabaseStorageProvider extends StorageProvider {
         this.logger.debug('Using DATABASE');
     }
 
-    createSessionStore(options?: TypeormStoreOptions): Store {
+    async createSessionStore(options?: TypeormStoreOptions): Promise<Store> {
         return new TypeormStore(options).connect(this.clientSessionRepo)
     }
 

diff --git a/src/Web/Client/index.ts b/src/Web/Client/index.ts
@@ -17,7 +17,7 @@ import {
 } from "../../Common/interfaces";
 import {
     buildCachePrefix,
-    createCacheManager, defaultFormat, filterLogBySubreddit, filterCriteriaSummary, formatFilterData,
+    defaultFormat, filterLogBySubreddit, filterCriteriaSummary, formatFilterData,
     formatLogLineToHtml, filterLogs, getUserAgent,
     intersect, isLogLineMinLevel,
     LogEntry, parseInstanceLogInfoName, parseInstanceLogName, parseRedditEntity,
@@ -64,6 +64,7 @@ import {
     InviteData, SubredditInviteDataPersisted
 } from "../Common/interfaces";
 import {open} from "fs/promises";
+import {createCacheManager} from "../../Common/Cache";
 
 const emitter = new EventEmitter();
 
@@ -323,7 +324,7 @@ const webClient = async (options: OperatorConfigWithFileContext) => {
         cookie: {
             maxAge: sessionMaxAge * 1000,
         },
-        store: sessionStoreProvider.createSessionStore(sessionStorage === 'database' ? {
+        store: await sessionStoreProvider.createSessionStore(sessionStorage === 'database' ? {
             cleanupLimit: 2,
             ttl: sessionMaxAge
         } : {}),

diff --git a/src/util.ts b/src/util.ts
@@ -14,7 +14,6 @@ import {
     ActionResult,
     ActivityDispatch,
     ActivityDispatchConfig,
-    CacheOptions,
     CheckSummary,
     ImageComparisonResult,
     ItemCritPropHelper,
@@ -35,11 +34,9 @@ import {
 } from "./Common/interfaces";
 import InvalidRegexError from "./Utils/InvalidRegexError";
 import {accessSync, constants, promises} from "fs";
-import {cacheOptDefaults, VERSION} from "./Common/defaults";
-import cacheManager, {Cache} from "cache-manager";
-import redisStore from "cache-manager-redis-store";
+import {VERSION} from "./Common/defaults";
+import cacheManager from "cache-manager";
 import Autolinker from 'autolinker';
-import {create as createMemoryStore} from './Utils/memoryStore';
 import {LEVEL, MESSAGE} from "triple-beam";
 import {Comment, PrivateMessage, RedditUser, Submission, Subreddit} from "snoowrap/dist/objects";
 import reRegExp from '@stdlib/regexp-regexp';
@@ -71,23 +68,23 @@ import {
     UserNoteCriteria
 } from "./Common/Infrastructure/Filters/FilterCriteria";
 import {
-    ActivitySourceValue,
+    ActivitySourceData,
     ActivitySourceTypes,
-    CacheProvider,
+    ActivitySourceValue,
     ConfigFormat,
     DurationVal,
     ExternalUrlContext,
     ImageHashCacheData,
     ModUserNoteLabel,
     modUserNoteLabels,
     RedditEntity,
-    RedditEntityType, RelativeDateTimeMatch,
+    RedditEntityType,
+    RelativeDateTimeMatch,
     statFrequencies,
     StatisticFrequency,
     StatisticFrequencyOption,
     UrlContext,
-    WikiContext,
-    ActivitySourceData
+    WikiContext
 } from "./Common/Infrastructure/Atomic";
 import {
     AuthorOptions,
@@ -1765,42 +1762,6 @@ export const cacheStats = (): ResourceStats => {
     };
 }
 
-export const buildCacheOptionsFromProvider = (provider: CacheProvider | any): CacheOptions => {
-    if(typeof provider === 'string') {
-        return {
-            store: provider as CacheProvider,
-            ...cacheOptDefaults
-        }
-    }
-    return {
-        store: 'memory',
-        ...cacheOptDefaults,
-        ...provider,
-    }
-}
-
-export const createCacheManager = (options: CacheOptions): Cache => {
-    const {store, max, ttl = 60, host = 'localhost', port, auth_pass, db, ...rest} = options;
-    switch (store) {
-        case 'none':
-            return cacheManager.caching({store: 'none', max, ttl});
-        case 'redis':
-            return cacheManager.caching({
-                store: redisStore,
-                host,
-                port,
-                auth_pass,
-                db,
-                ttl,
-                ...rest,
-            });
-        case 'memory':
-        default:
-            //return cacheManager.caching({store: 'memory', max, ttl});
-            return cacheManager.caching({store: {create: createMemoryStore}, max, ttl, shouldCloneBeforeSet: false});
-    }
-}
-
 export const randomId = () => crypto.randomBytes(20).toString('hex');
 
 export const intersect = (a: Array<any>, b: Array<any>) => {