feat: rules repository

src/repositories/RuleRepository.ts

@@ -0,0 +1,82 @@
+import DBService, {
+  DBLevel,
+  FacilityIndexKey,
+  FacilityItemValues,
+  FacilityValues,
+  LevelDefaultTyping,
+  Rules,
+  RulesItemKey
+} from '../services/DBService';
+import ApiError from '../exceptions/ApiError';
+import {  AbstractSublevel } from 'abstract-level';
+
+abstract class RuleRepository {
+  protected db;
+  protected dbService = DBService.getInstance();
+
+  public async getRule(key: RulesItemKey): Promise<Rules | null> {
+    try {
+      return await this.db.get(key);
+    } catch (e) {
+      if (e.status === 404) {
+        throw ApiError.NotFound(`Unable to get "${key}" of rule level"`);
+      }
+      throw e;
+    }
+  }
+
+  public async setRule(key: RulesItemKey, value: Rules): Promise<void> {
+    await this.db.put(key, value);
+  }
+
+  public async delRule(key: RulesItemKey): Promise<void> {
+    await this.db.del(key);
+  }
+}
+
+
+abstract class ItemRuleRepository extends RuleRepository {
+  protected db: AbstractSublevel<
+    AbstractSublevel<
+      AbstractSublevel<DBLevel, LevelDefaultTyping, string, FacilityValues>,
+      LevelDefaultTyping,
+      string,
+      FacilityItemValues
+    >,
+    LevelDefaultTyping,
+    RulesItemKey,
+    Rules
+  >;
+
+  protected constructor(facilityId: string, indexKey: FacilityIndexKey, itemId: string) {
+    super();
+
+    this.db = this.dbService.getItemRulesDB(facilityId, indexKey, itemId);
+  }
+}
+
+export class FacilityRuleRepository extends RuleRepository {
+  protected db: AbstractSublevel<
+    AbstractSublevel<DBLevel, LevelDefaultTyping, string, FacilityValues>,
+    LevelDefaultTyping,
+    RulesItemKey,
+    Rules
+  >;
+
+  constructor(facilityId: string) {
+    super();
+
+    this.db = this.dbService.getFacilityRulesDB(facilityId);
+  }
+}
+
+export class SpaceRuleRepository extends ItemRuleRepository {
+  constructor(facilityId: string, itemId: string) {
+    super(facilityId, 'spaces', itemId);
+  }
+}
+export class OtherItemRuleRepository extends ItemRuleRepository {
+  constructor(facilityId: string, itemId: string) {
+    super(facilityId, 'otherItems', itemId);
+  }
+}

src/services/DBService.ts

@@ -169,13 +169,6 @@ export default class DBService {
     >('rates', { valueEncoding: 'json' });
   }
 
-  public getSpaceRulesDB(facilityId: string, spaceId: string) {
-    return this.getFacilityItemDB(facilityId, 'spaces', spaceId).sublevel<
-      RulesItemKey,
-      Rules
-    >('rules', { valueEncoding: 'json' });
-  }
-
   public getSpaceStubsDB(facilityId: string, spaceId: string) {
     return this.getFacilityItemDB(facilityId, 'spaces', spaceId).sublevel<
       SpaceStubKey,
@@ -193,4 +186,15 @@ export default class DBService {
       ModifiersValues
     >('modifiers', { valueEncoding: 'json' });
   }
+
+  public getItemRulesDB(
+    facilityId: string,
+    indexKey: FacilityIndexKey,
+    itemId: string
+  ) {
+    return this.getFacilityItemDB(facilityId, indexKey, itemId).sublevel<
+      RulesItemKey,
+      Rules
+      >('rules', { valueEncoding: 'json' });
+  }
 }

test/repository.spec.ts

@@ -0,0 +1,50 @@
+import { FacilityRuleRepository, SpaceRuleRepository } from '../src/repositories/RuleRepository';
+import { NoticeRequiredRule } from '../src/proto/lpms';
+import { expect } from 'chai';
+
+describe('facility repository test', async () => {
+  const facilityId = '0x1234567890';
+  const spaceId = '0x1234567890';
+  const facilityRuleRepository = new FacilityRuleRepository(facilityId);
+  const spaceRuleRepository = new SpaceRuleRepository(facilityId, spaceId);
+
+  it('set rule', async () => {
+    const rule: NoticeRequiredRule = {
+      numDays: 10
+    };
+
+    await facilityRuleRepository.setRule('notice_required', rule);
+    await spaceRuleRepository.setRule('notice_required', rule);
+  });
+
+  it('get rule', async () => {
+    const rule = await facilityRuleRepository.getRule('notice_required') as NoticeRequiredRule;
+    const spaceRule = await spaceRuleRepository.getRule('notice_required') as NoticeRequiredRule;
+
+    expect(rule.numDays).to.be.equal(10);
+    expect(spaceRule.numDays).to.be.equal(10);
+  });
+
+  it('delete rule', async () => {
+    await facilityRuleRepository.delRule('notice_required');
+    await spaceRuleRepository.delRule('notice_required');
+  });
+
+  it('check rule not exist', async () => {
+    let error;
+
+    try {
+      await facilityRuleRepository.getRule('notice_required');
+    } catch (e) {
+      error = e;
+    }
+    expect(error.status).to.be.equal(404);
+
+    try {
+      await spaceRuleRepository.getRule('notice_required');
+    } catch (e) {
+      error = e;
+    }
+    expect(error.status).to.be.equal(404);
+  });
+});