make cache classes async, add RedisCache class

Author: patinthehat

src/MemoryCache.ts

@@ -0,0 +1,18 @@
+/* eslint-disable no-unused-vars */
+
+export abstract class Cache {
+    public prefix = '';
+
+    public destroy() {
+        //
+    }
+    public abstract has(key: string): Promise<boolean>;
+
+    public abstract get(key: string): Promise<any | null>;
+
+    public abstract put(key: string, value: any, ttlSeconds: number): void;
+
+    public abstract purge();
+
+    public abstract clear();
+}

src/lib/cache/Cache.ts

@@ -0,0 +1,64 @@
+import { Cache } from './Cache';
+
+export interface CacheItem {
+    ts: number;
+    expires: number;
+    value: any;
+}
+
+export interface CacheMap {
+    [key: string]: CacheItem;
+}
+
+export class MemoryCache extends Cache {
+    public map: CacheMap = {};
+
+    constructor(keyPrefix = '') {
+        super();
+
+        if (keyPrefix.length) {
+            keyPrefix += ':';
+        }
+
+        this.prefix = keyPrefix;
+    }
+
+    protected makeKey(key: string): string {
+        return `${this.prefix}${key}`;
+    }
+
+    public async has(key: string): Promise<boolean> {
+        this.purge();
+
+        return new Promise(resolve => resolve(typeof this.map[this.makeKey(key)] !== 'undefined'));
+    }
+
+    public async get(key: string): Promise<any | null> {
+        this.purge();
+
+        const result = this.map[this.makeKey(key)]?.value ?? null;
+
+        return new Promise(resolve => resolve(result));
+    }
+
+    public put(key: string, value: any, ttlSeconds: number) {
+        this.map[this.makeKey(key)] = {
+            ts: new Date().getTime(),
+            expires: new Date().getTime() + ttlSeconds * 1000,
+            value: value,
+        };
+    }
+
+    public purge() {
+        for (const prop in this.map) {
+            if (new Date().getTime() >= this.map[prop].expires) {
+                delete this.map[prop];
+                continue;
+            }
+        }
+    }
+
+    public clear() {
+        //
+    }
+}

src/lib/cache/MemoryCache.ts

@@ -0,0 +1,50 @@
+import { Cache } from './Cache';
+const Redis = require('ioredis');
+
+export class RedisCache extends Cache {
+    public redis: typeof Redis;
+
+    constructor(keyPrefix = '') {
+        super();
+
+        if (keyPrefix.length) {
+            keyPrefix += ':';
+        }
+
+        this.prefix = keyPrefix;
+
+        this.redis = new Redis({ keyPrefix: keyPrefix });
+    }
+
+    public destroy() {
+        this.redis.disconnect();
+    }
+
+    public async has(key: string): Promise<boolean> {
+        const result = await this.redis.exists(key);
+
+        return new Promise(resolve => resolve(result === 1));
+    }
+
+    public async get(key: string): Promise<any | null> {
+        let result = await this.redis.get(key);
+
+        if (result !== null) {
+            result = JSON.parse(result);
+        }
+
+        return new Promise(resolve => resolve(result));
+    }
+
+    public put(key: string, value: any, ttlSeconds: number): void {
+        this.redis.set(key, JSON.stringify(value), 'EX', ttlSeconds);
+    }
+
+    public purge() {
+        //
+    }
+
+    public clear() {
+        //
+    }
+}

src/lib/cache/RedisCache.ts

@@ -1,4 +1,4 @@
-import { MemoryCache } from '@/MemoryCache';
+import { MemoryCache } from '@/lib/cache/MemoryCache';
 import { getResolver as getCommentsResolver } from '@/resolvers/comments';
 import { getResolver as getJobsResolver } from '@/resolvers/jobs';
 import { getResolver as getStoriesResolver } from '@/resolvers/stories';

src/lib/resolver.ts

@@ -3,8 +3,9 @@ import axios from 'axios';
 export function getResolver(cache: any): any {
     const authorResolver = async parent => {
         const userCacheKey = `user:${parent.by}`;
+        const hasKey = await cache.has(userCacheKey);
 
-        if (cache.has(userCacheKey)) {
+        if (hasKey) {
             return cache.get(userCacheKey);
         }
 
@@ -13,7 +14,7 @@ export function getResolver(cache: any): any {
 
         cache.put(userCacheKey, resp.data, 3600);
 
-        return new Promise(resolve => resolve(cache.get(userCacheKey)));
+        return new Promise(resolve => resolve(resp.data));
     };
 
     return authorResolver;

src/resolvers/Story/author.ts

@@ -13,7 +13,9 @@ export function getResolver(cache: any): any {
         const commentIds = parent.kids.slice(0, first);
 
         for (const id of commentIds) {
-            if (!cache.has(`comment:${id}`)) {
+            const hasKey = await cache.has(`comment:${id}`);
+
+            if (!hasKey) {
                 // console.log(`getting comment ${id} from URL...`);
 
                 const commentResp = await axios.get(`${process.env.HACKERNEWS_API_URL}/item/${id}.json`);
@@ -22,7 +24,7 @@ export function getResolver(cache: any): any {
                 cache.put(`comment:${id}`, commentData, 3600);
             }
 
-            comments.push(cache.get(`comment:${id}`));
+            comments.push(await cache.get(`comment:${id}`));
         }
 
         return new Promise(resolve => resolve(comments));

src/resolvers/comments.ts

@@ -1,4 +1,4 @@
-import { MemoryCache } from '@/MemoryCache';
+import { MemoryCache } from '@/lib/cache/MemoryCache';
 import axios from 'axios';
 
 export function getResolver(storyIds, stories, cache: MemoryCache): any {
@@ -11,22 +11,23 @@ export function getResolver(storyIds, stories, cache: MemoryCache): any {
         const ids: number[] = [];
         const cacheKey = `jobstoryids:${first}-${skipText ? 'skipText' : 'dontSkipText'}`;
 
-        if (!cache.has(cacheKey)) {
+        const hasKey = await cache.has(cacheKey);
+        if (!hasKey) {
             const resp = await axios.get(`${process.env.HACKERNEWS_API_URL}/jobstories.json?limitToFirst=${first + 5}&orderBy="$key"`);
             const data: number[] = resp.data;
 
             cache.put(cacheKey, data, 600);
             ids.push(...data);
         }
 
-        const cacheData = cache.get(cacheKey);
+        const cacheData = await cache.get(cacheKey);
 
         ids.push(...cacheData);
         ids.splice(first);
 
         const storyDataPromises = ids
-            .map(id => {
-                if (cache.has(`${kind}story:${id}`)) {
+            .map(async id => {
+                if (await cache.has(`${kind}story:${id}`)) {
                     return null;
                 }
 
@@ -42,7 +43,7 @@ export function getResolver(storyIds, stories, cache: MemoryCache): any {
             });
 
         for (const id of ids) {
-            const storyItem = cache.get(`${kind}story:${id}`);
+            const storyItem = await cache.get(`${kind}story:${id}`);
 
             if (!storyItem.text || !skipText) {
                 stories.push(storyItem);

src/resolvers/jobs.ts

@@ -10,7 +10,8 @@ export function getResolver(topStoryIds, topStories, cache: any): any {
         const ids: number[] = [];
         const topstoryCacheKey = `${kind}storyids:${first}`;
 
-        if (!cache.has(topstoryCacheKey)) {
+        const hasTopStoryKey = await cache.has(topstoryCacheKey);
+        if (!hasTopStoryKey) {
             // console.log(`getting ${kind}storyids from URL...`);
 
             const resp = await axios.get(`${process.env.HACKERNEWS_API_URL}/${kind}stories.json?limitToFirst=${first}&orderBy="$key"`);
@@ -20,14 +21,14 @@ export function getResolver(topStoryIds, topStories, cache: any): any {
             ids.push(...data);
         }
 
-        const cacheData = cache.get(topstoryCacheKey);
+        const cacheData = await cache.get(topstoryCacheKey);
 
         ids.push(...cacheData);
         ids.splice(first);
 
         const storyDataPromises = ids
-            .map(id => {
-                if (cache.has(`${kind}story:${id}`)) {
+            .map(async id => {
+                if (await cache.has(`${kind}story:${id}`)) {
                     return null;
                 }
 
@@ -45,7 +46,7 @@ export function getResolver(topStoryIds, topStories, cache: any): any {
             });
 
         for (const id of ids) {
-            topStories.push(cache.get(`${kind}story:${id}`));
+            topStories.push(await cache.get(`${kind}story:${id}`));
         }
 
         return new Promise(resolve => resolve(topStories));

src/resolvers/stories.ts

@@ -1,19 +1,21 @@
 /* eslint-disable no-unused-vars */
 
-import { MemoryCache } from '../MemoryCache';
+import { MemoryCache } from '../lib/cache/MemoryCache';
 import axios from 'axios';
 
 export function getResolver(cache: MemoryCache): any {
     const userResolver = async (_, { id }) => {
-        if (cache.has(`user:${id}`)) {
-            return cache.get(`user:${id}`);
+        const hasKey = await cache.has(`user:${id}`);
+
+        if (hasKey) {
+            return await cache.get(`user:${id}`);
         }
 
         const resp = await axios.get(`${process.env.HACKERNEWS_API_URL}/user/${id}.json`);
 
         cache.put(`user:${id}`, resp.data, 3600);
 
-        return cache.get(`user:${id}`);
+        return resp.data;
     };
 
     return userResolver;