From 2560aae28d642c8f2e8ee5920dc1cc15f7c8c3f6 Mon Sep 17 00:00:00 2001
From: azu <azuciao@gmail.com>
Date: Sun, 9 Aug 2020 01:22:51 +0900
Subject: [PATCH 1/6] feat(storage): use Schema interface

---
 packages/storage/README.md          | 29 +++++++++-
 packages/storage/src/storage.ts     | 77 ++++++++++++++------------
 packages/storage/test/index.test.ts | 23 ++++++++
 packages/types/src/index.ts         | 85 +++++++++++++++++++++--------
 4 files changed, 154 insertions(+), 60 deletions(-)

diff --git a/packages/storage/README.md b/packages/storage/README.md
index 35908e0..5ed4ba3 100644
--- a/packages/storage/README.md
+++ b/packages/storage/README.md
@@ -1,6 +1,8 @@
 # @kvs/storage
 
-localstorage for KVS.
+Storage-like for KVS.
+
+You can inject Storage object like localStorage, sessionStorage to this storage.
 
 ## Install
 
@@ -10,7 +12,30 @@ Install with [npm](https://www.npmjs.com/):
 
 ## Usage
 
-- [ ] Write usage instructions
+```ts
+import { kvsStorage } from "@kvs/storage";
+(async () => {
+    type StorageSchema = {
+        a1: string;
+        b2: number;
+        c3: boolean;
+    };
+    const storage = await kvsStorage<StorageSchema>({
+        name: "test",
+        version: 1,
+        storage: localStorage
+    });
+    await storage.set("a1", "string");
+    await storage.set("b2", 42);
+    await storage.set("c3", false);
+    const a1 = await storage.get("a1");
+    const b2 = await storage.get("b2");
+    const c3 = await storage.get("c3");
+    assert.strictEqual(a1, "string");
+    assert.strictEqual(b2, 42);
+    assert.strictEqual(c3, false);
+})()
+```
 
 ## Changelog
 
diff --git a/packages/storage/src/storage.ts b/packages/storage/src/storage.ts
index 08b8217..c078624 100644
--- a/packages/storage/src/storage.ts
+++ b/packages/storage/src/storage.ts
@@ -1,50 +1,51 @@
-import type { KVS, KVSOptions } from "@kvs/types";
+import type { KVS, KVSOptions, StoreNames, StoreValue } from "@kvs/types";
 import { JsonValue } from "./JSONValue";
 
 export type KVSStorageKey = string;
-export const getItem = <K extends KVSStorageKey>(storage: Storage, key: K) => {
-    const item = storage.getItem(key);
+export const getItem = <Schema extends StorageSchema>(storage: Storage, key: StoreNames<Schema>) => {
+    const item = storage.getItem(String(key));
     return item !== null ? JSON.parse(item) : undefined;
 };
-export const hasItem = <K extends KVSStorageKey>(storage: Storage, key: K) => {
-    return storage.getItem(key) !== null;
+export const hasItem = <Schema extends StorageSchema>(storage: Storage, key: StoreNames<Schema>) => {
+    return storage.getItem(String(key)) !== null;
 };
-export const setItem = <K extends KVSStorageKey, V extends JsonValue | undefined>(
+export const setItem = <Schema extends StorageSchema>(
     storage: Storage,
-    key: K,
-    value: V
+    key: StoreNames<Schema>,
+    value: StoreValue<Schema, StoreNames<Schema>> | undefined
 ) => {
     // It is difference with IndexedDB implementation.
     // This behavior compatible with localStorage.
     if (value === undefined) {
         return deleteItem(storage, key);
     }
-    return storage.setItem(key, JSON.stringify(value));
+    return storage.setItem(String(key), JSON.stringify(value));
 };
 export const clearItem = (storage: Storage, kvsVersionKey: string) => {
-    const currentVersion: number | undefined = getItem(storage, kvsVersionKey);
+    // TODO: kvsVersionKey is special type
+    const currentVersion: number | undefined = getItem<any>(storage, kvsVersionKey);
     // clear all
     storage.clear();
     // set kvs version again
     if (currentVersion !== undefined) {
-        setItem(storage, kvsVersionKey, currentVersion);
+        setItem<any>(storage, kvsVersionKey, currentVersion);
     }
 };
-export const deleteItem = <K extends KVSStorageKey>(storage: Storage, key: K) => {
+export const deleteItem = <Schema extends StorageSchema>(storage: Storage, key: StoreNames<Schema>): boolean => {
     try {
-        storage.removeItem(key);
+        storage.removeItem(String(key));
         return true;
     } catch {
         return false;
     }
 };
 
-export function* createIterator<K extends KVSStorageKey, V extends JsonValue>(
+export function* createIterator<Schema extends StorageSchema>(
     storage: Storage,
     kvsVersionKey: string
-): Iterator<[K, V]> {
+): Iterator<[StoreNames<Schema>, StoreValue<Schema, StoreNames<Schema>>]> {
     for (let i = 0; i < storage.length; i++) {
-        const key = storage.key(i);
+        const key = storage.key(i) as StoreNames<Schema> | undefined;
         if (!key) {
             continue;
         }
@@ -53,7 +54,7 @@ export function* createIterator<K extends KVSStorageKey, V extends JsonValue>(
             continue;
         }
         const value = getItem(storage, key);
-        yield [key, value] as [K, V];
+        yield [key, value];
     }
 }
 
@@ -77,9 +78,10 @@ const openStorage = async ({
         storage: Storage;
     }) => any;
 }) => {
-    const oldVersion = getItem(storage, kvsVersionKey);
+    // kvsVersionKey is special type
+    const oldVersion = getItem<any>(storage, kvsVersionKey);
     if (oldVersion === undefined) {
-        setItem(storage, kvsVersionKey, DEFAULT_KVS_VERSION);
+        setItem<any>(storage, kvsVersionKey, DEFAULT_KVS_VERSION);
     }
     // if user set newVersion, upgrade it
     if (oldVersion !== version) {
@@ -95,28 +97,28 @@ const openStorage = async ({
     }
     return storage;
 };
-const createStore = <K extends KVSStorageKey, V extends JsonValue>({
+const createStore = <Schema extends StorageSchema>({
     storage,
     kvsVersionKey
 }: {
     storage: Storage;
     kvsVersionKey: string;
 }) => {
-    const store = {
-        get(key: K): Promise<V | undefined> {
+    const store: KvsStorage<Schema> = {
+        get<K extends StoreNames<Schema>>(key: K): Promise<StoreValue<Schema, K> | undefined> {
             return Promise.resolve().then(() => {
-                return getItem(storage, key);
+                return getItem<Schema>(storage, key);
             });
         },
-        has(key: K): Promise<boolean> {
+        has(key: StoreNames<Schema>): Promise<boolean> {
             return Promise.resolve().then(() => {
-                return hasItem(storage, key);
+                return hasItem<Schema>(storage, key);
             });
         },
-        set(key: K, value: V | undefined): Promise<KVS<K, V>> {
+        set<K extends StoreNames<Schema>>(key: K, value: StoreValue<Schema, K> | undefined) {
             return Promise.resolve()
                 .then(() => {
-                    return setItem(storage, key, value);
+                    return setItem<Schema>(storage, key, value);
                 })
                 .then(() => {
                     return store;
@@ -127,17 +129,17 @@ const createStore = <K extends KVSStorageKey, V extends JsonValue>({
                 return clearItem(storage, kvsVersionKey);
             });
         },
-        delete(key: K): Promise<boolean> {
+        delete(key: StoreNames<Schema>): Promise<boolean> {
             return Promise.resolve().then(() => {
-                return deleteItem(storage, key);
+                return deleteItem<Schema>(storage, key);
             });
         },
         close(): Promise<void> {
             // Noop function
             return Promise.resolve();
         },
-        [Symbol.asyncIterator](): AsyncIterator<[K, V]> {
-            const iterator = createIterator<K, V>(storage, kvsVersionKey);
+        [Symbol.asyncIterator](): AsyncIterator<[StoreNames<Schema>, StoreValue<Schema, StoreNames<Schema>>]> {
+            const iterator = createIterator<Schema>(storage, kvsVersionKey);
             return {
                 next() {
                     return Promise.resolve().then(() => {
@@ -149,14 +151,17 @@ const createStore = <K extends KVSStorageKey, V extends JsonValue>({
     };
     return store;
 };
-export type KvsStorage<K extends KVSStorageKey, V extends JsonValue> = KVS<K, V>;
-export type KvsStorageOptions<K extends KVSStorageKey, V extends JsonValue> = KVSOptions<K, V> & {
+export type StorageSchema = {
+    [index: string]: JsonValue;
+};
+export type KvsStorage<Schema extends StorageSchema> = KVS<Schema>;
+export type KvsStorageOptions<Schema extends StorageSchema> = KVSOptions<Schema> & {
     kvsVersionKey?: string;
     storage: Storage;
 };
-export const kvsStorage = async <K extends KVSStorageKey, V extends JsonValue>(
-    options: KvsStorageOptions<K, V>
-): Promise<KvsStorage<K, V>> => {
+export const kvsStorage = async <Schema extends StorageSchema>(
+    options: KvsStorageOptions<Schema>
+): Promise<KvsStorage<Schema>> => {
     const { name, version, upgrade, ...kvStorageOptions } = options;
     const kvsVersionKey = kvStorageOptions.kvsVersionKey ?? "__kvs_version__";
     const storage = await openStorage({
diff --git a/packages/storage/test/index.test.ts b/packages/storage/test/index.test.ts
index 111b1df..032330a 100644
--- a/packages/storage/test/index.test.ts
+++ b/packages/storage/test/index.test.ts
@@ -1,3 +1,4 @@
+import assert from "assert";
 import { kvsStorage } from "../src";
 import { createKVSTestCase } from "@kvs/common-test-case";
 
@@ -45,8 +46,30 @@ const deleteAllDB = async () => {
         console.error("deleteAllDB", error);
     }
 };
+
 describe("@kvs/storage", () => {
     before(deleteAllDB);
     afterEach(deleteAllDB);
     kvsTestCase.run();
+    it("example", async () => {
+        type StorageSchema = {
+            a1: string;
+            b2: number;
+            c3: boolean;
+        };
+        const storage = await kvsStorage<StorageSchema>({
+            name: databaseName,
+            version: 2,
+            storage: localStorage
+        });
+        await storage.set("a1", "string");
+        await storage.set("b2", 42);
+        await storage.set("c3", false);
+        const a1 = await storage.get("a1");
+        const b2 = await storage.get("b2");
+        const c3 = await storage.get("c3");
+        assert.strictEqual(a1, "string");
+        assert.strictEqual(b2, 42);
+        assert.strictEqual(c3, false);
+    });
 });
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
index 7e4a8fc..50df5c8 100644
--- a/packages/types/src/index.ts
+++ b/packages/types/src/index.ts
@@ -1,38 +1,79 @@
-export type KVS<K, V> = {
+export type StorageSchema = {
+    [index: string]: any;
+};
+// https://stackoverflow.com/questions/51465182/typescript-remove-index-signature-using-mapped-types
+export type KnownKeys<T> = {
+    [K in keyof T]: string extends K ? never : number extends K ? never : K;
+} extends { [_ in keyof T]: infer U }
+    ? U
+    : never;
+/**
+ * Extract known object store names from the DB schema type.
+ *
+ * @template DBTypes DB schema type, or unknown if the DB isn't typed.
+ */
+export type StoreNames<DBTypes extends StorageSchema | unknown> = DBTypes extends StorageSchema
+    ? KnownKeys<DBTypes>
+    : string;
+/**
+ * Extract database value types from the DB schema type.
+ *
+ * @template DBTypes DB schema type, or unknown if the DB isn't typed.
+ * @template StoreName Names of the object stores to get the types of.
+ */
+export type StoreValue<
+    DBTypes extends StorageSchema | unknown,
+    StoreName extends StoreNames<DBTypes>
+> = DBTypes extends StorageSchema ? DBTypes[StoreName] : any;
+
+export type KVS<Schema extends StorageSchema> = {
     clear(): Promise<void>;
-    delete(key: K): Promise<boolean>;
-    get(key: K): Promise<V | undefined>;
-    has(key: K): Promise<boolean>;
-    set(key: K, value: V | undefined): Promise<KVS<K, V>>;
+    delete(key: StoreNames<Schema>): Promise<boolean>;
+    get<K extends StoreNames<Schema>>(key: K): Promise<StoreValue<Schema, K> | undefined>;
+    has(key: StoreNames<Schema>): Promise<boolean>;
+    set<K extends StoreNames<Schema>>(key: K, value: StoreValue<Schema, K> | undefined): Promise<KVS<Schema>>;
     /*
      * Close the KVS connection
      * DB-like KVS close the connection via this method
      * Of course, localStorage-like KVS implement do nothing. It is just noop function
      */
     close(): Promise<void>;
-} & AsyncIterable<[K, V]>;
-export type KVSOptions<K, V> = {
+} & AsyncIterable<[StoreNames<Schema>, StoreValue<Schema, StoreNames<Schema>>]>;
+export type KVSOptions<Schema extends StorageSchema> = {
     name: string;
     version: number;
-    upgrade?({ kvs, oldVersion, newVersion }: { kvs: KVS<K, V>; oldVersion: number; newVersion: number }): Promise<any>;
+    upgrade?({
+        kvs,
+        oldVersion,
+        newVersion
+    }: {
+        kvs: KVS<Schema>;
+        oldVersion: number;
+        newVersion: number;
+    }): Promise<any>;
 } & {
     // options will be extended
     [index: string]: any;
 };
-export type KVSConstructor<K, V> = (options: KVSOptions<K, V>) => Promise<KVS<K, V>>;
+export type KVSConstructor<Schema extends StorageSchema> = (options: KVSOptions<Schema>) => Promise<KVS<Schema>>;
 /**
  * Sync Version
  */
-export type KVSSync<K, V> = {
-    clear(): void;
-    delete(key: K): boolean;
-    get(key: K): V | undefined;
-    has(key: K): boolean;
-    set(key: K, value: V | undefined): KVSSync<K, V>;
-    close(): void;
-} & Iterable<[K, V]>;
-export type KVSSyncOptions<K, V> = {
-    name: string;
-    version: number;
-    upgrade?({ kvs, oldVersion, newVersion }: { kvs: KVS<K, V>; oldVersion: number; newVersion: number }): any;
-};
+// export type KVSSync<Schema extends StorageSchema> = {
+//     clear(): void;
+//     delete(key: KeyOf<Schema>): boolean;
+//     get<T extends KeyOf<Schema>>(key: keyof T): Schema[T] | undefined;
+//     has(key: KeyOf<Schema>): boolean;
+//     set<T extends KeyOf<Schema>>(key: T, value: Schema[T] | undefined): Schema;
+//     /*
+//      * Close the KVS connection
+//      * DB-like KVS close the connection via this method
+//      * Of course, localStorage-like KVS implement do nothing. It is just noop function
+//      */
+//     close(): void;
+// } & Iterable<[KeyOf<Schema>, ValueOf<Schema>]>;
+// export type KVSSyncOptions<Schema extends StorageSchema> = {
+//     name: string;
+//     version: number;
+//     upgrade?({ kvs, oldVersion, newVersion }: { kvs: KVS<Schema>; oldVersion: number; newVersion: number }): any;
+// };

From ec143e27d174271f4ce45f657e1ae644ef01591c Mon Sep 17 00:00:00 2001
From: azu <azuciao@gmail.com>
Date: Sun, 9 Aug 2020 01:41:09 +0900
Subject: [PATCH 2/6] feat(@kvs/indexeddb): migrate Schema Type

---
 packages/indexeddb/README.md          | 24 ++++++++-
 packages/indexeddb/src/index.ts       | 73 ++++++++++++++++-----------
 packages/indexeddb/test/index.test.ts | 23 ++++++++-
 packages/storage/test/index.test.ts   |  2 +-
 4 files changed, 89 insertions(+), 33 deletions(-)

diff --git a/packages/indexeddb/README.md b/packages/indexeddb/README.md
index d7e094b..2c217f3 100644
--- a/packages/indexeddb/README.md
+++ b/packages/indexeddb/README.md
@@ -10,7 +10,29 @@ Install with [npm](https://www.npmjs.com/):
 
 ## Usage
 
-- [ ] Write usage instructions
+```ts
+import { KVSIndexedDB, kvsIndexedDB } from "@kvs/indexeddb";
+(async () => {
+    type StorageSchema = {
+        a1: string;
+        b2: number;
+        c3: boolean;
+    };
+    const storage = await kvsIndexedDB<StorageSchema>({
+        name: "test",
+        version: 1,
+    });
+    await storage.set("a1", "string");
+    await storage.set("b2", 42);
+    await storage.set("c3", false);
+    const a1 = await storage.get("a1");
+    const b2 = await storage.get("b2");
+    const c3 = await storage.get("c3");
+    assert.strictEqual(a1, "string");
+    assert.strictEqual(b2, 42);
+    assert.strictEqual(c3, false);
+})();
+```
 
 ## Changelog
 
diff --git a/packages/indexeddb/src/index.ts b/packages/indexeddb/src/index.ts
index e545c49..9aa60b9 100644
--- a/packages/indexeddb/src/index.ts
+++ b/packages/indexeddb/src/index.ts
@@ -1,6 +1,5 @@
-import type { KVS, KVSOptions } from "@kvs/types";
+import type { KVS, KVSOptions, StoreNames, StoreValue } from "@kvs/types";
 
-type IndexedDBKey = string;
 const debug = {
     enabled: false,
     log(...args: any[]) {
@@ -97,11 +96,15 @@ const dropInstance = (database: IDBDatabase, databaseName: string): Promise<void
     });
 };
 
-const getItem = <K extends IndexedDBKey, V>(database: IDBDatabase, tableName: string, key: K): Promise<V> => {
+const getItem = <Schema extends KVSIndexedSchema>(
+    database: IDBDatabase,
+    tableName: string,
+    key: StoreNames<Schema>
+): Promise<StoreValue<Schema, StoreNames<Schema>>> => {
     return new Promise((resolve, reject) => {
         const transaction = database.transaction(tableName, "readonly");
         const objectStore = transaction.objectStore(tableName);
-        const request = objectStore.get(key);
+        const request = objectStore.get(String(key));
         request.onsuccess = () => {
             resolve(request.result);
         };
@@ -110,11 +113,15 @@ const getItem = <K extends IndexedDBKey, V>(database: IDBDatabase, tableName: st
         };
     });
 };
-const hasItem = async <K extends IndexedDBKey>(database: IDBDatabase, tableName: string, key: K): Promise<boolean> => {
+const hasItem = async <Schema extends KVSIndexedSchema>(
+    database: IDBDatabase,
+    tableName: string,
+    key: StoreNames<Schema>
+): Promise<boolean> => {
     return new Promise((resolve, reject) => {
         const transaction = database.transaction(tableName, "readonly");
         const objectStore = transaction.objectStore(tableName);
-        const request = objectStore.count(key);
+        const request = objectStore.count(String(key));
         request.onsuccess = () => {
             resolve(request.result !== 0);
         };
@@ -123,22 +130,22 @@ const hasItem = async <K extends IndexedDBKey>(database: IDBDatabase, tableName:
         };
     });
 };
-const setItem = async <K extends IndexedDBKey, V>(
+const setItem = async <Schema extends KVSIndexedSchema>(
     database: IDBDatabase,
     tableName: string,
-    key: K,
-    value: V
+    key: StoreNames<Schema>,
+    value: StoreValue<Schema, StoreNames<Schema>> | undefined
 ): Promise<void> => {
     // If the value is undefined, delete the key
     // This behavior aim to align localStorage implementation
     if (value === undefined) {
-        await deleteItem(database, tableName, key);
+        await deleteItem<Schema>(database, tableName, key);
         return;
     }
     return new Promise((resolve, reject) => {
         const transaction = database.transaction(tableName, "readwrite");
         const objectStore = transaction.objectStore(tableName);
-        const request = objectStore.put(value, key);
+        const request = objectStore.put(value, String(key));
         transaction.oncomplete = () => {
             resolve();
         };
@@ -150,15 +157,15 @@ const setItem = async <K extends IndexedDBKey, V>(
         };
     });
 };
-const deleteItem = async <K extends IndexedDBKey>(
+const deleteItem = async <Schema extends KVSIndexedSchema>(
     database: IDBDatabase,
     tableName: string,
-    key: K
+    key: StoreNames<Schema>
 ): Promise<boolean> => {
     return new Promise((resolve, reject) => {
         const transaction = database.transaction(tableName, "readwrite");
         const objectStore = transaction.objectStore(tableName);
-        const request = objectStore.delete(key);
+        const request = objectStore.delete(String(key));
         transaction.oncomplete = () => {
             resolve();
         };
@@ -186,7 +193,10 @@ const clearItems = async (database: IDBDatabase, tableName: string): Promise<voi
         };
     });
 };
-const iterator = <K extends IndexedDBKey, V>(database: IDBDatabase, tableName: string): AsyncIterator<[K, V]> => {
+const iterator = <Schema extends KVSIndexedSchema, K extends StoreNames<Schema>, V extends StoreValue<Schema, K>>(
+    database: IDBDatabase,
+    tableName: string
+): AsyncIterator<[K, V]> => {
     const handleCursor = <T>(request: IDBRequest<T | null>): Promise<{ done: boolean; value?: T }> => {
         return new Promise((resolve, reject) => {
             request.onsuccess = () => {
@@ -237,23 +247,23 @@ interface StoreOptions {
     tableName: string;
 }
 
-const createStore = <K extends IndexedDBKey, V>({
+const createStore = <Schema extends KVSIndexedSchema>({
     database,
     databaseName,
     tableName
-}: StoreOptions): KVSIndexedDB<K, V> => {
-    const store: KVSIndexedDB<K, V> = {
-        delete(key: K): Promise<boolean> {
-            return deleteItem(database, tableName, key).then(() => true);
+}: StoreOptions): KVSIndexedDB<Schema> => {
+    const store: KVSIndexedDB<Schema> = {
+        delete(key: StoreNames<Schema>): Promise<boolean> {
+            return deleteItem<Schema>(database, tableName, key).then(() => true);
         },
-        get(key: K): Promise<V | undefined> {
-            return getItem(database, tableName, key);
+        get<K extends StoreNames<Schema>>(key: K): Promise<StoreValue<Schema, K> | undefined> {
+            return getItem<Schema>(database, tableName, key);
         },
-        has(key: K): Promise<boolean> {
+        has(key: StoreNames<Schema>): Promise<boolean> {
             return hasItem(database, tableName, key);
         },
-        set(key: K, value: V) {
-            return setItem(database, tableName, key, value).then(() => store);
+        set<K extends StoreNames<Schema>>(key: K, value: StoreValue<Schema, K>) {
+            return setItem<Schema>(database, tableName, key, value).then(() => store);
         },
         clear(): Promise<void> {
             return clearItems(database, tableName);
@@ -274,11 +284,14 @@ const createStore = <K extends IndexedDBKey, V>({
     return store;
 };
 
-export type KVSIndexedDB<K extends IndexedDBKey, V> = KVS<K, V> & IndexedDBResults;
-export type KvsIndexedDBOptions<K extends IndexedDBKey, V> = KVSOptions<K, V> & IndexedDBOptions;
-export const kvsIndexedDB = async <K extends IndexedDBKey, V>(
-    options: KvsIndexedDBOptions<K, V>
-): Promise<KVSIndexedDB<K, V>> => {
+export type KVSIndexedSchema = {
+    [index: string]: any;
+};
+export type KVSIndexedDB<Schema extends KVSIndexedSchema> = KVS<Schema> & IndexedDBResults;
+export type KvsIndexedDBOptions<Schema extends KVSIndexedSchema> = KVSOptions<Schema> & IndexedDBOptions;
+export const kvsIndexedDB = async <Schema extends KVSIndexedSchema>(
+    options: KvsIndexedDBOptions<Schema>
+): Promise<KVSIndexedDB<Schema>> => {
     const { name, version, upgrade, ...indexDBOptions } = options;
     if (indexDBOptions.debug) {
         debug.enabled = indexDBOptions.debug;
diff --git a/packages/indexeddb/test/index.test.ts b/packages/indexeddb/test/index.test.ts
index e59e0eb..be86b72 100644
--- a/packages/indexeddb/test/index.test.ts
+++ b/packages/indexeddb/test/index.test.ts
@@ -1,5 +1,6 @@
 import { KVSIndexedDB, kvsIndexedDB } from "../src";
 import { createKVSTestCase } from "@kvs/common-test-case";
+import assert from "assert";
 
 const databaseName = "kvs-test";
 const kvsTestCase = createKVSTestCase(
@@ -46,7 +47,7 @@ const kvsTestCase = createKVSTestCase(
     }
 );
 const deleteAllDB = async () => {
-    const kvs = kvsTestCase.ref.current as KVSIndexedDB<any, any> | null;
+    const kvs = kvsTestCase.ref.current as KVSIndexedDB<any> | null;
     if (!kvs) {
         return;
     }
@@ -62,4 +63,24 @@ describe("@kvs/indexedDB", () => {
     before(deleteAllDB);
     afterEach(deleteAllDB);
     kvsTestCase.run();
+    it("example", async () => {
+        type StorageSchema = {
+            a1: string;
+            b2: number;
+            c3: boolean;
+        };
+        const storage = await kvsIndexedDB<StorageSchema>({
+            name: databaseName,
+            version: 1
+        });
+        await storage.set("a1", "string");
+        await storage.set("b2", 42);
+        await storage.set("c3", false);
+        const a1 = await storage.get("a1");
+        const b2 = await storage.get("b2");
+        const c3 = await storage.get("c3");
+        assert.strictEqual(a1, "string");
+        assert.strictEqual(b2, 42);
+        assert.strictEqual(c3, false);
+    });
 });
diff --git a/packages/storage/test/index.test.ts b/packages/storage/test/index.test.ts
index 032330a..57cd3d6 100644
--- a/packages/storage/test/index.test.ts
+++ b/packages/storage/test/index.test.ts
@@ -59,7 +59,7 @@ describe("@kvs/storage", () => {
         };
         const storage = await kvsStorage<StorageSchema>({
             name: databaseName,
-            version: 2,
+            version: 1,
             storage: localStorage
         });
         await storage.set("a1", "string");

From 84d75f4407b33119da6d4745adea611f2b80404e Mon Sep 17 00:00:00 2001
From: azu <azuciao@gmail.com>
Date: Sun, 9 Aug 2020 01:43:49 +0900
Subject: [PATCH 3/6] feat(@kvs/memorystorage): migrate to Schema type

---
 packages/memorystorage/src/index.ts | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/packages/memorystorage/src/index.ts b/packages/memorystorage/src/index.ts
index b6dd03f..2ef1d79 100644
--- a/packages/memorystorage/src/index.ts
+++ b/packages/memorystorage/src/index.ts
@@ -1,15 +1,18 @@
-import { JsonValue, KvsStorage, kvsStorage, KVSStorageKey } from "@kvs/storage";
+import { JsonValue, KvsStorage, kvsStorage } from "@kvs/storage";
 import { KVS, KVSOptions } from "@kvs/types";
 // @ts-ignore
 import localstorage from "localstorage-memory";
 
-export type KvsLocalStorage<K extends KVSStorageKey, V extends JsonValue> = KVS<K, V>;
-export type KvsLocalStorageOptions<K extends KVSStorageKey, V extends JsonValue> = KVSOptions<K, V> & {
+export type KvsMemoryStorageSchema = {
+    [index: string]: JsonValue;
+};
+export type KvsMemoryStorage<Schema extends KvsMemoryStorageSchema> = KVS<Schema>;
+export type KvsMemoryStorageOptions<Schema extends KvsMemoryStorageSchema> = KVSOptions<Schema> & {
     kvsVersionKey?: string;
 };
-export const kvsMemoryStorage = async <K extends KVSStorageKey, V extends JsonValue>(
-    options: KvsLocalStorageOptions<K, V>
-): Promise<KvsStorage<K, V>> => {
+export const kvsMemoryStorage = async <Schema extends KvsMemoryStorageSchema>(
+    options: KvsMemoryStorageOptions<Schema>
+): Promise<KvsStorage<Schema>> => {
     return kvsStorage({
         ...options,
         storage: localstorage

From 0c84640c1c1d28955c60ca83d8a01bdce936d9ef Mon Sep 17 00:00:00 2001
From: azu <azuciao@gmail.com>
Date: Sun, 9 Aug 2020 01:46:08 +0900
Subject: [PATCH 4/6] feat(@kvs/localstorage): migrate to Schema type

---
 packages/localstorage/README.md    | 26 ++++++++++++++++++++++++--
 packages/localstorage/src/index.ts | 15 +++++++++------
 packages/storage/README.md         |  3 ++-
 3 files changed, 35 insertions(+), 9 deletions(-)

diff --git a/packages/localstorage/README.md b/packages/localstorage/README.md
index e06e408..f507b53 100644
--- a/packages/localstorage/README.md
+++ b/packages/localstorage/README.md
@@ -10,8 +10,30 @@ Install with [npm](https://www.npmjs.com/):
 
 ## Usage
 
-- [ ] Write usage instructions
-
+```ts
+import assert from "assert";
+import { kvsLocalStorage } from "@kvs/localstorage";
+(async () => {
+    type StorageSchema = {
+        a1: string;
+        b2: number;
+        c3: boolean;
+    };
+    const storage = await kvsLocalStorage<StorageSchema>({
+        name: "test",
+        version: 1
+    });
+    await storage.set("a1", "string");
+    await storage.set("b2", 42);
+    await storage.set("c3", false);
+    const a1 = await storage.get("a1");
+    const b2 = await storage.get("b2");
+    const c3 = await storage.get("c3");
+    assert.strictEqual(a1, "string");
+    assert.strictEqual(b2, 42);
+    assert.strictEqual(c3, false);
+})();
+```
 ## Changelog
 
 See [Releases page](https://github.com/azu/kvs/releases).
diff --git a/packages/localstorage/src/index.ts b/packages/localstorage/src/index.ts
index 025296d..7415774 100644
--- a/packages/localstorage/src/index.ts
+++ b/packages/localstorage/src/index.ts
@@ -1,13 +1,16 @@
-import { JsonValue, KvsStorage, kvsStorage, KVSStorageKey } from "@kvs/storage";
+import { JsonValue, KvsStorage, kvsStorage } from "@kvs/storage";
 import { KVS, KVSOptions } from "@kvs/types";
 
-export type KvsLocalStorage<K extends KVSStorageKey, V extends JsonValue> = KVS<K, V>;
-export type KvsLocalStorageOptions<K extends KVSStorageKey, V extends JsonValue> = KVSOptions<K, V> & {
+export type KvsLocalStorageSchema = {
+    [index: string]: JsonValue;
+};
+export type KvsLocalStorage<Schema extends KvsLocalStorageSchema> = KVS<Schema>;
+export type KvsLocalStorageOptions<Schema extends KvsLocalStorageSchema> = KVSOptions<Schema> & {
     kvsVersionKey?: string;
 };
-export const kvsLocalStorage = async <K extends KVSStorageKey, V extends JsonValue>(
-    options: KvsLocalStorageOptions<K, V>
-): Promise<KvsStorage<K, V>> => {
+export const kvsLocalStorage = async <Schema extends KvsLocalStorageSchema>(
+    options: KvsLocalStorageOptions<Schema>
+): Promise<KvsStorage<Schema>> => {
     return kvsStorage({
         ...options,
         storage: window.localStorage
diff --git a/packages/storage/README.md b/packages/storage/README.md
index 5ed4ba3..3abe77d 100644
--- a/packages/storage/README.md
+++ b/packages/storage/README.md
@@ -13,6 +13,7 @@ Install with [npm](https://www.npmjs.com/):
 ## Usage
 
 ```ts
+import assert from "assert";
 import { kvsStorage } from "@kvs/storage";
 (async () => {
     type StorageSchema = {
@@ -34,7 +35,7 @@ import { kvsStorage } from "@kvs/storage";
     assert.strictEqual(a1, "string");
     assert.strictEqual(b2, 42);
     assert.strictEqual(c3, false);
-})()
+})();
 ```
 
 ## Changelog

From 0951d08405d42588454878a03c9082961ad0c363 Mon Sep 17 00:00:00 2001
From: azu <azuciao@gmail.com>
Date: Sun, 9 Aug 2020 01:57:06 +0900
Subject: [PATCH 5/6] feat(@kvs/env): migrate Schema Type

---
 packages/common-test-case/src/common-test-case.ts | 10 +++++-----
 packages/env/src/browser.ts                       | 12 ++++++------
 packages/env/src/node.ts                          | 10 +++++-----
 packages/env/src/share.ts                         | 10 ++++++----
 packages/indexeddb/src/index.ts                   |  3 ++-
 packages/node-localstorage/src/index.ts           | 15 +++++++++------
 6 files changed, 33 insertions(+), 27 deletions(-)

diff --git a/packages/common-test-case/src/common-test-case.ts b/packages/common-test-case/src/common-test-case.ts
index 2ef63b9..6859e3b 100644
--- a/packages/common-test-case/src/common-test-case.ts
+++ b/packages/common-test-case/src/common-test-case.ts
@@ -5,21 +5,21 @@ export type KVSTestCaseOptions = {
     setTestDataList: { name: string; value: any; type?: "object" }[];
 };
 export type KVSTestCaseRef = {
-    current: KVS<any, any> | null;
-    updateRef(ref: KVS<any, any>): void;
+    current: KVS<any> | null;
+    updateRef(ref: KVS<any>): void;
 };
 // version always be defined
 export const createKVSTestCase = (
-    kvsStorageConstructor: (options: Partial<KVSOptions<any, any>> & { version: number }) => Promise<KVS<any, any>>,
+    kvsStorageConstructor: (options: Partial<KVSOptions<any>> & { version: number }) => Promise<KVS<any>>,
     options: KVSTestCaseOptions
 ) => {
     const ref: KVSTestCaseRef = {
         current: null,
-        updateRef(target: KVS<any, any>) {
+        updateRef(target: KVS<any>) {
             ref.current = target;
         }
     };
-    let kvs: KVS<any, any>;
+    let kvs: KVS<any>;
     return {
         ref,
         run: () => {
diff --git a/packages/env/src/browser.ts b/packages/env/src/browser.ts
index aab1338..0eb7f19 100644
--- a/packages/env/src/browser.ts
+++ b/packages/env/src/browser.ts
@@ -1,9 +1,9 @@
-import { JsonValue, KvsStorage } from "@kvs/storage";
-import { kvsIndexedDB } from "@kvs/indexeddb";
-import { KvsEnvStorageOptions } from "./share";
+import { KvsStorage } from "@kvs/storage";
+import { kvsIndexedDB, KvsIndexedDBOptions } from "@kvs/indexeddb";
+import { KvsEnvStorageOptions, KvsEnvStorageSchema } from "./share";
 
-export const kvsEnvStorage = async <K extends string, V extends JsonValue>(
-    options: KvsEnvStorageOptions<K, V>
-): Promise<KvsStorage<K, V>> => {
+export const kvsEnvStorage = async <Schema extends KvsEnvStorageSchema>(
+    options: KvsEnvStorageOptions<Schema> & KvsIndexedDBOptions<Schema>
+): Promise<KvsStorage<Schema>> => {
     return kvsIndexedDB(options);
 };
diff --git a/packages/env/src/node.ts b/packages/env/src/node.ts
index 39de644..b8329fb 100644
--- a/packages/env/src/node.ts
+++ b/packages/env/src/node.ts
@@ -1,9 +1,9 @@
-import { JsonValue, KvsStorage } from "@kvs/storage";
-import { kvsLocalStorage } from "@kvs/node-localstorage";
+import { kvsLocalStorage, KvsLocalStorage, KvsLocalStorageOptions } from "@kvs/node-localstorage";
 import { KvsEnvStorageOptions } from "./share";
+import { KVSIndexedSchema } from "@kvs/indexeddb/lib";
 
-export const kvsEnvStorage = async <K extends string, V extends JsonValue>(
-    options: KvsEnvStorageOptions<K, V>
-): Promise<KvsStorage<K, V>> => {
+export const kvsEnvStorage = async <Schema extends KVSIndexedSchema>(
+    options: KvsEnvStorageOptions<Schema> & KvsLocalStorageOptions<Schema>
+): Promise<KvsLocalStorage<Schema>> => {
     return kvsLocalStorage(options);
 };
diff --git a/packages/env/src/share.ts b/packages/env/src/share.ts
index 0467daf..87c650d 100644
--- a/packages/env/src/share.ts
+++ b/packages/env/src/share.ts
@@ -1,6 +1,8 @@
-import { JsonValue, KVSStorageKey } from "@kvs/storage";
+import { JsonValue } from "@kvs/storage";
 import { KVS } from "@kvs/types";
-import { KvsLocalStorageOptions } from "@kvs/node-localstorage";
 
-export type KvsEnvStorage<K extends KVSStorageKey, V extends JsonValue> = KVS<K, V>;
-export type KvsEnvStorageOptions<K extends KVSStorageKey, V extends JsonValue> = KvsLocalStorageOptions<K, V>;
+export type KvsEnvStorageSchema = {
+    [index: string]: JsonValue;
+};
+export type KvsEnvStorage<Schema extends KvsEnvStorageSchema> = KVS<Schema>;
+export type KvsEnvStorageOptions<Schema extends KvsEnvStorageSchema> = KvsEnvStorage<Schema>;
diff --git a/packages/indexeddb/src/index.ts b/packages/indexeddb/src/index.ts
index 9aa60b9..4ad3137 100644
--- a/packages/indexeddb/src/index.ts
+++ b/packages/indexeddb/src/index.ts
@@ -1,4 +1,5 @@
 import type { KVS, KVSOptions, StoreNames, StoreValue } from "@kvs/types";
+import { JsonValue } from "@kvs/storage";
 
 const debug = {
     enabled: false,
@@ -285,7 +286,7 @@ const createStore = <Schema extends KVSIndexedSchema>({
 };
 
 export type KVSIndexedSchema = {
-    [index: string]: any;
+    [index: string]: JsonValue;
 };
 export type KVSIndexedDB<Schema extends KVSIndexedSchema> = KVS<Schema> & IndexedDBResults;
 export type KvsIndexedDBOptions<Schema extends KVSIndexedSchema> = KVSOptions<Schema> & IndexedDBOptions;
diff --git a/packages/node-localstorage/src/index.ts b/packages/node-localstorage/src/index.ts
index 61ad692..e9bc079 100644
--- a/packages/node-localstorage/src/index.ts
+++ b/packages/node-localstorage/src/index.ts
@@ -1,5 +1,5 @@
 import path from "path";
-import { JsonValue, KvsStorage, kvsStorage, KVSStorageKey } from "@kvs/storage";
+import { JsonValue, KvsStorage, kvsStorage } from "@kvs/storage";
 import { KVS, KVSOptions } from "@kvs/types";
 // @ts-ignore
 import { LocalStorage } from "node-localstorage";
@@ -8,14 +8,17 @@ import appRoot from "app-root-path";
 // @ts-ignore
 import mkdirp from "mkdirp";
 
-export type KvsLocalStorage<K extends KVSStorageKey, V extends JsonValue> = KVS<K, V>;
-export type KvsLocalStorageOptions<K extends KVSStorageKey, V extends JsonValue> = KVSOptions<K, V> & {
+export type KvsLocalStorageSchema = {
+    [index: string]: JsonValue;
+};
+export type KvsLocalStorage<Schema extends KvsLocalStorageSchema> = KVS<Schema>;
+export type KvsLocalStorageOptions<Schema extends KvsLocalStorageSchema> = KVSOptions<Schema> & {
     kvsVersionKey?: string;
     storeFilePath?: string;
 };
-export const kvsLocalStorage = async <K extends KVSStorageKey, V extends JsonValue>(
-    options: KvsLocalStorageOptions<K, V>
-): Promise<KvsStorage<K, V>> => {
+export const kvsLocalStorage = async <Schema extends KvsLocalStorageSchema>(
+    options: KvsLocalStorageOptions<Schema>
+): Promise<KvsStorage<Schema>> => {
     const defaultCacheDir = path.join(appRoot.toString(), ".cache");
     if (!options.storeFilePath) {
         await mkdirp(defaultCacheDir);

From ee6dadacbb1d2e003956162b6cb7a5611f99a391 Mon Sep 17 00:00:00 2001
From: azu <azuciao@gmail.com>
Date: Sun, 9 Aug 2020 02:07:00 +0900
Subject: [PATCH 6/6] test(env): fix test

---
 README.md                 | 2 ++
 package.json              | 1 +
 packages/env/src/share.ts | 4 ++--
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index e91e9ed..f2ff097 100644
--- a/README.md
+++ b/README.md
@@ -22,6 +22,8 @@ KVS libraries provide following common features.
     - provide `get`, `set`, `has`, `delete`, and `clear` API
 - Version migration API
     - Upgrade date via `version`
+- Tiny package
+    - Almost package size is 1kb(gzip)
 
 ## Packages
 
diff --git a/package.json b/package.json
index e33901b..8d9d670 100644
--- a/package.json
+++ b/package.json
@@ -19,6 +19,7 @@
     "build": "lerna run build",
     "clean": "lerna run clean",
     "test": "lerna run test",
+    "ci": "lerna run test --ignore '@kvs/localstorage'",
     "versionup": "lerna version --conventional-commits",
     "versionup:patch": "lerna version patch --conventional-commits",
     "versionup:minor": "lerna version minor --conventional-commits",
diff --git a/packages/env/src/share.ts b/packages/env/src/share.ts
index 87c650d..9342216 100644
--- a/packages/env/src/share.ts
+++ b/packages/env/src/share.ts
@@ -1,8 +1,8 @@
 import { JsonValue } from "@kvs/storage";
-import { KVS } from "@kvs/types";
+import { KVS, KVSOptions } from "@kvs/types";
 
 export type KvsEnvStorageSchema = {
     [index: string]: JsonValue;
 };
 export type KvsEnvStorage<Schema extends KvsEnvStorageSchema> = KVS<Schema>;
-export type KvsEnvStorageOptions<Schema extends KvsEnvStorageSchema> = KvsEnvStorage<Schema>;
+export type KvsEnvStorageOptions<Schema extends KvsEnvStorageSchema> = KVSOptions<Schema>;