Offline-friendly react-native apps

          class StorageResource<Entity extends { id: ItemId }> {
              constructor({ type, serializer }): StorageResource;

              getItems(ids: Array<string>): {[type: string]: Array<Entity>} | null;
              multiRemove(ids: Array<ItemId>): Promise<void>;
              setItems(items: Array<Entity>): Promise<void>;

              cleanAll(): Promise<void>;
              cleanUp(options: { days: number }): Promise<void>;

              parseItem(rawItem: string): Entity;
              serializeItem(item: Entity): string;
              trackLastRead(ids: Array<ItemId>): Promise<void>;
            }
        

          const usersStorage = StorageResource({ type: 'users', serializer });

          usersStorage.setItems([{ id: 1, name: 'Davyd' }]);

          /*
          AsyncStorage: {
              'CV::users::1': '{"id":1,"name":"Davyd"}',
              'LR::users::1': '1573942810000',
          }
          */

          usersStorage.getItems([1]);
          // AsyncStorage: {'LR::users::1': '1573942820000',}

          usersStorage.getItems([1]);
          // AsyncStorage: {'LR::users::1': '1573942830000',}
        

          class StorageResourceWithHelpers<
            Entity extends { id: ItemId }
          > extends StorageResource<Entity> {
            setCustomIds(key: string, ids: Array<ItemId>): Promise<void>;
            getCustomIds(key: string): Promise<Array<ItemId> | null>;
            removeCustomKeys(keys: Array<string>): Promise<void>;
          }
        

          class BlocksResource extends StorageResourceWithHelpers(){
              async getStoredMainScreenBlocks(){
                  const ids = this.getCustomIds('main-screen-blocks');

                  return ids ? this.getItems(ids) : null;
              }
          }

          const resource = BlocksResource({ type: 'blocks', serializer });
          //...
          const [ids,items] = await apiMethod(...);

          resource.setCustomIds('main-screen-blocks', ids);
          resource.setItems(items);
          resource.getStoredMainScreenBlocks(); // {blocks: [...]}
        

          const handlerOfflineRejects = async (...args: Args) => {
              try {
                  await apiMethod(...args).then((ids) => onGetIds(ids));
                  // ...
              } catch (error) {
                  if (isNetworkError(error)) {
                      const resourcesIndex = await storageMethod();

                      if (resourcesIndex) {
                          dispatch(indexResources(resourcesIndex));
                          // ...
                      }
                  }

                  throw error;
              }
          };
        

          export const findCurrentCompany = createOfflineFallbackSaga({
            apiMethod: () => api.getCurrentCompany(),
            storageMethod: () => storage.getStoredCurrentCompany(),
            onGetIds: (ids: Array<CompanyId>) => storage.setCurrentCompanyIds(ids),
          });