[RFC] Server Storage System

[GiveMe-A-Name]

1. BackGround

Provide a Storage System for FS, SSR Cache, and so on.
We don't need more overhead for Fs, SSR Cache.
On the other hand, the upper layer can't take more care about underlying storage.

2. Glossary

Name	Description
LocalStorage	The storage is effective only for current machines, based on memory
GlobalStorage	The storage is effective for all machines, based on Redis, and so on

3. Basic example

The api like web api storage

// 1. @modern-js/utils/store

const default = new DefaultContainer();
const custom = new CustomContainer();

const store =  new Store(local, global);

// someHook
// 2. Server Init
InitServer(context) {
   const default = new DefaultContainer();
   const custom = new CustomContainer();


   const store = new Store({
     default,
   }).customContainer(custom);
   context.store = store;
}

// usage
function someFunc(context: ModernServerContext) {
    // 1. 
    const { store } = context;
    // we need a symbol to tag a independence store space.
    const storage = store.createStorage<string>({
        type: 'default' | 'custom' = 'default',
    });
    
    // get
    const item = storage.get(key);
    
    // set
    storage.set(key, item);
    
    // remote
    storage.remove(key);
    
    // clear
    storage.clear();
    
    // has
    storage.has(key);
    
    storage.keys()
    
    storage.values()
    
    // Return total length of objects in cache taking into account `length` options function.
    let n: number = storage.length;
}

4. Detailed Design

Store

Every module can create storage on its own.

function someFunc(context: ModernServerContext) {
    const storage = store.createStorage<string>({
        type: 'default' | 'custom' = 'default', // the storage type.
    });
}

Then every module can create a cache system from this storage.

The Store would export createStorage method

class Store {
    // The container represents the lower store struct.
    // like: Memory, Redis, and so on.

    constructor(default, custom) {
      this.container1 = default;
      this.container1 = custom;
    }
    
    createStorage<V>(type: 'default' | 'custom') {
       // or generate symbol by himself.
       const symbol: string = generateSymbol();
        if(type === 'local') {
            return createLocalStorage(name, this.container1);
        } else if(type === 'global') {
            return createGlobalStorage(name, this.container2);
        }
    }
}

Storage

Storage would export a series of methods for upper layer application usage.

class Storage {
    constructor(symbol: string, container: Container){
        this.symbol = symbol;
        this.container = container;
    }
    
    get(k: string) {
      const uniqueKey = calcuUniqueKey(k);
      
      return this.containter.get(uniqueKey);
    }
    
    // computed a unique key from symbol & key.
    private calcuUniqueKey(k: string): string {
      return this.symbol + k;
    }
}

Container

// implement Container Interface Class

interface Container<K, V> {
  get(k: K): V | undefined;
  set(k: K, v: V): void;
  has(k: K): boolean;
  // ....
}

export class MemoryContainer implement Container {
 // ...
}


export class RedisContainer implement Container {
 // ...
}

Container Design

5. Drawbacks

1. Every module must create storage from serverContext. It means we must pass the context as function arguments.

function someHook(context: serverContext) {
    someFunc(context);
}

function someFunc(context: serverContext) {
    xxx(context)
}

function xxx(context: serverContext) {
    const { store } = context;
    // we need a symbol to tag a independence store space.
    const storage = store.createStorage<string>({
        name: 'stroage1111', // a unique name
        type: 'local' | 'global' = 'local',
    });
}

2. The symbol name must have a space to restrain

Like this:

// usage
import { storeName1, storeName2 } from '@modern-js/utils/contants';

// define
// @modern-js/utils/contants
export const storeName1 = 'xxx';

export const storeName2 = 'yyy';

7. Alternatives

Every module import store from dependency, like this:

import { store } from "@modern-js/utils/xx";

function someFunc() {
    const storage = store.createStorage({name: '', type: ''})
}