coh-content-db 2.0.0-rc.7 → 2.0.0-rc.9

package/src/main/db/coh-content-database.ts

@@ -1,120 +1,129 @@
-import { ContentBundle } from '../api/content-bundle'
+import { BundleData } from '../api/bundle-data'
 import { Archetype } from './archetype'
 import { Zone } from './zone'
 import { Badge } from './badge'
-import { BundleMetadata } from './bundle-metadata'
+import { BundleHeader } from './bundle-header'
 import { BadgeIndex } from './badge-index'
 import { BadgeSearchOptions } from './badge-search-options'
 import { Paged } from './paged'
 import { Contact } from './contact'
 import { Mission } from './mission'
+import { AbstractIndex } from './abstract-index'
 
 export class CohContentDatabase {
-  readonly #archetypeIndex: Record<string, Archetype> = {}
-  readonly #zoneIndex: Record<string, Zone> = {}
-  readonly #contactIndex: Record<string, Contact> = {}
-  readonly #missionIndex: Record<string, Mission> = {}
-  readonly #badgeIndex: BadgeIndex
+  #archetypeIndex = new AbstractIndex<Archetype>('key')
+  #zoneIndex = new AbstractIndex<Zone>('key')
+  #contactIndex = new AbstractIndex<Contact>('key')
+  #missionIndex = new AbstractIndex<Mission>('key')
+  #badgeIndex = new BadgeIndex()
+
+  #header?: BundleHeader
+  #servers?: string[]
+
+  /**
+   * Load the given content bundle, resetting the db if a bundle is already loaded.
+   * @param bundle The bundle to load.
+   */
+  load(bundle: BundleData): void {
+    this.#header = new BundleHeader(bundle.header)
+    this.#servers = bundle.servers ?? []
+
+    this.#archetypeIndex.load(bundle.archetypes?.map(x => new Archetype(x)))
+    this.#zoneIndex.load(bundle.zones?.map(x => new Zone(x)))
+    this.#contactIndex.load(bundle.contacts?.map(x => new Contact(x)))
+    this.#missionIndex.load(bundle.missions?.map(x => new Mission(x)))
+    this.#badgeIndex.load(bundle.badges?.map(x => new Badge(x)))
+  }
 
   /**
-   * Metadata about the content bundle.
+   * Header information about the content bundle.
    */
-  readonly metadata: BundleMetadata
+  get header(): BundleHeader | undefined {
+    return this.#header
+  }
 
   /**
    * List of the game server names.
    *
    * Torchbearer, Excelsior, etc.
    */
-  readonly servers: string[]
+  get servers(): string[] {
+    return this.#servers ?? []
+  }
 
   /**
    * List of archetypes.
    */
-  readonly archetypes: Archetype[]
+  get archetypes(): Archetype[] {
+    return this.#archetypeIndex.values
+  }
 
   /**
-   * List of game zones.
+   * Get archetype by key.
+   * @param key The key.
    */
-  readonly zones: Zone[]
+  getArchetype(key: string | undefined): Archetype | undefined {
+    return this.#archetypeIndex.get(key)
+  }
 
   /**
-   * List of contacts.
+   * List of game zones.
    */
-  readonly contacts: Contact[]
+  get zones(): Zone[] {
+    return this.#zoneIndex.values
+  }
 
   /**
-   * List of missions.
+   * Get zone by key.
+   * @param key The key.
    */
-  readonly missions: Contact[]
+  getZone(key: string | undefined): Zone | undefined {
+    return this.#zoneIndex.get(key)
+  }
 
   /**
-   * List of badges.
+   * List of contacts.
    */
-  readonly badges: Badge[]
+  get contacts(): Contact[] {
+    return this.#contactIndex.values
+  }
 
   /**
-   * Initialize the database with a content bundle.
-   * @param bundle The data to load.
+   * Get contact by key.
+   * @param key The key.
    */
-  constructor(bundle: ContentBundle) {
-    this.metadata = new BundleMetadata(bundle)
-    this.servers = bundle.servers ?? []
-
-    this.archetypes = bundle.archetypes?.map((data) => {
-      if (this.#archetypeIndex[data.key] !== undefined) throw new Error(`Duplicate archetype key '${data.key}'`)
-      const archetype = new Archetype(data)
-      this.#archetypeIndex[archetype.key] = archetype
-      return archetype
-    }) ?? []
-
-    this.zones = bundle.zones?.map((data) => {
-      if (this.#zoneIndex[data.key] !== undefined) throw new Error(`Duplicate zone key '${data.key}'`)
-      const zone = new Zone(data)
-      this.#zoneIndex[zone.key] = zone
-      return zone
-    }) ?? []
-
-    this.contacts = bundle.contacts?.map((data) => {
-      if (this.#contactIndex[data.key] !== undefined) throw new Error(`Duplicate contact key '${data.key}'`)
-      const contact = new Contact(data)
-      this.#contactIndex[contact.key] = contact
-      return contact
-    }) ?? []
-
-    this.missions = bundle.missions?.map((data) => {
-      if (this.#missionIndex[data.key] !== undefined) throw new Error(`Duplicate mission key '${data.key}'`)
-      const mission = new Mission(data)
-      this.#missionIndex[mission.key] = mission
-      return mission
-    }) ?? []
-
-    this.badges = bundle.badges?.map(data => new Badge(data)) ?? []
-    this.#badgeIndex = new BadgeIndex(this.badges)
-  }
-
-  getArchetype(key?: string): Archetype | undefined {
-    if (!key) return undefined
-    return this.#archetypeIndex[key]
+  getContact(key: string | undefined): Contact | undefined {
+    return this.#contactIndex.get(key)
   }
 
-  getZone(key?: string): Zone | undefined {
-    if (!key) return undefined
-    return this.#zoneIndex[key]
+  /**
+   * List of missions.
+   */
+  get missions(): Mission[] {
+    return this.#missionIndex.values
   }
 
-  getContact(key?: string): Contact | undefined {
-    if (!key) return undefined
-    return this.#contactIndex[key]
+  /**
+   * Get mission by key.
+   * @param key The key.
+   */
+  getMission(key: string | undefined): Mission | undefined {
+    return this.#missionIndex.get(key)
   }
 
-  getMission(key?: string): Mission | undefined {
-    if (!key) return undefined
-    return this.#missionIndex[key]
+  /**
+   * List of badges.
+   */
+  get badges(): Badge[] {
+    return this.#badgeIndex.values
   }
 
-  getBadge(key?: string): Badge | undefined {
-    return this.#badgeIndex.getBadge(key)
+  /**
+   * Get badge by key.
+   * @param key The key.
+   */
+  getBadge(key: string | undefined): Badge | undefined {
+    return this.#badgeIndex.get(key)
   }
 
   /**
@@ -124,6 +133,6 @@ export class CohContentDatabase {
    * @param options {@link BadgeSearchOptions}
    */
   searchBadges(options?: BadgeSearchOptions): Paged<Badge> {
-    return this.#badgeIndex.searchBadges(options)
+    return this.#badgeIndex.search(options)
   }
 }

package/src/main/index.ts

@@ -6,9 +6,9 @@ export * from './api/badge-data'
 export * from './api/badge-requirement-data'
 export * from './api/badge-requirement-type'
 export * from './api/badge-type'
-export * from './api/change'
+export * from './api/bundle-data'
+export * from './api/bundle-header-data'
 export * from './api/contact-data'
-export * from './api/content-bundle'
 export * from './api/enhancement-category'
 export * from './api/link'
 export * from './api/location-data'
@@ -27,7 +27,7 @@ export * from './db/badge'
 export * from './db/badge-index'
 export * from './db/badge-requirement'
 export * from './db/badge-search-options'
-export * from './db/bundle-metadata'
+export * from './db/bundle-header'
 export * from './db/coh-content-database'
 export * from './db/contact'
 export * from './db/key'
@@ -38,5 +38,4 @@ export * from './db/paged'
 export * from './db/zone'
 
 // ROOT
-export { CHANGELOG } from './changelog'
 export * from './util'

package/src/test/api/bundle-data.fixture.ts

@@ -0,0 +1,6 @@
+import { defineFixture } from 'efate'
+import { BundleData } from '../../main'
+
+export const bundleDataFixture = defineFixture<BundleData>(() => {
+  // no mandatory fields
+})

package/src/test/api/bundle-header-data.fixture.ts

@@ -0,0 +1,6 @@
+import { defineFixture } from 'efate'
+import { BundleHeaderData } from '../../main'
+
+export const bundleHeaderDataFixture = defineFixture<BundleHeaderData>(() => {
+  // no mandatory fields
+})

package/src/test/db/abstract-index.test.ts

@@ -0,0 +1,86 @@
+import { AbstractIndex } from '../../main/db/abstract-index'
+
+interface TestObject {
+  key: string
+  otherValue: number
+}
+
+describe(AbstractIndex.name, () => {
+  describe('Constructor', () => {
+    test(`should accept the key field`, () => {
+      new AbstractIndex<TestObject>('key')
+    })
+  })
+
+  describe('value', () => {
+    test(`should return the original values`, () => {
+      const values = [
+        { key: '1', otherValue: 1 },
+        { key: '2', otherValue: 2 },
+      ]
+      const index = new AbstractIndex<TestObject>('key')
+      index.load(values)
+
+      expect(index.values).toStrictEqual(values)
+    })
+  })
+
+  describe('get', () => {
+    test(`should return the indexed value on match`, () => {
+      const index = new AbstractIndex<TestObject>('key')
+      index.load([
+        { key: '1', otherValue: 1 },
+        { key: '2', otherValue: 2 },
+      ])
+
+      expect(index.get('2')).toStrictEqual({ key: '2', otherValue: 2 })
+    })
+
+    test(`should return undefined on no match`, () => {
+      const index = new AbstractIndex<TestObject>('key')
+
+      expect(index.get('2')).toBeUndefined()
+    })
+
+    test(`should return undefined on undefined key`, () => {
+      const index = new AbstractIndex<TestObject>('key')
+      const key = undefined
+      expect(index.get(key)).toBeUndefined()
+    })
+  })
+
+  describe('load', () => {
+    test(`should reset the index when used`, () => {
+      const index = new AbstractIndex<TestObject>('key')
+      index.load([
+        { key: '1', otherValue: 1 },
+        { key: '2', otherValue: 2 },
+      ])
+
+      expect(index.get('2')).toStrictEqual({ key: '2', otherValue: 2 })
+
+      index.load([
+        { key: '3', otherValue: 3 },
+      ])
+      expect(index.get('1')).toBeUndefined()
+      expect(index.get('2')).toBeUndefined()
+      expect(index.get('3')).toStrictEqual({ key: '3', otherValue: 3 })
+    })
+
+    test(`should accept an undefined value`, () => {
+      const index = new AbstractIndex<TestObject>('key')
+      const values = undefined
+      index.load(values)
+
+      expect(index.values).toHaveLength(0)
+    })
+
+    test(`should throw an error on duplicate key`, () => {
+      const index = new AbstractIndex<TestObject>('key')
+      expect(() => index.load([
+        { key: '1', otherValue: 1 },
+        { key: '1', otherValue: 1 },
+      ])).toThrow('Duplicate key [1]')
+    })
+  })
+})