Initial development (#1)

Author: Lee Brooks

.eslintrc.js

@@ -0,0 +1,14 @@
+module.exports = {
+    root: true,
+    parser: '@typescript-eslint/parser',
+    plugins: [
+        '@typescript-eslint',
+    ],
+    extends: [
+        'airbnb-typescript/base',
+    ],
+    rules: {
+        '@typescript-eslint/indent': ['error', 4],
+        'arrow-parens': ['error', 'as-needed']
+    },
+};

.gitignore

@@ -1,4 +1,3 @@
-/coverage
 /node_modules
 /lib
 package-lock.json

.travis.yml

@@ -1,21 +1,38 @@
-# Node Package Template
+# Cache JS
 
-A template repository for a Node.js package using TypeScript.
+[![Build Status](https://travis-ci.com/Pod-Point/cache-js.svg?branch=master)](https://travis-ci.com/Pod-Point/cache-js)
+
+A cache service for JS.
 
 ## Usage
 
-See the following link for how to create a repository from a template:
-https://help.github.com/en/articles/creating-a-repository-from-a-template
+To install this package, run the following command:
+```bash
+npm install @pod-point/cache-js
+```
 
-### Installation
+Once installed, simply create a new instance of the Cache service and begin using it e.g.
+```
+import { Redis } from '@pod-point/cache-js';
 
-To install the latest version of this templates  dev dependencies, run the following command:
-```bash
-npm install --save-dev @types/faker @types/jest @pod-point/tslint-config-podpoint-base faker jest ts-jest tslint typescript
+const cacheService = new Redis();
+
+await cacheService.put('foo', 'bar');
 ```
 
+There are only 3 simple methods a cache service can carry out, and these are `put`, `get` and `remove`, all fairly self-explanatory!
+
+When putting key/value pairs into the cache you can also set an expiry date, or a time in seconds until it should expire.
+
 ## Development
 
+### Installation
+
+To install this packages dependencies, run the following command:
+```bash
+npm install
+```
+
 ### Testing
 
 This package uses jest. To run the test suites for this project, run the following command:

README.md

@@ -1,31 +1,50 @@
 {
-  "name": "@pod-point/node-package",
-  "version": "1.0.0",
-  "description": "A template repository for a Node.js package using TypeScript.",
+  "name": "@pod-point/cache-js",
+  "version": "1.0.2",
+  "description": "A cache service for JS.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "author": "Pod Point Software Team <software@pod-point.com>",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Pod-Point/node-package.git"
+    "url": "git+https://github.com/Pod-Point/cache-js.git"
   },
   "bugs": {
-    "url": "https://github.com/Pod-Point/node-package/issues"
+    "url": "https://github.com/Pod-Point/cache-js/issues"
   },
-  "homepage": "https://github.com/Pod-Point/node-package#readme",
+  "homepage": "https://github.com/Pod-Point/cache-js#readme",
   "keywords": [
-    "TypeScript"
+    "TypeScript",
+    "JavaScript",
+    "Cache",
+    "Redis"
   ],
   "scripts": {
     "build": "node_modules/.bin/tsc",
-    "lint": "node_modules/.bin/tslint 'src/**/*.{ts,tsx}'",
+    "lint": "node_modules/.bin/eslint 'src/**/*.{ts,tsx}'",
     "lint:fix": "npm run lint -- --fix",
     "test": "node_modules/.bin/jest --watch",
     "test:coverage": "node_modules/.bin/jest --coverage --runInBand --ci"
   },
-  "dependencies": {},
-  "devDependencies": {},
+  "dependencies": {
+    "redis": "^2.8.0"
+  },
+  "devDependencies": {
+    "@types/faker": "^4.1.8",
+    "@types/jest": "^24.0.25",
+    "@types/node": "^13.1.1",
+    "@types/redis": "^2.8.14",
+    "@typescript-eslint/eslint-plugin": "^2.13.0",
+    "@typescript-eslint/parser": "^2.13.0",
+    "eslint": "^6.8.0",
+    "eslint-config-airbnb-typescript": "^6.3.1",
+    "eslint-plugin-import": "^2.19.1",
+    "faker": "^4.1.0",
+    "jest": "^24.9.0",
+    "ts-jest": "^24.2.0",
+    "typescript": "^3.7.4"
+  },
   "jest": {
     "collectCoverageFrom": [
       "src/**/*.ts",

package.json

@@ -0,0 +1,85 @@
+import { createClient } from 'redis';
+import Redis from '../../../services/Redis';
+
+const mockSet = jest.fn((key, value, cb) => cb());
+const mockQuit = jest.fn();
+const mockDel = jest.fn((key, cb) => cb());
+const mockExpire = jest.fn((key, time, cb) => cb());
+const mockExpireAt = jest.fn((key, time, cb) => cb());
+const mockGet = jest.fn((key, cb) => cb(null, 'someData'));
+
+jest.mock('redis', () => ({
+    createClient: jest.fn(() => ({
+        del: mockDel,
+        expire: mockExpire,
+        expireat: mockExpireAt,
+        get: mockGet,
+        set: mockSet,
+        quit: mockQuit,
+    })),
+}));
+
+describe('services/redis/Redis', () => {
+    const key = 'foo';
+    const value = 'bar';
+
+    [true, false].forEach(ephemeral => {
+        const isEphemeral = ephemeral ? 'ephemeral' : 'nonEphemeral';
+        const cache = new Redis({}, ephemeral);
+
+        describe(isEphemeral, () => {
+            beforeEach(() => {
+                mockQuit.mockReset();
+            });
+
+            afterEach(() => {
+                if (ephemeral) {
+                    expect(createClient).toHaveBeenCalled();
+                    expect(mockQuit).toHaveBeenCalledWith();
+                }
+            });
+
+            it('persists the key/value pair in the cache', async () => {
+                await cache.put(key, value);
+
+                expect(mockSet).toHaveBeenCalledWith('foo', 'bar', expect.any(Function));
+            });
+
+            it('persists the key/value pair in the cache to expire at a particular time', async () => {
+                const timestamp = (new Date()).getTime();
+                await cache.put(key, value, {
+                    at: timestamp,
+                });
+
+                expect(mockSet).toHaveBeenCalledWith('foo', 'bar', expect.any(Function));
+                expect(mockExpireAt).toHaveBeenCalledWith(
+                    'foo',
+                    timestamp,
+                    expect.any(Function),
+                );
+            });
+
+            it('persists the key/value pair in the cache to expire in a given number of seconds', async () => {
+                await cache.put(key, value, {
+                    in: 1,
+                });
+
+                expect(mockSet).toHaveBeenCalledWith('foo', 'bar', expect.any(Function));
+                expect(mockExpire).toHaveBeenCalledWith('foo', 1, expect.any(Function));
+            });
+
+            it('retrieves the keys value from the cache', async () => {
+                const data = await cache.get(key);
+
+                expect(mockGet).toHaveBeenCalledWith('foo', expect.any(Function));
+                expect(data).toEqual('someData');
+            });
+
+            it('removes the key/value pair from the cache', async () => {
+                await cache.remove(key);
+
+                expect(mockDel).toHaveBeenCalledWith('foo', expect.any(Function));
+            });
+        });
+    });
+});

src/__tests__/services/redis/Redis.test.ts

@@ -1 +1,2 @@
-// Export all the things from here.
+export { default as Redis } from './services/Redis';
+export { default as Service } from './types/Service';

src/index.ts

@@ -0,0 +1,101 @@
+import { ClientOpts, createClient } from 'redis';
+import { promisify } from 'util';
+import Expire from '../types/Expire';
+import Service from '../types/Service';
+import RedisService from '../types/redis/Service';
+
+class Redis implements Service {
+    private config: ClientOpts;
+
+    private ephemeral: boolean;
+
+    private service: RedisService;
+
+    /**
+     * Creates a Redis client instance depending on config.
+     */
+    public constructor(config?: ClientOpts, ephemeral?: boolean) {
+        this.ephemeral = ephemeral;
+        this.config = config;
+
+        if (!this.ephemeral) {
+            this.service = this.getService(true);
+        }
+    }
+
+    /**
+     * Retrieves the keys value from the cache.
+     */
+    public async get(key: string): Promise<string> {
+        const service = this.getService();
+
+        const value = await service.get(key);
+
+        this.quitIfNeeded(service);
+
+        return value;
+    }
+
+    /**
+     * Persists the key/value pair in the cache,
+     * optionally setting it to expire at a particular time or in a given number of seconds.
+     */
+    public async put(key: string, value: string, expire?: Expire): Promise<void> {
+        const service = this.getService();
+
+        await service.set(key, value);
+
+        if (expire) {
+            if (expire.at) {
+                await service.expireAt(key, expire.at);
+            }
+
+            if (expire.in) {
+                await service.expire(key, expire.in);
+            }
+        }
+
+        this.quitIfNeeded(service);
+    }
+
+    /**
+     * Removes the key/value pair from the cache.
+     */
+    public async remove(key: string): Promise<void> {
+        const service = this.getService();
+
+        await service.del(key);
+
+        this.quitIfNeeded(service);
+    }
+
+    /**
+     * Quits the redis client if required.
+     */
+    private async quitIfNeeded(service): Promise<void> {
+        if (this.ephemeral) {
+            service.client.quit();
+        }
+    }
+
+    /**
+     * Creates new Redis instance if one does not already exist or if is configured to be ephemeral.
+     */
+    private getService(force: boolean = false): RedisService {
+        if (this.ephemeral || force) {
+            const client = createClient(this.config);
+            this.service = {
+                client,
+                del: promisify(client.del).bind(client),
+                expire: promisify(client.expire).bind(client),
+                expireAt: promisify(client.expireat).bind(client),
+                get: promisify(client.get).bind(client),
+                set: promisify(client.set).bind(client),
+            };
+        }
+
+        return this.service;
+    }
+}
+
+export default Redis;

src/services/Redis.ts

@@ -0,0 +1,13 @@
+interface Expire {
+    /**
+     * The timestamp when the key/value pair should expire.
+     */
+    at?: number;
+
+    /**
+     * The number of seconds until the key/value pair should expire.
+     */
+    in?: number;
+}
+
+export default Expire;

src/types/Expire.ts

@@ -0,0 +1,18 @@
+interface Service {
+    /**
+     * Retrieves the keys value from the cache.
+     */
+    get(key: string): Promise<string>;
+
+    /**
+     * Persists the key/value pair in the cache.
+     */
+    put(key: string, value: string): Promise<void>;
+
+    /**
+     * Removes the key/value pair from the cache.
+     */
+    remove(key: string): Promise<void>;
+}
+
+export default Service;

src/types/Service.ts

@@ -0,0 +1,12 @@
+import { RedisClient } from 'redis';
+
+interface RedisService {
+    client: RedisClient,
+    del: (key: string) => Promise<void>;
+    expire: (key: string, seconds: number) => Promise<void>;
+    expireAt: (key: string, seconds: number) => Promise<void>;
+    get: (key: string) => Promise<string>;
+    set: (key: string, value: string) => Promise<void>;
+}
+
+export default RedisService;