Standardization for leveldb

src/controllers/StorageController.ts

@@ -12,7 +12,7 @@ import { web3StorageKey, typedDataDomain } from '../config';
 import { walletAccountsIndexes } from '../types';
 import { Facility, Item, ItemType, Space } from '../proto/facility';
 import facilityService from '../services/FacilityService';
-import { FacilitySpaceLevelValues } from 'src/services/DBService';
+import { FacilitySpaceValues } from 'src/services/DBService';
 const { readFile } = promises;
 
 export class StorageController {
@@ -75,7 +75,7 @@ export class StorageController {
       ]);
 
       // Extract spaces from metadata
-      const spaces: Record<string, [string, FacilitySpaceLevelValues][]> = {};
+      const spaces: Record<string, [string, FacilitySpaceValues][]> = {};
       const otherItems: Record<string, [string, Item][]> = {};
 
       for (const item of serviceProviderData.items) {

src/repositories/FacilityRepository.ts

@@ -1,4 +1,8 @@
-import DBService, { FacilityItemType, FacilityLevelValues, FacilitySpaceLevelValues } from '../services/DBService';
+import DBService, {
+  FacilityItemType,
+  FacilityValues,
+  FacilitySpaceValues
+} from '../services/DBService';
 import { Level } from 'level';
 import { Item } from '../proto/facility';
 
@@ -11,6 +15,8 @@ export class FacilityRepository {
     this.db = DBService.getInstance().getDB();
   }
 
+  // --- facility index management
+
   public async getFacilityIds(): Promise<string[]> {
     try {
       return await this.db.get<string, string[]>('facilities', {
@@ -24,51 +30,45 @@ export class FacilityRepository {
     return [];
   }
 
-  public async createFacilityIndex(facilityId: string) {
-    const facilitiesIds = await this.getFacilityIds();
+  public async addFacilityToIndex(facilityId: string) {
+    const facilityIds = await this.getFacilityIds();
 
-    if (facilitiesIds.length > 0) {
-      const idsSet = new Set<string>(facilitiesIds);
-      idsSet.add(facilityId);
-      await this.db.put('facilities', Array.from(idsSet));
+    if (facilityIds.length > 0) {
+      const ids = new Set<string>(facilityIds);
+      ids.add(facilityId);
+      await this.db.put('facilities', Array.from(ids));
     } else {
       await this.db.put('facilities', [facilityId]);
     }
   }
 
-  public async getItemIds(
-    facilityId: string,
-    itemType: FacilityItemType
-  ): Promise<string[]> {
-    try {
-      const facilitySublevel = this.dbService.getFacilitySublevelDB(facilityId);
-      return await facilitySublevel.get<string, string[]>(itemType, {
-        valueEncoding: 'json'
-      });
-    } catch (e) {
-      if (e.status !== 404) {
-        throw e;
+  public async delFacilityFromIndex(facilityId: string) {
+    const facilityIds = await this.getFacilityIds();
+
+    if (facilityIds.length > 0) {
+      const ids = new Set<string>(facilityIds);
+      if (ids.delete(facilityId)) {
+        await this.db.put('facilities', Array.from(ids));
       }
     }
-    return [];
   }
 
-  public async createFacilityItem(
+  // --- facility level getters / setters
+
+  public async setFacilityKey(
     facilityId: string,
     key: string,
-    value: FacilityLevelValues
+    value: FacilityValues
   ): Promise<void> {
-    const facilitySublevel = this.dbService.getFacilitySublevelDB(facilityId);
-
-    await facilitySublevel.put(key, value);
+    await this.dbService.getFacilityDB(facilityId).put(key, value);
   }
 
-  public async getFacilityDbKey(
+  public async getFacilityKey(
     facilityId: string,
     key: string
-  ): Promise<FacilityLevelValues> {
+  ): Promise<FacilityValues> {
     try {
-      return await this.dbService.getFacilitySublevelDB(facilityId).get(key);
+      return await this.dbService.getFacilityDB(facilityId).get(key);
     } catch (e) {
       if (e.status === 404) {
         throw new Error(`Unable to get "${key}" of facility "${facilityId}"`);
@@ -77,56 +77,90 @@ export class FacilityRepository {
     }
   }
 
-  public async getSpaceDbKey(
+  // --- items (space and otherItems) index management
+
+  public async getItemIds(
     facilityId: string,
-    spaceId: string,
-    key: string
-  ): Promise<FacilitySpaceLevelValues> {
+    itemType: FacilityItemType
+  ): Promise<string[]> {
     try {
       return await this.dbService
-        .getFacilityItemDB(facilityId, 'spaces', spaceId)
-        .get(key);
+        .getFacilityDB(facilityId)
+        .get<string, string[]>(itemType, {
+          valueEncoding: 'json'
+        });
     } catch (e) {
-      if (e.status === 404) {
-        throw new Error(
-          `Unable to get "${key}" of space "${spaceId}" of facility "${facilityId}"`
-        );
+      if (e.status !== 404) {
+        throw e;
       }
-      throw e;
     }
+    return [];
   }
 
-  public async createSpaceIndex(
+  public async addItemToIndex(
     facilityId: string,
     itemType: FacilityItemType,
     itemId: string
   ): Promise<void> {
     const itemIds = await this.getItemIds(facilityId, itemType);
-    const facilitySublevel = this.dbService.getFacilitySublevelDB(facilityId);
+    const db = this.dbService.getFacilityDB(facilityId);
 
     if (itemIds.length > 0) {
-      const spaceSet = new Set<string>(itemIds);
-      spaceSet.add(itemId);
-      await facilitySublevel.put(itemType, Array.from(spaceSet));
+      const ids = new Set<string>(itemIds);
+      ids.add(itemId);
+      await db.put(itemType, Array.from(ids));
     } else {
-      await facilitySublevel.put(itemType, [itemId]);
+      await db.put(itemType, [itemId]);
     }
   }
 
-  public async createSpaceItem(
+  public async delItemFromIndex(
+    facilityId: string,
+    itemType: FacilityItemType,
+    itemId: string
+  ): Promise<void> {
+    const itemIds = await this.getItemIds(facilityId, itemType);
+
+    if (itemIds.length > 0) {
+      const ids = new Set<string>(itemIds);
+      if (ids.delete(itemId)) {
+        await this.db.put(itemType, Array.from(ids));
+      }
+    }
+  }
+
+  // --- item level (space and otherItems) getters / setters
+
+  public async setItemKey(
     facilityId: string,
     itemType: FacilityItemType,
     itemId: string,
     key: string,
-    value: Item | FacilitySpaceLevelValues
+    value: Item | FacilitySpaceValues
   ): Promise<void> {
-    const sublevel = this.dbService.getFacilityItemDB(
-      facilityId,
-      itemType,
-      itemId
-    );
+    await this.dbService
+      .getFacilityItemDB(facilityId, itemType, itemId)
+      .put(key, value);
+  }
 
-    await sublevel.put(key, value);
+  public async getItemKey(
+    facilityId: string,
+    itemType: FacilityItemType,
+    itemId: string,
+    key: string
+  ): Promise<Item | FacilitySpaceValues> {
+    try {
+      return await this.dbService
+        .getFacilityItemDB(facilityId, itemType, itemId)
+        .get(key);
+    } catch (e) {
+      if (e.status === 404) {
+        throw new Error(
+          `Unable to get "${key}" of item "${itemId}" of facility "${facilityId}"`
+        );
+      }
+      throw e;
+    }
   }
 }
 

src/repositories/MainRepository.ts

@@ -12,7 +12,7 @@ export class MainRepository {
 
   public async getId(): Promise<number> {
     try {
-      return (Number(await this.db.get('user_db_increment'))) + 1;
+      return Number(await this.db.get('user_db_increment')) + 1;
     } catch (e) {
       if (e.status === 404) {
         return 1;

src/repositories/UserRepository.ts

@@ -7,7 +7,12 @@ export class UserRepository {
   private dbService: DBService;
   private db: Level<string, string | string[]>;
   private userDB: AbstractSublevel<DBLevel, LevelDefaultTyping, string, User>;
-  private loginDB: AbstractSublevel<DBLevel, LevelDefaultTyping, string, string>;
+  private loginDB: AbstractSublevel<
+    DBLevel,
+    LevelDefaultTyping,
+    string,
+    string
+  >;
 
   constructor() {
     this.dbService = DBService.getInstance();
@@ -16,7 +21,6 @@ export class UserRepository {
     this.loginDB = this.dbService.getLoginDB();
   }
 
-
   public async getAllUsers(): Promise<User[]> {
     return await this.userDB.values().all();
   }

src/services/DBService.ts

@@ -1,7 +1,11 @@
 import { AbstractSublevel } from 'abstract-level';
 import { Level } from 'level';
 import { Token, User } from '../types';
-import { Facility, Item, Space } from '../proto/facility';
+import {
+  Facility as FacilityMetadata,
+  Item as ItemMetadata,
+  Space as SpaceMetadata
+} from '../proto/facility';
 import {
   Availability,
   DayOfWeekLOSRule,
@@ -24,10 +28,10 @@ export type FacilityModifiers =
   | DayOfWeekRateModifer
   | OccupancyRateModifier
   | LOSRateModifier;
-export type FacilityLevelValues = Facility | string[];
-export type FacilitySpaceLevelValues = Item | Space;
+export type FacilityValues = FacilityMetadata | string[];
+export type FacilitySpaceValues = ItemMetadata | SpaceMetadata;
 export type FacilityItemType = 'spaces' | 'otherItems';
-export type FacilityItemValues = Item | FacilitySpaceLevelValues;
+export type FacilityItemValues = ItemMetadata | FacilitySpaceValues;
 export type AvailabilityDate = `${number}-${number}-${number}`;
 export type AvailabilityItemKey = 'default' | AvailabilityDate;
 
@@ -95,9 +99,9 @@ export default class DBService {
     return this.db;
   }
 
-  public getFacilitySublevelDB(facilityId: string) {
+  public getFacilityDB(facilityId: string) {
     const prefix = 'f_';
-    return this.db.sublevel<string, FacilityLevelValues>(prefix + facilityId, {
+    return this.db.sublevel<string, FacilityValues>(prefix + facilityId, {
       valueEncoding: 'json'
     });
   }
@@ -108,10 +112,10 @@ export default class DBService {
     itemId: string
   ) {
     const key = `${itemType}_${itemId}`;
-    return this.getFacilitySublevelDB(facilityId).sublevel<
-      string,
-      FacilityItemValues
-    >(key, { valueEncoding: 'json' });
+    return this.getFacilityDB(facilityId).sublevel<string, FacilityItemValues>(
+      key,
+      { valueEncoding: 'json' }
+    );
   }
 
   public getSpaceAvailabilityDB(facilityId: string, itemId: string) {

src/services/FacilityService.ts

@@ -1,6 +1,12 @@
 import { Item } from '../proto/facility';
-import { FacilityItemType, FacilityLevelValues, FacilitySpaceLevelValues } from './DBService';
-import facilityRepository, { FacilityRepository } from '../repositories/FacilityRepository';
+import {
+  FacilityItemType,
+  FacilityValues,
+  FacilitySpaceValues
+} from './DBService';
+import facilityRepository, {
+  FacilityRepository
+} from '../repositories/FacilityRepository';
 
 export class FacilityService {
   private repository: FacilityRepository;
@@ -11,26 +17,30 @@ export class FacilityService {
 
   public async setFacilityDbKeys(
     facilityId: string,
-    entries: [string, FacilityLevelValues][]
+    entries: [string, FacilityValues][]
   ): Promise<void> {
-    await this.repository.createFacilityIndex(facilityId);
+    await this.repository.addFacilityToIndex(facilityId);
 
     await Promise.all(
       entries.map(([key, value]) =>
-        this.repository.createFacilityItem(facilityId, key, value))
+        this.repository.setFacilityKey(facilityId, key, value)
+      )
     );
   }
 
   public async setItemDbKeys(
     facilityId: string,
     itemType: FacilityItemType,
     itemId: string,
-    entries: [string, Item | FacilitySpaceLevelValues][]
+    entries: [string, Item | FacilitySpaceValues][]
   ): Promise<void> {
-    await this.repository.createSpaceIndex(facilityId, itemType, itemId);
+    await this.repository.addItemToIndex(facilityId, itemType, itemId);
 
-    await Promise.all(entries.map(([key, value]) =>
-      this.repository.createSpaceItem(facilityId, itemType, itemId, key, value)));
+    await Promise.all(
+      entries.map(([key, value]) =>
+        this.repository.setItemKey(facilityId, itemType, itemId, key, value)
+      )
+    );
   }
 }
 

src/services/SpaceSearchService.ts

@@ -7,14 +7,18 @@ import facilityRepository from '../repositories/FacilityRepository';
 
 export default class SpaceSearchService {
   public static async check(ask: Ask, facilityId: string): Promise<Space[]> {
-    const spacesIds = await facilityRepository.getFacilityDbKey(facilityId, 'spaces');
+    const spacesIds = await facilityRepository.getFacilityKey(
+      facilityId,
+      'spaces'
+    );
 
     if (Array.isArray(spacesIds)) {
       const set = new Set();
 
       for (const v of spacesIds) {
-        const space = await facilityRepository.getSpaceDbKey(
+        const space = await facilityRepository.getItemKey(
           facilityId,
+          'spaces',
           v,
           'metadata'
         );