fix: better typing

Author: Krzysztof Borowy

packages/core/src/AsyncStorage.ts

@@ -1,19 +1,26 @@
+/**
+ * Copyright (c) React Native Community.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
 import {simpleErrorHandler, simpleLogger, noop} from './defaults';
 import {
   FactoryOptions,
   IStorageBackend,
   LoggerAction,
-  StorageModel,
   StorageOptions,
 } from '../types';
 
-class AsyncStorage<STR extends IStorageBackend, VAL = StorageModel<STR>> {
-  private readonly _backend: STR;
+class AsyncStorage<M, T extends IStorageBackend<M>> {
+  private readonly _backend: T;
   private readonly _config: FactoryOptions;
   private readonly log: (action: LoggerAction) => void;
   private readonly error: (e: Error | string) => void;
 
-  constructor(storageBackend: STR, asOptions: FactoryOptions) {
+  constructor(storageBackend: T, asOptions: FactoryOptions) {
     this._backend = storageBackend;
     this._config = asOptions;
 
@@ -35,13 +42,15 @@ class AsyncStorage<STR extends IStorageBackend, VAL = StorageModel<STR>> {
           : simpleErrorHandler;
     }
   }
-
-  async get(key: string, opts: StorageOptions = null): Promise<VAL | null> {
-    let value = null;
+  async get<K extends keyof M>(
+    key: K,
+    opts: StorageOptions = null,
+  ): Promise<M[K] | null> {
+    let value = null as M[K] | null;
     try {
       this.log({
         action: 'read-single',
-        key: key,
+        key: key as string,
       });
       value = await this._backend.getSingle(key, opts);
     } catch (e) {
@@ -51,15 +60,15 @@ class AsyncStorage<STR extends IStorageBackend, VAL = StorageModel<STR>> {
     return value;
   }
 
-  async set(
-    key: string,
-    value: VAL,
+  async set<K extends keyof M>(
+    key: K,
+    value: M[K],
     opts: StorageOptions = null,
   ): Promise<void> {
     try {
       this.log({
         action: 'save-single',
-        key,
+        key: key as string,
         value,
       });
       await this._backend.setSingle(key, value, opts);
@@ -68,16 +77,16 @@ class AsyncStorage<STR extends IStorageBackend, VAL = StorageModel<STR>> {
     }
   }
 
-  async getMultiple(
-    keys: Array<string>,
+  async getMultiple<K extends keyof M>(
+    keys: Array<K>,
     opts: StorageOptions = null,
-  ): Promise<Array<VAL | null>> {
-    let values: Array<VAL | null> = [];
+  ): Promise<{[k in K]: M[k] | null}> {
+    let values = {} as {[k in K]: M[k] | null};
 
     try {
       this.log({
         action: 'read-many',
-        key: keys,
+        key: keys as string[],
       });
       values = await this._backend.getMany(keys, opts);
     } catch (e) {
@@ -87,8 +96,8 @@ class AsyncStorage<STR extends IStorageBackend, VAL = StorageModel<STR>> {
     return values;
   }
 
-  async setMultiple(
-    keyValues: Array<{[key: string]: VAL}>,
+  async setMultiple<K extends keyof M>(
+    keyValues: Array<{[k in K]: M[k]}>,
     opts: StorageOptions = null,
   ): Promise<void> {
     try {
@@ -102,11 +111,11 @@ class AsyncStorage<STR extends IStorageBackend, VAL = StorageModel<STR>> {
     }
   }
 
-  async remove(key: string, opts: StorageOptions = null): Promise<void> {
+  async remove(key: keyof M, opts: StorageOptions = null): Promise<void> {
     try {
       this.log({
         action: 'delete-single',
-        key,
+        key: key as string,
       });
       await this._backend.removeSingle(key, opts);
     } catch (e) {
@@ -115,22 +124,22 @@ class AsyncStorage<STR extends IStorageBackend, VAL = StorageModel<STR>> {
   }
 
   async removeMultiple(
-    keys: Array<string>,
+    keys: Array<keyof M>,
     opts: StorageOptions = null,
   ): Promise<void> {
     try {
       this.log({
         action: 'delete-many',
-        key: keys,
+        key: keys as string[],
       });
       await this._backend.removeMany(keys, opts);
     } catch (e) {
       this.error(e);
     }
   }
 
-  async getKeys(opts: StorageOptions = null): Promise<Array<string>> {
-    let keys: Array<string> = [];
+  async getKeys(opts: StorageOptions = null): Promise<Array<keyof M>> {
+    let keys: Array<keyof M> = [];
 
     try {
       this.log({
@@ -157,7 +166,7 @@ class AsyncStorage<STR extends IStorageBackend, VAL = StorageModel<STR>> {
 
   // todo: think how we could provide additional functions through AS, without returning the instance
   // some kind of extension-like functionality
-  instance(): STR {
+  instance(): T {
     return this._backend;
   }
 }

packages/core/src/defaults.ts

@@ -1,3 +1,11 @@
+/**
+ * Copyright (c) React Native Community.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
 import {FactoryOptions, LoggerAction} from '../types';
 
 export const factoryOptions: FactoryOptions = {

packages/core/src/index.ts

@@ -1,6 +1,14 @@
+/**
+ * Copyright (c) React Native Community.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
 import AsyncStorage from './AsyncStorage';
 import {factoryOptions} from './defaults';
-import {IStorageBackend, FactoryOptions, StorageModel} from '../types';
+import {IStorageBackend, FactoryOptions, EmptyStorageModel} from '../types';
 
 class AsyncStorageFactory {
   constructor() {
@@ -9,11 +17,11 @@ class AsyncStorageFactory {
     );
   }
 
-  static create<STR extends IStorageBackend>(
-    storage: STR,
+  static create<M = EmptyStorageModel>(
+    storage: IStorageBackend,
     opts: FactoryOptions = factoryOptions,
-  ): AsyncStorage<STR, StorageModel<STR>> {
-    return new AsyncStorage(storage, opts);
+  ) {
+    return new AsyncStorage<M, IStorageBackend<M>>(storage, opts);
   }
 }
 

packages/core/types/index.d.ts

@@ -1,63 +1,94 @@
-export class AsyncStorage<
-  STR extends IStorageBackend,
-  VAL = StorageModel<STR>
-> {
-  get(key: string, opts?: StorageOptions): Promise<VAL | null>;
+/**
+ * Copyright (c) React Native Community.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Crates an Async Storage instance for given storage backend
+ * Enhanced by Factory Options, to, in example, enable logging
+ */
+export default class AsyncStorageFactory {
+  static create<M = EmptyStorageModel>(
+    storage: IStorageBackend,
+    opts: FactoryOptions,
+  ): AsyncStorage<M, IStorageBackend<M>>;
+}
+
+/**
+ * Do not instantiate. Create through AsyncStorageFactory.
+ * Main API that will be used to call underlying storage backend
+ */
+export class AsyncStorage<M, T extends IStorageBackend<M>> {
+  get<K extends keyof M>(key: K, opts?: StorageOptions): Promise<M[K] | null>;
 
-  set(key: string, value: VAL, opts?: StorageOptions): Promise<void>;
+  set<K extends keyof M>(
+    key: K,
+    value: M[K],
+    opts?: StorageOptions,
+  ): Promise<void>;
 
-  getMultiple(
-    keys: Array<string>,
+  getMultiple<K extends keyof M>(
+    keys: Array<K>,
     opts?: StorageOptions,
-  ): Promise<Array<VAL | null>>;
+  ): Promise<{[k in K]: M[k] | null}>;
 
-  setMultiple(
-    keyValues: Array<{[key: string]: VAL}>,
+  setMultiple<K extends keyof M>(
+    keyValues: Array<Partial<{[k in keyof M]: M[k]}>>,
     opts?: StorageOptions,
   ): Promise<void>;
 
-  remove(key: string, opts?: StorageOptions): Promise<void>;
+  remove(key: keyof M, opts?: StorageOptions): Promise<void>;
 
-  removeMultiple(keys: Array<string>, opts?: StorageOptions): Promise<void>;
+  removeMultiple(keys: Array<keyof M>, opts?: StorageOptions): Promise<void>;
 
-  getKeys(opts?: StorageOptions): Promise<Array<string>>;
+  getKeys(opts?: StorageOptions): Promise<Array<keyof M>>;
 
   clearStorage(opts?: StorageOptions): Promise<void>;
 
-  instance(): STR;
+  instance(): T;
 }
 
-export default class AsyncStorageFactory {
-  static create<STR extends IStorageBackend>(
-    storage: STR,
-    opts: FactoryOptions,
-  ): AsyncStorage<STR, StorageModel<STR>>;
-}
-
-export interface IStorageBackend<VAL = any> {
-  getSingle(key: string, opts?: StorageOptions): Promise<VAL | null>;
+/**
+ * Interface that must be implemented by any Storage Backend
+ * Provides basic API for reading/writing and deleting of data
+ */
+export interface IStorageBackend<T = EmptyStorageModel> {
+  getSingle<K extends keyof T>(
+    key: K,
+    opts?: StorageOptions,
+  ): Promise<T[K] | null>;
 
-  setSingle(key: string, value: VAL, opts?: StorageOptions): Promise<void>;
+  setSingle<K extends keyof T>(
+    key: K,
+    value: T[K],
+    opts?: StorageOptions,
+  ): Promise<void>;
 
-  getMany(
-    keys: Array<string>,
+  getMany<K extends keyof T>(
+    keys: Array<K>,
     opts?: StorageOptions,
-  ): Promise<Array<VAL | null>>;
+  ): Promise<{[k in K]: T[k] | null}>;
 
-  setMany(
-    values: Array<{[key: string]: VAL}>,
+  setMany<K extends keyof T>(
+    values: Array<{[k in K]: T[k]}>,
     opts?: StorageOptions,
   ): Promise<void>;
 
-  removeSingle(key: string, opts?: StorageOptions): Promise<void>;
+  removeSingle(key: keyof T, opts?: StorageOptions): Promise<void>;
 
-  removeMany(keys: Array<string>, opts?: StorageOptions): Promise<void>;
+  removeMany(keys: Array<keyof T>, opts?: StorageOptions): Promise<void>;
 
-  getKeys(opts?: StorageOptions): Promise<Array<string>>;
+  getKeys(opts?: StorageOptions): Promise<Array<keyof T>>;
 
   dropStorage(opts?: StorageOptions): Promise<void>;
 }
 
+/**
+ * Used by Factory to enhance calls
+ */
 export type FactoryOptions = {
   logger?: ((action: LoggerAction) => void) | boolean;
   errorHandler?: ((error: Error | string) => void) | boolean;
@@ -78,8 +109,12 @@ export type LoggerAction = {
   key?: string | Array<string>;
 };
 
+// Helper types
+
 export type StorageModel<T> = T extends IStorageBackend<infer V> ? V : any;
 
+export type EmptyStorageModel = {[key in symbol | number | string]: any};
+
 export type StorageOptions = {
   [key: string]: any;
 } | null;