wip: fix a few bugs and add some tests

Author: Bas950

packages/util/package.json

@@ -17,7 +17,8 @@
   ],
   "exports": {
     ".": "./dist/index.js",
-    "./browser": "./dist/browser.js"
+    "./browser": "./dist/browser.js",
+    "./db": "./dist/db.js"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

packages/util/src/functions/binarySearch.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from 'vitest'
+import { binarySearch } from './binarySearch'
+
+describe('binarySearch', () => {
+  describe('uint32Array tests', () => {
+    const uint32Array = new Uint32Array([1, 3, 5, 7, 9, 11, 13, 15])
+
+    it('should find existing elements', () => {
+      expect(binarySearch(uint32Array, 1)).toBe(0)
+      expect(binarySearch(uint32Array, 7)).toBe(3)
+      expect(binarySearch(uint32Array, 15)).toBe(7)
+    })
+
+    it('should return insertion point for non-existing elements', () => {
+      expect(binarySearch(uint32Array, 4)).toBe(1)
+      expect(binarySearch(uint32Array, 10)).toBe(4)
+      expect(binarySearch(uint32Array, 16)).toBe(7)
+    })
+
+    it('should return null for elements smaller than all in the array', () => {
+      expect(binarySearch(uint32Array, 0)).toBe(null)
+    })
+
+    it('should work with an array of length 1', () => {
+      const singleElementArray = new Uint32Array([5])
+      expect(binarySearch(singleElementArray, 5)).toBe(0)
+      expect(binarySearch(singleElementArray, 3)).toBe(null)
+      expect(binarySearch(singleElementArray, 7)).toBe(0)
+    })
+
+    it('should work with an empty array', () => {
+      const emptyArray = new Uint32Array([])
+      expect(binarySearch(emptyArray, 5)).toBe(null)
+    })
+  })
+
+  describe('bigUint64Array tests', () => {
+    const bigUint64Array = new BigUint64Array([1n, 3n, 5n, 7n, 9n, 11n, 13n, 15n])
+
+    it('should find existing elements', () => {
+      expect(binarySearch(bigUint64Array, 1n)).toBe(0)
+      expect(binarySearch(bigUint64Array, 7n)).toBe(3)
+      expect(binarySearch(bigUint64Array, 15n)).toBe(7)
+    })
+
+    it('should return insertion point for non-existing elements', () => {
+      expect(binarySearch(bigUint64Array, 4n)).toBe(1)
+      expect(binarySearch(bigUint64Array, 10n)).toBe(4)
+      expect(binarySearch(bigUint64Array, 16n)).toBe(7)
+    })
+
+    it('should return null for elements smaller than all in the array', () => {
+      expect(binarySearch(bigUint64Array, 0n)).toBe(null)
+    })
+
+    it('should work with an array of length 1', () => {
+      const singleElementArray = new BigUint64Array([5n])
+      expect(binarySearch(singleElementArray, 5n)).toBe(0)
+      expect(binarySearch(singleElementArray, 3n)).toBe(null)
+      expect(binarySearch(singleElementArray, 7n)).toBe(0)
+    })
+
+    it('should work with an empty array', () => {
+      const emptyArray = new BigUint64Array([])
+      expect(binarySearch(emptyArray, 5n)).toBe(null)
+    })
+  })
+
+  describe('edge cases', () => {
+    it('should handle the maximum possible Uint32 value', () => {
+      const maxUint32Array = new Uint32Array([4294967295])
+      expect(binarySearch(maxUint32Array, 4294967295)).toBe(0)
+    })
+
+    it('should handle the maximum possible BigUint64 value', () => {
+      const maxBigUint64Array = new BigUint64Array([18446744073709551615n])
+      expect(binarySearch(maxBigUint64Array, 18446744073709551615n)).toBe(0)
+    })
+  })
+})

packages/util/src/functions/countryCodeToNumber.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest'
+import { countryCodeToNumber } from './countryCodeToNumber'
+
+describe('countryCodeToNumber', () => {
+  it('should convert "AA" to 0', () => {
+    expect(countryCodeToNumber('AA')).toBe(0)
+  })
+
+  it('should convert "ZZ" to 675', () => {
+    expect(countryCodeToNumber('ZZ')).toBe(675)
+  })
+
+  it('should convert "CA" to 52', () => {
+    expect(countryCodeToNumber('CA')).toBe(52)
+  })
+
+  it('should convert "US" to 538', () => {
+    expect(countryCodeToNumber('US')).toBe(538)
+  })
+
+  it('should throw an error for lowercase input', () => {
+    expect(() => countryCodeToNumber('aa')).toThrow('Input must be a valid two-letter country code (A-Z)')
+  })
+
+  it('should throw an error for input with non-alphabetic characters', () => {
+    expect(() => countryCodeToNumber('A1')).toThrow('Input must be a valid two-letter country code (A-Z)')
+  })
+
+  it('should throw an error for input with more than two characters', () => {
+    expect(() => countryCodeToNumber('USA')).toThrow('Input must be a valid two-letter country code (A-Z)')
+  })
+
+  it('should throw an error for input with less than two characters', () => {
+    expect(() => countryCodeToNumber('A')).toThrow('Input must be a valid two-letter country code (A-Z)')
+  })
+
+  it('should throw an error for empty input', () => {
+    expect(() => countryCodeToNumber('')).toThrow('Input must be a valid two-letter country code (A-Z)')
+  })
+})

packages/util/src/functions/getSettings.test.ts

@@ -0,0 +1,198 @@
+import type { IpLocationApiInputSettings } from './getSettings'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { DEFAULT_SETTINGS, LOCATION_FIELDS, MAIN_FIELDS } from '../constants'
+import { getSettings } from './getSettings'
+
+describe('getSettings', () => {
+  const originalEnv = process.env
+  const originalArgv = process.argv
+
+  beforeEach(() => {
+    vi.resetModules()
+    process.env = { ...originalEnv }
+    process.argv = [...originalArgv]
+  })
+
+  afterEach(() => {
+    process.env = originalEnv
+    process.argv = originalArgv
+  })
+
+  it('should return default settings when no input is provided', () => {
+    const settings = getSettings()
+    expect(settings).toMatchObject({
+      licenseKey: DEFAULT_SETTINGS.licenseKey,
+      series: DEFAULT_SETTINGS.series,
+      fields: DEFAULT_SETTINGS.fields,
+      language: DEFAULT_SETTINGS.language,
+      smallMemory: DEFAULT_SETTINGS.smallMemory,
+      smallMemoryFileSize: DEFAULT_SETTINGS.smallMemoryFileSize,
+    })
+  })
+
+  it('should override default settings with input settings', () => {
+    const inputSettings: IpLocationApiInputSettings = {
+      licenseKey: 'test-key',
+      series: 'GeoIP2',
+      fields: ['country', 'city'],
+      language: 'es',
+      smallMemory: true,
+      smallMemoryFileSize: 8192,
+    }
+    const settings = getSettings(inputSettings)
+    expect(settings).toMatchObject({
+      licenseKey: 'test-key',
+      series: 'GeoIP2',
+      fields: ['country', 'city'],
+      language: 'es',
+      smallMemory: true,
+      smallMemoryFileSize: 8192,
+    })
+  })
+
+  it('should use environment variables to override default settings', () => {
+    process.env.ILA_LICENSE_KEY = 'env-key'
+    process.env.ILA_SERIES = 'GeoIP2'
+    process.env.ILA_FIELDS = 'country,city'
+    process.env.ILA_LANGUAGE = 'fr'
+    process.env.ILA_SMALL_MEMORY = 'true'
+    process.env.ILA_SMALL_MEMORY_FILE_SIZE = '16384'
+
+    const settings = getSettings()
+    expect(settings).toMatchObject({
+      licenseKey: 'env-key',
+      series: 'GeoIP2',
+      fields: ['country', 'city'],
+      language: 'fr',
+      smallMemory: true,
+      smallMemoryFileSize: 16384,
+    })
+  })
+
+  it('should use CLI arguments to override default and environment settings', () => {
+    process.env.ILA_LICENSE_KEY = 'env-key'
+    process.argv = [
+      ...process.argv,
+      'ILA_LICENSE_KEY=cli-key',
+      'ILA_SERIES=GeoIP2',
+      'ILA_FIELDS=country,region1',
+      'ILA_LANGUAGE=de',
+      'ILA_SMALL_MEMORY=true',
+      'ILA_SMALL_MEMORY_FILE_SIZE=32768',
+    ]
+
+    const settings = getSettings()
+    expect(settings).toMatchObject({
+      licenseKey: 'cli-key',
+      series: 'GeoIP2',
+      fields: ['country', 'region1'],
+      language: 'de',
+      smallMemory: true,
+      smallMemoryFileSize: 32768,
+    })
+  })
+
+  it('should process "all" fields correctly', () => {
+    const inputSettings: IpLocationApiInputSettings = {
+      fields: 'all',
+    }
+    const settings = getSettings(inputSettings)
+    expect(settings.fields).toEqual([...MAIN_FIELDS, ...LOCATION_FIELDS])
+
+    process.argv = [...process.argv, 'ILA_FIELDS=all']
+    const settings2 = getSettings()
+    expect(settings2.fields).toEqual([...MAIN_FIELDS, ...LOCATION_FIELDS])
+  })
+
+  it('should filter out invalid fields', () => {
+    const inputSettings: IpLocationApiInputSettings = {
+      fields: ['country', 'invalid_field', 'city'] as any,
+    }
+    const settings = getSettings(inputSettings)
+    expect(settings.fields).toEqual(['country', 'city'])
+  })
+
+  it('should handle invalid fields input', () => {
+    const inputSettings: IpLocationApiInputSettings = {
+      fields: 0 as any,
+    }
+    const settings = getSettings(inputSettings)
+    expect(settings.fields).toEqual(DEFAULT_SETTINGS.fields)
+  })
+
+  it('should use default fields if all provided fields are invalid', () => {
+    const inputSettings: IpLocationApiInputSettings = {
+      fields: ['invalid_field1', 'invalid_field2'] as any,
+    }
+    const settings = getSettings(inputSettings)
+    expect(settings.fields).toEqual(DEFAULT_SETTINGS.fields)
+  })
+
+  it('should process directory paths correctly', () => {
+    const inputSettings: IpLocationApiInputSettings = {
+      dataDir: '../custom-data',
+      tmpDataDir: '/tmp/custom-tmp',
+    }
+    const settings = getSettings(inputSettings)
+    expect(settings.dataDir).toMatch(/custom-data$/)
+    expect(settings.tmpDataDir).toBe('/tmp/custom-tmp')
+  })
+
+  it('should calculate correct record sizes and database settings', () => {
+    const inputSettings: IpLocationApiInputSettings = {
+      fields: ['country', 'city', 'latitude', 'longitude'],
+      smallMemory: true,
+      smallMemoryFileSize: 4096,
+    }
+    const settings = getSettings(inputSettings)
+    expect(settings.dataType).toBe('City')
+    expect(settings.locationFile).toBe(true)
+    expect(settings.mainRecordSize).toBeGreaterThan(0)
+    expect(settings.locationRecordSize).toBeGreaterThan(0)
+    expect(settings.v4.recordSize).toBeGreaterThan(settings.mainRecordSize)
+    expect(settings.v6.recordSize).toBeGreaterThan(settings.mainRecordSize)
+    expect(settings.v4.fileLineMax).toBeGreaterThan(0)
+    expect(settings.v6.fileLineMax).toBeGreaterThan(0)
+
+    const settings2 = getSettings({
+      fields: ['country', 'city', 'latitude', 'longitude'],
+      smallMemory: true,
+      smallMemoryFileSize: 0,
+    })
+    expect(settings2.dataType).toBe('City')
+    expect(settings2.locationFile).toBe(true)
+    expect(settings2.mainRecordSize).toBeGreaterThan(0)
+    expect(settings2.locationRecordSize).toBeGreaterThan(0)
+    expect(settings2.v4.recordSize).toBeGreaterThan(settings2.mainRecordSize)
+    expect(settings2.v6.recordSize).toBeGreaterThan(settings2.mainRecordSize)
+    expect(settings2.v4.fileLineMax).toBe(1)
+    expect(settings2.v6.fileLineMax).toBe(1)
+  })
+
+  it('should generate correct fieldDir', () => {
+    const inputSettings: IpLocationApiInputSettings = {
+      fields: ['country', 'city'],
+      dataDir: '/custom/data/dir',
+    }
+    const settings = getSettings(inputSettings)
+    const expectedFieldDir = join('/custom/data/dir', (16 + 2048).toString(36))
+    expect(settings.fieldDir).toBe(expectedFieldDir)
+  })
+
+  it('should handle invalid language input', () => {
+    const inputSettings: IpLocationApiInputSettings = {
+      language: 'invalid_language' as any,
+    }
+    const settings = getSettings(inputSettings)
+    expect(settings.language).toBe(DEFAULT_SETTINGS.language)
+  })
+
+  it('should handle invalid series input', () => {
+    const inputSettings: IpLocationApiInputSettings = {
+      series: 'InvalidSeries' as any,
+    }
+    const settings = getSettings(inputSettings)
+    expect(settings.series).toBe(DEFAULT_SETTINGS.series)
+  })
+})

packages/util/src/functions/getSettings.ts

@@ -133,7 +133,7 @@ export function getSettings(settings?: IpLocationApiInputSettings): IpLocationAp
     ...DEFAULT_SETTINGS,
     ...envSettings,
     ...cliSettings,
-    ...settings,
+    ...(settings ?? {}),
   }
 
   //* Process and validate individual settings
@@ -187,16 +187,21 @@ export function getSettings(settings?: IpLocationApiInputSettings): IpLocationAp
  * @returns Partial IpLocationApiInputSettings
  */
 function getFromIlaObject(ilaObject: Record<string, string | undefined>): Partial<IpLocationApiInputSettings> {
-  return {
+  const settings = {
     licenseKey: ilaObject[getKey('licenseKey')],
     series: ilaObject[getKey('series')] as 'GeoLite2' | 'GeoIP2',
     dataDir: ilaObject[getKey('dataDir')],
     tmpDataDir: ilaObject[getKey('tmpDataDir')],
     fields: ilaObject[getKey('fields')] === 'all' ? 'all' : ilaObject[getKey('fields')]?.split(',') as IpLocationApiInputSettings['fields'],
     language: ilaObject[getKey('language')] as IpLocationApiInputSettings['language'],
-    smallMemory: ilaObject[getKey('smallMemory')] === 'true',
-    smallMemoryFileSize: ilaObject[getKey('smallMemoryFileSize')] ? Number.parseInt(ilaObject[getKey('smallMemoryFileSize')]!) : DEFAULT_SETTINGS.smallMemoryFileSize,
+    smallMemory: ilaObject[getKey('smallMemory')] ? ilaObject[getKey('smallMemory')] === 'true' : undefined,
+    smallMemoryFileSize: ilaObject[getKey('smallMemoryFileSize')] ? Number.parseInt(ilaObject[getKey('smallMemoryFileSize')]!) : undefined,
   }
+
+  //* Remove keys with undefined values
+  return Object.fromEntries(
+    Object.entries(settings).filter(([_, value]) => value !== undefined),
+  ) as Partial<IpLocationApiInputSettings>
 }
 
 /**

packages/util/src/functions/getUnderscoreFill.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest'
+import { getUnderscoreFill } from './getUnderscoreFill'
+
+describe('getUnderscoreFill', () => {
+  it('should pad the string with underscores to the left', () => {
+    expect(getUnderscoreFill('test', 8)).toBe('____test')
+  })
+
+  it('should return the original string if it is already longer than the specified length', () => {
+    expect(getUnderscoreFill('longstring', 5)).toBe('longstring')
+  })
+
+  it('should return the original string if it is equal to the specified length', () => {
+    expect(getUnderscoreFill('equal', 5)).toBe('equal')
+  })
+
+  it('should handle empty string input', () => {
+    expect(getUnderscoreFill('', 3)).toBe('___')
+  })
+
+  it('should handle length of 0', () => {
+    expect(getUnderscoreFill('test', 0)).toBe('test')
+  })
+
+  it('should handle very long padding', () => {
+    expect(getUnderscoreFill('x', 100)).toBe(`${'_'.repeat(99)}x`)
+  })
+})