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

package/src/test/db/bundle-header.test.ts

@@ -0,0 +1,76 @@
+import { BundleHeader } from '../../main'
+import { bundleHeaderDataFixture } from '../api/bundle-header-data.fixture'
+
+describe(BundleHeader.name, () => {
+  describe('name', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ name: 'foo' }))
+      expect(header.name).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('name').create())
+      expect(header.name).toBeUndefined()
+    })
+  })
+
+  describe('description', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ description: 'foo' }))
+      expect(header.description).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('description').create())
+      expect(header.description).toBeUndefined()
+    })
+  })
+
+  describe('repositoryUrl', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ repositoryUrl: 'foo' }))
+      expect(header.repositoryUrl).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('repositoryUrl').create())
+      expect(header.repositoryUrl).toBeUndefined()
+    })
+  })
+
+  describe('changelogUrl', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ changelogUrl: 'foo' }))
+      expect(header.changelogUrl).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('changelogUrl').create())
+      expect(header.changelogUrl).toBeUndefined()
+    })
+  })
+
+  describe('links', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ links: [{ title: 'foo', href: 'bar' }] }))
+      expect(header.links).toStrictEqual([{ title: 'foo', href: 'bar' }])
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('links').create())
+      expect(header.links).toHaveLength(0)
+    })
+  })
+
+  describe('version', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ version: 'foo' }))
+      expect(header.version).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('version').create())
+      expect(header.version).toBeUndefined()
+    })
+  })
+})

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

@@ -1,237 +1,322 @@
 import { CohContentDatabase } from '../../main'
-import { contentBundleFixture } from '../api/content-bundle.fixture'
 import { archetypeDataFixture } from '../api/archetype-data.fixture'
 import { badgeDataFixture } from '../api/badge-data.fixture'
 import { zoneDataFixture } from '../api/zone-data.fixture'
 import { contactDataFixture } from '../api/contact-data.fixture'
 import { missionDataFixture } from '../api/mission-data.fixture'
+import { bundleDataFixture } from '../api/bundle-data.fixture'
 
 describe(CohContentDatabase.name, () => {
-  test('should load a basic bundle', () => {
-    new CohContentDatabase(contentBundleFixture.create())
+  describe('load', () => {
+    test('should load a basic bundle', () => {
+      const database = new CohContentDatabase()
+      database.load({})
+    })
+
+    test('should reset the database if load is called again', () => {
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({
+        header: { name: 'Homecoming' },
+        servers: ['Test'],
+        archetypes: [archetypeDataFixture.create()],
+        zones: [zoneDataFixture.create()],
+        contacts: [contactDataFixture.create()],
+        missions: [missionDataFixture.create()],
+        badges: [badgeDataFixture.create()],
+      }))
+
+      expect(database.header?.name).toEqual('Homecoming')
+      expect(database.servers).toHaveLength(1)
+      expect(database.archetypes).toHaveLength(1)
+      expect(database.zones).toHaveLength(1)
+      expect(database.contacts).toHaveLength(1)
+      expect(database.missions).toHaveLength(1)
+      expect(database.badges).toHaveLength(1)
+
+      database.load(bundleDataFixture.create({ header: { name: 'Reset' } }))
+      expect(database.header?.name).toEqual('Reset')
+      expect(database.servers).toHaveLength(0)
+      expect(database.archetypes).toHaveLength(0)
+      expect(database.zones).toHaveLength(0)
+      expect(database.contacts).toHaveLength(0)
+      expect(database.missions).toHaveLength(0)
+      expect(database.badges).toHaveLength(0)
+    })
+  })
+
+  describe('header', () => {
+    test(`should be undefined if not initialized`, () => {
+      const database = new CohContentDatabase()
+      expect(database.header).toBeUndefined()
+    })
+
+    test(`should load values from bundle`, () => {
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture
+        .create({ header: { name: 'Homecoming' } }))
+
+      expect(database.header?.name).toBe('Homecoming')
+    })
   })
 
   describe('servers', () => {
     test(`should accept an undefined field`, () => {
-      const data = contentBundleFixture
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture
         .omit('servers')
-        .create()
-      expect(new CohContentDatabase(data).servers).toHaveLength(0)
+        .create())
+
+      expect(database.servers).toHaveLength(0)
+    })
+
+    test(`should be empty if uninitialized`, () => {
+      const database = new CohContentDatabase()
+      expect(database.servers).toHaveLength(0)
     })
 
     test(`should load values from bundle`, () => {
-      const data = contentBundleFixture
-        .create({ servers: ['Foo', 'Bar'] })
-      expect(new CohContentDatabase(data).servers).toStrictEqual(['Foo', 'Bar'])
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture
+        .create({ servers: ['Foo', 'Bar'] }))
+
+      expect(database.servers).toStrictEqual(['Foo', 'Bar'])
     })
   })
 
   describe('archetypes', () => {
     test(`should throw an error on duplicate key`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      expect(() => database.load(bundleDataFixture.create({
         archetypes: [
           archetypeDataFixture.create({ key: 'foo' }),
           archetypeDataFixture.create({ key: 'foo' }),
         ],
-      })
-      expect(() => new CohContentDatabase(data)).toThrow(`Duplicate archetype key 'foo'`)
+      }))).toThrow(`Duplicate key [foo]`)
     })
 
     test(`should accept an undefined field`, () => {
-      const data = contentBundleFixture
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture
         .omit('archetypes')
-        .create()
-      expect(new CohContentDatabase(data).archetypes).toHaveLength(0)
+        .create())
+      expect(database.archetypes).toHaveLength(0)
     })
 
     test(`should load data from bundle`, () => {
-      const data = contentBundleFixture
-        .create({ archetypes: [archetypeDataFixture.create({ key: 'foo' })] })
-      expect(new CohContentDatabase(data).getArchetype('foo')).not.toBeUndefined()
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture
+        .create({ archetypes: [archetypeDataFixture.create({ key: 'foo' })] }))
+      expect(database.getArchetype('foo')).not.toBeUndefined()
     })
   })
 
   describe('badges', () => {
     test(`should throw an error on duplicate key`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      expect(() => database.load(bundleDataFixture.create({
         badges: [
           badgeDataFixture.create({ key: 'foo' }),
           badgeDataFixture.create({ key: 'foo' }),
         ],
-      })
-      expect(() => new CohContentDatabase(data)).toThrow('Duplicate badge key [foo]')
+      }))).toThrow('Duplicate key [foo]')
     })
 
     test(`should accept an undefined field`, () => {
-      const data = contentBundleFixture
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture
         .omit('badges')
-        .create()
-      expect(new CohContentDatabase(data).badges).toHaveLength(0)
+        .create())
+      expect(database.badges).toHaveLength(0)
     })
   })
 
   describe('zones', () => {
     test(`should throw an error on duplicate zone`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      expect(() => database.load(bundleDataFixture.create({
         zones: [
           zoneDataFixture.create({ key: 'foo' }),
           zoneDataFixture.create({ key: 'foo' }),
         ],
-      })
-      expect(() => new CohContentDatabase(data)).toThrow(`Duplicate zone key 'foo'`)
+      }))).toThrow(`Duplicate key [foo]`)
     })
 
     test(`should accept an undefined field`, () => {
-      const data = contentBundleFixture
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture
         .omit('zones')
-        .create()
-      expect(new CohContentDatabase(data).zones).toHaveLength(0)
+        .create())
+      expect(database.zones).toHaveLength(0)
     })
   })
 
   describe('contacts', () => {
     test(`should throw an error on duplicate contact`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      expect(() => database.load(bundleDataFixture.create({
         contacts: [
           contactDataFixture.create({ key: 'foo' }),
           contactDataFixture.create({ key: 'foo' }),
         ],
-      })
-      expect(() => new CohContentDatabase(data)).toThrow(`Duplicate contact key 'foo'`)
+      }))).toThrow(`Duplicate key [foo]`)
     })
 
     test(`should accept an undefined field`, () => {
-      const data = contentBundleFixture
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture
         .omit('contacts')
-        .create()
-      expect(new CohContentDatabase(data).contacts).toHaveLength(0)
+        .create())
+      expect(database.contacts).toHaveLength(0)
     })
   })
 
   describe('missions', () => {
     test(`should throw an error on duplicate mission`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      expect(() => database.load(bundleDataFixture.create({
         missions: [
           missionDataFixture.create({ key: 'foo' }),
           missionDataFixture.create({ key: 'foo' }),
         ],
-      })
-      expect(() => new CohContentDatabase(data)).toThrow(`Duplicate mission key 'foo'`)
+      }))).toThrow(`Duplicate key [foo]`)
     })
 
     test(`should accept an undefined field`, () => {
-      const data = contentBundleFixture
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture
         .omit('missions')
-        .create()
-      expect(new CohContentDatabase(data).missions).toHaveLength(0)
+        .create())
+      expect(database.missions).toHaveLength(0)
     })
   })
 
   describe('getArchetype', () => {
     test(`should retrieve archetype from the index`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({
         archetypes: [archetypeDataFixture.create({ key: 'foo' })],
-      })
-
-      expect(new CohContentDatabase(data).getArchetype('foo')).not.toBeUndefined()
+      }))
+      expect(database.getArchetype('foo')).not.toBeUndefined()
     })
 
     test(`should return undefined for unknown archetype`, () => {
-      const data = contentBundleFixture.create({ archetypes: [] })
-      expect(new CohContentDatabase(data).getArchetype('foo')).toBeUndefined()
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({ archetypes: [] }))
+      expect(database.getArchetype('foo')).toBeUndefined()
     })
 
     test(`should return undefined for undefined key`, () => {
-      expect(new CohContentDatabase(contentBundleFixture.create({ archetypes: [] })).getArchetype()).toBeUndefined()
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({ archetypes: [] }))
+      const key = undefined
+      expect(database.getArchetype(key)).toBeUndefined()
     })
   })
 
   describe('getZone', () => {
     test(`should retrieve zone from the index`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({
         zones: [zoneDataFixture.create({ key: 'foo' })],
-      })
+      }))
 
-      expect(new CohContentDatabase(data).getZone('foo')).not.toBeUndefined()
+      expect(database.getZone('foo')).not.toBeUndefined()
     })
 
     test(`should return undefined for unknown zone`, () => {
-      const data = contentBundleFixture.create({ zones: [] })
-      expect(new CohContentDatabase(data).getZone('foo')).toBeUndefined()
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({ zones: [] }))
+      expect(database.getZone('foo')).toBeUndefined()
     })
 
     test(`should return undefined for undefined key`, () => {
-      expect(new CohContentDatabase(contentBundleFixture.create({ zones: [] })).getZone()).toBeUndefined()
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({ zones: [] }))
+      const key = undefined
+      expect(database.getZone(key)).toBeUndefined()
     })
   })
 
   describe('getContact', () => {
     test(`should retrieve contact from the index`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({
         contacts: [contactDataFixture.create({ key: 'foo' })],
-      })
-
-      expect(new CohContentDatabase(data).getContact('foo')).not.toBeUndefined()
+      }))
+      expect(database.getContact('foo')).not.toBeUndefined()
     })
 
     test(`should return undefined for unknown contact`, () => {
-      const data = contentBundleFixture.create({ contacts: [] })
-      expect(new CohContentDatabase(data).getContact('foo')).toBeUndefined()
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({ contacts: [] }))
+      expect(database.getContact('foo')).toBeUndefined()
     })
 
     test(`should return undefined for undefined key`, () => {
-      expect(new CohContentDatabase(contentBundleFixture.create({ contacts: [] })).getContact()).toBeUndefined()
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({ contacts: [] }))
+      const key = undefined
+      expect(database.getContact(key)).toBeUndefined()
     })
   })
 
   describe('getMission', () => {
     test(`should retrieve mission from the index`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({
         missions: [missionDataFixture.create({ key: 'foo' })],
-      })
-
-      expect(new CohContentDatabase(data).getMission('foo')).not.toBeUndefined()
+      }))
+      expect(database.getMission('foo')).not.toBeUndefined()
     })
 
     test(`should return undefined for unknown mission`, () => {
-      const data = contentBundleFixture.create({ missions: [] })
-      expect(new CohContentDatabase(data).getMission('foo')).toBeUndefined()
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({ missions: [] }))
+      expect(database.getMission('foo')).toBeUndefined()
     })
 
     test(`should return undefined for undefined key`, () => {
-      expect(new CohContentDatabase(contentBundleFixture.create({ missions: [] })).getMission()).toBeUndefined()
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({ missions: [] }))
+      const key = undefined
+      expect(database.getMission(key)).toBeUndefined()
     })
   })
 
   describe('getBadge', () => {
     test(`should retrieve badge from the index`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({
         badges: [badgeDataFixture.create({ key: 'foo' })],
-      })
-
-      expect(new CohContentDatabase(data).getBadge('foo')).not.toBeUndefined()
+      }))
+      expect(database.getBadge('foo')).not.toBeUndefined()
     })
 
     test(`should return undefined for unknown badge`, () => {
-      const data = contentBundleFixture.create({ badges: [] })
-      expect(new CohContentDatabase(data).getBadge('foo')).toBeUndefined()
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({ badges: [] }))
+      expect(database.getBadge('foo')).toBeUndefined()
     })
 
     test(`should return undefined for undefined key`, () => {
-      expect(new CohContentDatabase(contentBundleFixture.create({ badges: [] })).getBadge()).toBeUndefined()
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({ badges: [] }))
+      const key = undefined
+      expect(database.getBadge(key)).toBeUndefined()
     })
   })
 
   describe('searchBadges', () => {
     test(`should search the badge list`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      database.load(bundleDataFixture.create({
         badges: [
           badgeDataFixture.create({ key: 'foo', name: [{ value: 'Foo' }] }),
           badgeDataFixture.create({ key: 'bar', name: [{ value: 'Bar' }] }),
         ],
-      })
+      }))
 
-      const result = new CohContentDatabase(data).searchBadges({ query: { str: 'oo' } })
+      const result = database.searchBadges({ query: { str: 'oo' } })
       expect(result.totalItems).toBe(1)
       expect(result.items.map(x => x.key)).toStrictEqual(['foo'])
     })

package/src/test/integration.test.ts

@@ -0,0 +1,16 @@
+import { BundleData } from '../main'
+import { TEST_BADGE } from './api/badge-data.test'
+
+/**
+ * If you change this test, update the example in the README as well
+ */
+export const TEST_BUNDLE: BundleData = {
+  header: { name: 'My Content Bundle' },
+  badges: [TEST_BADGE],
+}
+
+describe('BundleData', () => {
+  test('should be a usable interface', () => {
+    expect(TEST_BUNDLE).not.toBeUndefined()
+  })
+})

package/src/main/api/change.ts

@@ -1,17 +0,0 @@
-import { MarkdownString } from './markdown-string'
-
-export interface Change {
-  /**
-   * The version number in {@link http://semver.org|semver} format.
-   */
-  version: string
-  /**
-   * Date of the change.
-   */
-  date: Date
-
-  /**
-   * Description of the change.
-   */
-  description: MarkdownString
-}

package/src/main/changelog.ts

@@ -1,29 +0,0 @@
-import { Change } from './api/change'
-
-export const CHANGELOG: Change[] = [
-  {
-    version: '2.0.0',
-    date: new Date('2025-03-12'),
-    description: ''
-      + '* Replaced redundant interfaces with their concrete equivalents.\n'
-      + `* Server groups are now referred to as 'forks'.\n`
-      + '* Replaced enums with union types and changed values to `kebab-case`.\n'
-      + '* `IServerGroupData` is now `ContentBundle` and each database instance is now designed to accept only a single bundle.\n'
-      + '* `GameMap` is now `Zone`.\n'
-      + '* Removed the `serverGroup` property from entities to simplify the object tree given that only a single context can exist per db now.\n'
-      + '* Added a simple indexing and search function for badge names, text and acquisition info.\n'
-      + '* Zone and badge references now follow a standard Markdown link format with a `badge://` or `map://` protocol.\n'
-      + '* Badge partials are now known as badge requirements.\n'
-      + '* Removed the `VidiotMap` API as it was never used or fleshed out properly.\n'
-      + '* Added formal support for Missions and Contacts in badge requirements.\n'
-      + '* Move exploration badge locations into badge requirement list.\n'
-      + '* Standardized pluralization of some field names (name, icon).\n'
-      + '* Combined `settitle` ids into a single tuple field.\n'
-      + '* Change from GNU to The Unlicense.\n'
-      + '* Removed all third-party dependencies.\n'
-      + '* Moved from webpack to rollup for packaging.\n'
-      + '* Add eslint for linting.\n'
-      + '* Add jest for unit tests.\n'
-      + '* Added GitHub Actions for CI.\n',
-  },
-]

package/src/main/db/bundle-metadata.ts

@@ -1,39 +0,0 @@
-import { ContentBundle } from '../api/content-bundle'
-import { Change } from '../api/change'
-import { Link } from '../api/link'
-import { MarkdownString } from '../api/markdown-string'
-
-export class BundleMetadata {
-  /**
-   * Name of the content bundle.
-   */
-  readonly name: string
-
-  /**
-   * Description of the fork.
-   */
-  readonly description?: MarkdownString
-
-  /**
-   * Repository where the db content package is maintained.
-   */
-  readonly repository?: string
-
-  /**
-   * List of external links. Wiki, forums, etc.
-   */
-  readonly links: Link[]
-
-  /**
-   * Change log for this data package.
-   */
-  readonly changelog: Change[]
-
-  constructor(bundle: ContentBundle) {
-    this.name = bundle.name
-    this.description = bundle.description
-    this.repository = bundle.repository
-    this.links = bundle.links ?? []
-    this.changelog = bundle.changelog ?? []
-  }
-}

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

@@ -1,6 +0,0 @@
-import { defineFixture } from 'efate'
-import { ContentBundle } from '../../main'
-
-export const contentBundleFixture = defineFixture<ContentBundle>((t) => {
-  t.name.as(index => `Bundle ${index}`)
-})

package/src/test/api/content-bundle.test.ts

@@ -1,14 +0,0 @@
-import { ContentBundle } from '../../main'
-import { TEST_BADGE } from './badge-data.test'
-
-// If you change this test, update the example in the README as well
-export const TEST_BUNDLE: ContentBundle = {
-  name: 'My Content Bundle',
-  badges: [TEST_BADGE],
-}
-
-describe('ContentBundle', () => {
-  test('should be a usable interface', () => {
-    expect(TEST_BUNDLE).not.toBeUndefined()
-  })
-})

package/src/test/changelog.test.ts

@@ -1,36 +0,0 @@
-import { CHANGELOG } from '../main'
-
-describe('CHANGELOG', () => {
-  test('should be extant', () => {
-    expect(CHANGELOG).not.toBeUndefined()
-    expect(CHANGELOG).not.toBeUndefined()
-  })
-
-  test('should be an array', () => {
-    expect(Array.isArray(CHANGELOG)).toBeTruthy()
-  })
-
-  test('should have only semver versions', () => {
-    // semver.org - https://regex101.com/r/vkijKf/1/
-    const pattern = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/
-
-    for (const change of CHANGELOG) {
-      expect(pattern.test(change.version)).toBeTruthy()
-    }
-  })
-
-  test('should have dates', () => {
-    for (const change of CHANGELOG) {
-      const date = change.date
-      expect(date).not.toBeUndefined()
-      expect(date).not.toBeUndefined()
-    }
-  })
-
-  test('should have descriptions', () => {
-    for (const change of CHANGELOG) {
-      expect(change).not.toBeUndefined()
-      expect(change).not.toBeUndefined()
-    }
-  })
-})