perf: Base storage only touches and get tags if tag list is not empty

Additionally fixed all eslint issues and removed any type.

BREAKING CHANGE: fixed typings for get/set and managers. Throw errors if executor returns undefined. Executor should always return value or null - for emptiness

fix: Remove undefined as get return type.

Also removed `E extends Executor<R>` type parameter.

`Record.value` is always defined.

WriteOptions now has type parameter used in getTags signature.

Throw an error if executor returns undefined.

.eslintrc.json

@@ -1,12 +1,18 @@
 {
   "parser": "@typescript-eslint/parser",
-  "plugins": [
-    "@typescript-eslint"
-  ],
+  "plugins": ["@typescript-eslint"],
   "extends": [
     "prettier",
     "eslint:recommended",
     "plugin:@typescript-eslint/eslint-recommended",
     "plugin:@typescript-eslint/recommended"
+  ],
+  "overrides": [
+    {
+      "files": ["src/**/__mocks__/*.ts", "*.spec.ts"],
+      "rules": {
+        "@typescript-eslint/no-explicit-any": "off"
+      }
+    }
   ]
 }

package.json

@@ -27,8 +27,8 @@
     "clean": "rm -rf dist",
     "build": "tsc",
     "watch": "tsc -w",
-    "format": "prettier --write tests/**/*.ts src/**/*.ts",
-    "lint": "prettier -c tests/**/*.ts src/**/*.ts && eslint src/**/*.ts tests/**/*.ts",
+    "format": "prettier --write tests/**/*.ts src/*.ts src/**/*.ts",
+    "lint": "prettier -c tests/**/*.ts src/*.ts src/**/*.ts && eslint src tests --ext .ts --max-warnings 0",
     "check": "npm run lint && npm run test:unit",
     "test": "npm run test:unit",
     "test:unit": "jest --coverage --verbose --passWithNoTests",

src/Cache.ts

@@ -1,14 +1,14 @@
 import defaultsDeep from "lodash/defaultsDeep";
 import { ConnectionStatus } from "./ConnectionStatus";
-import { Executor, ValueOfExecutor } from "./Executor";
-import { ReadWriteOptions, Storage, WriteOptions } from "./storage/Storage";
-import { StorageAdapter } from "./StorageAdapter";
-import { BaseStorage } from "./storage/BaseStorage";
+import { Executor, runExecutor } from "./Executor";
 import { Logger } from "./Logger";
 import { Manager } from "./Manager";
+import { ManagerOptions } from "./managers/BaseManager";
 import RefreshAheadManager from "./managers/RefreshAheadManager";
-import { BaseManager, ManagerOptions } from "./managers/BaseManager";
-import {RecordValue} from "./storage/Record";
+import { BaseStorage } from "./storage/BaseStorage";
+import { Record } from "./storage/Record";
+import { ReadWriteOptions, Storage, WriteOptions } from "./storage/Storage";
+import { StorageAdapter } from "./StorageAdapter";
 
 export interface CacheWithCustomStorageOptions {
   storage: Storage;
@@ -17,20 +17,25 @@ export interface CacheWithBaseStorageOptions {
   adapter: StorageAdapter;
   tagsAdapter?: StorageAdapter;
 }
-export interface ManagerConstructor<T extends BaseManager = any> {
+
+export interface ManagerConstructor<T extends Manager> {
   new (options: ManagerOptions): T;
   getName(): string;
 }
+
 export type CacheOptions = (CacheWithCustomStorageOptions | CacheWithBaseStorageOptions) & {
   logger: Logger;
   expiresIn?: number;
   prefix?: string;
   hashKeys?: boolean;
 };
-export const isCustomStorageOptions = (options: any): options is CacheWithCustomStorageOptions =>
-  Boolean(options.storage);
-export const isBaseStorageOptions = (options: any): options is CacheWithBaseStorageOptions =>
-  Boolean(options.adapter) && !Boolean(options.storage);
+
+export const isCustomStorageOptions = (options: object): options is CacheWithCustomStorageOptions =>
+  Object.prototype.hasOwnProperty.call(options, "storage");
+
+export const isBaseStorageOptions = (options: object): options is CacheWithBaseStorageOptions =>
+  Object.prototype.hasOwnProperty.call(options, "adapter");
+
 export interface ManagerSelectorOptions {
   manager?: string;
 }
@@ -97,19 +102,19 @@ class Cache {
    * Get delegates call to default or provided manager. The only thing it does by itself is checking
    * the connection status of storage. If storage is disconnected calls executor directly and returns result.
    */
-  public async get<E extends Executor>(
+  public async get<R>(
     key: string,
-    executor: E,
-    options: ReadWriteOptions & ManagerSelectorOptions = {}
-  ): Promise<ValueOfExecutor<E>> {
+    executor: Executor<R>,
+    options: ReadWriteOptions<R> & ManagerSelectorOptions = {}
+  ): Promise<R> {
     const connectionStatus = this.storage.getConnectionStatus();
 
     if (connectionStatus !== ConnectionStatus.CONNECTED) {
       this.logger.error(
         `Storage connection status is "${connectionStatus}", cache is unavailable!. Running executor.`
       );
 
-      return executor();
+      return runExecutor(executor);
     }
 
     const { manager: managerName = RefreshAheadManager.getName() } = options;
@@ -122,11 +127,11 @@ class Cache {
   /**
    * Just like "get" this method delegates call to default or provided manager
    */
-  public async set(
+  public async set<R>(
     key: string,
-    value: RecordValue,
-    options: WriteOptions & ManagerSelectorOptions = {}
-  ): Promise<any> {
+    value: R,
+    options: WriteOptions<R> & ManagerSelectorOptions = {}
+  ): Promise<Record<R>> {
     const { manager: managerName = RefreshAheadManager.getName() } = options;
     const computedOptions = defaultsDeep({}, options, { expiresIn: this.expiresIn });
     const manager = this.getManager(managerName);
@@ -145,15 +150,15 @@ class Cache {
    * cache.touch(['news']);
    * ```
    */
-  public async touch(tags: string[]): Promise<any> {
+  public async touch(tags: string[]): Promise<void> {
     return this.storage.touch(tags);
   }
 
   /**
    * Register a new cache manager
    */
-  public registerManager(
-    managerClass: ManagerConstructor,
+  public registerManager<T extends Manager>(
+    managerClass: ManagerConstructor<T>,
     name?: string | null,
     options: Partial<ManagerOptions> = {}
   ): void {

src/Executor.ts

@@ -1,12 +1,22 @@
+import { executorReturnsUndefinedError } from "./errors/errors";
 import { ReadWriteOptions } from "./storage/Storage";
 import { Record } from "./storage/Record";
 
-export interface ExecutorContext {
+export interface ExecutorContext<R> {
   key: string;
-  executor: Executor;
-  options: ReadWriteOptions;
-  record?: Record;
+  executor: Executor<R>;
+  options: ReadWriteOptions<R>;
+  record?: Record<R>;
 }
 
-export type ValueOfExecutor<V extends Executor> = ReturnType<V> extends Promise<infer RT> ? RT : V;
-export type Executor = (...args: any[]) => Promise<any> | any;
+export async function runExecutor<R>(executor: Executor<R>): Promise<R> {
+  const result = await executor();
+
+  if (result === undefined) {
+    throw executorReturnsUndefinedError();
+  }
+
+  return result;
+}
+
+export type Executor<R> = (...args: unknown[]) => Promise<R> | R;

src/LockedKeyRetrieveStrategy.ts

@@ -7,7 +7,7 @@ import { ExecutorContext } from "./Executor";
  */
 export interface LockedKeyRetrieveStrategy {
   getName(): string;
-  get<R = unknown>(context: ExecutorContext): Promise<R>;
+  get<R>(context: ExecutorContext<R>): Promise<R>;
 }
 
 export enum LockedKeyRetrieveStrategyTypes {

src/Logger.ts

@@ -3,8 +3,8 @@
  * errors and trace/debug information
  */
 export interface Logger {
-  info(...args: any[]): void;
-  trace(...args: any[]): void;
-  warn(...args: any[]): void;
-  error(...args: any[]): void;
+  info(...args: unknown[]): void;
+  trace(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
 }

src/Manager.ts

@@ -1,13 +1,13 @@
-import { Executor, ValueOfExecutor } from "./Executor";
+import { Executor } from "./Executor";
 import { WriteOptions, ReadWriteOptions } from "./storage/Storage";
-import {RecordValue} from "./storage/Record";
+import { Record } from "./storage/Record";
 
 /**
  * Manager is the basic interface for all caching classes. Manager must implement
  * two simple methods - get, and set. Cache class will delegate it's get and set calls to manager
  * which must decide what record should be threaten as invalid, when and how to update record
  */
 export interface Manager {
-  get<E extends Executor>(key: string, executor: E, options: ReadWriteOptions): Promise<ValueOfExecutor<E>>;
-  set(key: string, value: RecordValue, options?: WriteOptions): Promise<any>;
+  get<R>(key: string, executor: Executor<R>, options: ReadWriteOptions<R>): Promise<R>;
+  set<R>(key: string, value: R, options?: WriteOptions<R>): Promise<Record<R>>;
 }

src/adapters/RedisStorageAdapter.ts

@@ -63,7 +63,7 @@ export class RedisStorageAdapter implements StorageAdapter {
   /**
    * Implementing this method in the redis adapter will trigger a callback as soon as the redis send event to the 'ready' event.
    */
-  public onConnect(callback: (...args: any[]) => void): void {
+  public onConnect(callback: (...args: unknown[]) => void): void {
     this.redisInstance.on("ready", callback);
   }
 

src/adapters/TestStorageAdapter.ts

@@ -1,5 +1,6 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { ConnectionStatus } from "../ConnectionStatus";
-import { StorageAdapterOptions, StorageAdapter } from "../StorageAdapter";
+import { StorageAdapter, StorageAdapterOptions } from "../StorageAdapter";
 
 class TestStorageAdapter implements StorageAdapter {
   options: StorageAdapterOptions;
@@ -61,9 +62,7 @@ class TestStorageAdapter implements StorageAdapter {
   async releaseLock(key: string): Promise<boolean> {
     this.checkConnection();
 
-    const isDeleted = await this.del(`${key}_lock`);
-
-    return isDeleted;
+    return this.del(`${key}_lock`);
   }
 
   async isLockExists(key: string): Promise<boolean> {

src/deserialize.spec.ts

@@ -1,12 +1,7 @@
 import deserialize from "./deserialize";
 
 describe("deserizalize", () => {
-  it("returns undefined as is", () => {
-    expect(deserialize(undefined)).toEqual(undefined);
-  });
-
   it("parses valid json string or null", () => {
-    expect(deserialize(null)).toEqual(null);
     expect(deserialize("null")).toEqual(null);
     expect(deserialize('"test"')).toEqual("test");
     expect(deserialize("1")).toEqual(1);

src/deserialize.ts

@@ -1,10 +1,6 @@
 import * as errors from "./errors/errors";
 
-export default function(value: any): any {
-  if (value === undefined) {
-    return value;
-  }
-
+export default function<R>(value: string): R {
   try {
     return JSON.parse(value);
   } catch (error) {

src/errors/constants.ts

@@ -3,4 +3,5 @@ export const ERRORS = {
   RequestMaximumTimeoutExceededError: "RequestMaximumTimeoutExceededError",
   WaitForResultError: "WaitForResultError",
   OperationTimeoutError: "OperationTimeoutError",
+  ExecutorReturnsUndefinedError: "ExecutorReturnsUndefinedError",
 };

src/errors/errors.ts

@@ -26,3 +26,9 @@ export function operationTimeoutError(timeout: number): Error {
 export function isOperationTimeoutError(error: unknown): boolean {
   return error instanceof Error && error.name === ERRORS.OperationTimeoutError;
 }
+
+export function executorReturnsUndefinedError(): Error {
+  const text = "Executor should not return undefined. Correct value for emptiness is null.";
+
+  return customError(ERRORS.ExecutorReturnsUndefinedError, text);
+}

src/index.ts

@@ -1,6 +1,6 @@
 import { StorageAdapter, StorageAdapterOptions } from "./StorageAdapter";
 import { Tag, Tags } from "./storage/Storage";
-import {Record, RecordValue} from "./storage/Record";
+import { Record } from "./storage/Record";
 import Cache, { CacheOptions } from "./Cache";
 import RedisStorageAdapter from "./adapters/RedisStorageAdapter";
 import MemcachedStorageAdapter from "./adapters/MemcachedStorageAdapter";
@@ -14,7 +14,6 @@ export {
   StorageAdapterOptions,
   Record,
   Tag,
-  RecordValue,
   Tags,
   RedisStorageAdapter,
   MemcachedStorageAdapter,

src/locked-key-retrieve-strategies/RunExecutorLockedKeyRetrieveStrategy.ts

@@ -1,5 +1,5 @@
 import { LockedKeyRetrieveStrategy } from "../LockedKeyRetrieveStrategy";
-import { ExecutorContext } from "../Executor";
+import { ExecutorContext, runExecutor } from "../Executor";
 
 /**
  * This locked key retrieve strategy is default and suitable for most cases. It just
@@ -10,7 +10,7 @@ export class RunExecutorLockedKeyRetrieveStrategy implements LockedKeyRetrieveSt
     return "runExecutor";
   }
 
-  async get(context: ExecutorContext): Promise<any> {
-    return context.executor();
+  async get<R>(context: ExecutorContext<R>): Promise<R> {
+    return runExecutor(context.executor);
   }
 }

src/locked-key-retrieve-strategies/WaitForResultLockedKeyRetrieveStrategy.spec.ts

@@ -38,6 +38,14 @@ describe("WaitForResultLockedKeyRetrieveStrategy", () => {
     expect(instance.getName()).toEqual(expect.any(String));
   });
 
+  it("get deserializes value", async () => {
+    keyLockCheckFnMock.mockReturnValue(false);
+    getRecordMock.mockReturnValue({ value: `{"a":1}` });
+
+    expect(await instance.get({ key: "test" })).toEqual({ a: 1 });
+    getRecordMock.mockReset();
+  });
+
   it("get throws if null in cache", async () => {
     getRecordMock.mockReturnValue(null);
     await expect(instance.get({ key: "test" })).rejects.toThrow("Error while waiting for result in cache");
@@ -53,12 +61,4 @@ describe("WaitForResultLockedKeyRetrieveStrategy", () => {
     await expect(instance.get({ key: "test" })).rejects.toThrow("Exceeded maximum timeout of 100");
     keyLockCheckFnMock.mockReset();
   });
-
-  it("get returns undefined if record value is undefined", async () => {
-    keyLockCheckFnMock.mockReturnValue(false);
-    getRecordMock.mockReturnValue({ value: undefined });
-
-    expect(await instance.get({ key: "test" })).toEqual(undefined);
-    getRecordMock.mockReset();
-  });
 });

src/locked-key-retrieve-strategies/WaitForResultLockedKeyRetrieveStrategy.ts

@@ -10,7 +10,7 @@ export const DEFAULT_MAXIMUM_TIMEOUT = 3000;
 export const DEFAULT_REQUEST_TIMEOUT = 250;
 
 export type KeyLockCheckFn = (key: string) => boolean | Promise<boolean>;
-export type GetRecordFn = (key: string) => Promise<any>;
+export type GetRecordFn = <R>(key: string) => Promise<Record<R> | null>;
 export type WaitForResultLockedKeyRetrieveStrategyOptions = {
   maximumTimeout?: number;
   requestTimeout?: number;
@@ -44,21 +44,21 @@ export class WaitForResultLockedKeyRetrieveStrategy implements LockedKeyRetrieve
     return "waitForResult";
   }
 
-  public async get(context: ExecutorContext): Promise<any> {
+  public async get<R>(context: ExecutorContext<R>): Promise<R> {
     const startTime = Date.now();
-    const retryRequest = async (): Promise<any> => {
+    const retryRequest = async (): Promise<R> => {
       if (Date.now() < startTime + this.maximumTimeout) {
         const isLocked = await this.keyIsLocked(context.key);
 
         if (!isLocked) {
-          const rec: Record | null = await this.getRecord(context.key);
+          const rec = await this.getRecord<string>(context.key);
 
           switch (rec) {
             case null:
             case undefined:
               throw errors.waitForResultError();
             default:
-              return deserialize(rec.value);
+              return deserialize<R>(rec.value);
           }
         }