@bemoje/cli 0.0.4 → 0.0.6

package/src/opt/OptionReader.ts

@@ -0,0 +1,61 @@
+import { OptionBuilder } from './OptionBuilder'
+import { OptionHelpers } from './OptionHelpers'
+
+export class OptionReader {
+  constructor(protected readonly parent: OptionBuilder) {}
+
+  get $() {
+    return this.parent.$
+  }
+  get option() {
+    return this.parent.$
+  }
+  get description() {
+    return this.$.description
+  }
+  get optional() {
+    return this.$.optional
+  }
+  get mandatory() {
+    return this.$.mandatory
+  }
+  get hidden() {
+    return this.$.hidden
+  }
+  get variadic() {
+    return this.$.variadic
+  }
+  get short() {
+    return this.$.short
+  }
+  get long() {
+    return this.$.long
+  }
+  get preset() {
+    return this.$.presetArg
+  }
+  get default() {
+    return this.$.defaultValue
+  }
+  get choices() {
+    return this.$.argChoices
+  }
+  get env() {
+    return this.$.envVar
+  }
+  get flags() {
+    return this.$.flags
+  }
+  get name() {
+    return this.$.name()
+  }
+  get attributeName() {
+    return this.$.attributeName()
+  }
+  get defaultValueDescription() {
+    return this.$.defaultValueDescription
+  }
+  get hasArgument() {
+    return OptionHelpers.hasArgument(this.parent.$)
+  }
+}

package/src/types/IConfig.ts

@@ -0,0 +1,25 @@
+import type { JsonValue } from '../util/types/JsonValue'
+import type { TStringParser } from '../util/types/TStringParser'
+import type { TValidator } from '../util/types/TValidator'
+
+export interface IConfig<Val extends JsonValue> {
+  /**
+   * The default value of the property.
+   */
+  defaultValue: Val
+
+  /**
+   * The description of the property.
+   */
+  description: string
+
+  /**
+   * A function that parses a string to the desired type.
+   */
+  parse?: TStringParser<Val>
+
+  /**
+   * A function that validates the value.
+   */
+  validate?: TValidator<Val>
+}

package/src/types/IPreset.ts

@@ -0,0 +1,16 @@
+import type { Any } from '../util/types/Any'
+import type { OptionValues } from '@commander-js/extra-typings'
+
+export interface IPreset {
+  description: string
+  presets: string[]
+  args: Any[]
+  options: OptionValues
+}
+
+export interface IPresetPartial {
+  description: string
+  presets?: string[]
+  args?: Any[]
+  options?: OptionValues
+}

package/src/util/array/arrLast.test.ts

@@ -0,0 +1,25 @@
+import { arrLast } from './arrLast'
+
+describe(arrLast.name, () => {
+  it('should return the last element of a non-empty array', () => {
+    const array = [1, 2, 3]
+    const result = arrLast(array)
+    expect(result).toBe(3)
+  })
+
+  it('should throw an error when called with an empty array', () => {
+    expect(() => arrLast([])).toThrow('Cannot get last element of empty array.')
+  })
+
+  it('should return the last element of an array with a single element', () => {
+    const array = ['a']
+    const result = arrLast(array)
+    expect(result).toBe('a')
+  })
+
+  it('should return the last element of an array with multiple elements of different types', () => {
+    const array = [1, 'a', false, null]
+    const result = arrLast(array)
+    expect(result).toBe(null)
+  })
+})

package/src/util/array/arrLast.ts

@@ -0,0 +1,15 @@
+/**
+ * Returns the last element of an array.
+ * Throws an error if the array is empty.
+ * @template T The type of elements in the array.
+ * @param array The array to get the last element from.
+ * @returns The last element of the array.
+ * @throws If the array is empty.
+ * @example const numbers = [1, 2, 3, 4, 5];
+ * const lastNumber = arrLast(numbers);
+ * //=> 5
+ */
+export function arrLast<T>(array: T[]): T {
+  if (!array.length) throw new Error('Cannot get last element of empty array.')
+  return array[array.length - 1]
+}

package/src/util/array/arrSome.test.ts

@@ -0,0 +1,78 @@
+import { arrSome } from './arrSome'
+
+describe('arrSome', () => {
+  it('example', () => {
+    const arr = ['hello', 'world']
+    expect(
+      arrSome(arr, (element: any) => {
+        return element.length > 5
+      })
+    ).toBe(false)
+    expect(
+      arrSome(arr, (element: any) => {
+        return element.length === 5
+      })
+    ).toBe(true)
+    expect(
+      arrSome([], (element: any) => {
+        return element.length === 5
+      })
+    ).toBe(false)
+  })
+
+  it('callback is passed all correct values', () => {
+    const arr = [1, 2, 3, 4, 5]
+    const indexCheck = new Array(arr.length)
+    arrSome(arr, (element: any, i: number, array: Array<any>) => {
+      expect(arr === array).toBe(true)
+      expect(arr[i] === array[i]).toBe(true)
+      expect(arr[i] === element).toBe(true)
+      expect(Number.isInteger(i)).toBe(true)
+      indexCheck[i] = arr[i]
+      return false
+    })
+    expect(indexCheck).toStrictEqual(arr)
+  })
+
+  it('should return false if the array is empty', () => {
+    const input: number[] = []
+    const predicate = (num: number) => num > 0
+
+    const result = arrSome(input, predicate)
+
+    expect(result).toBe(false)
+  })
+
+  it('should return false if no element satisfies the predicate', () => {
+    const input = [1, 2, 3, 4, 5]
+    const predicate = (num: number) => num > 5
+
+    const result = arrSome(input, predicate)
+
+    expect(result).toBe(false)
+  })
+
+  it('should return true if at least one element satisfies the predicate', () => {
+    const input = [1, 2, 3, 4, 5]
+    const predicate = (num: number) => num > 3
+
+    const result = arrSome(input, predicate)
+
+    expect(result).toBe(true)
+  })
+
+  it('should pass the index and the array to the predicate function', () => {
+    const input = [1, 2, 3, 4, 5]
+    const predicate = jest.fn((num: number, index: number, arr: number[]) => false)
+
+    const result = arrSome(input, predicate)
+
+    expect(result).toBe(false)
+    expect(predicate).toHaveBeenCalledTimes(5)
+    expect(predicate).toHaveBeenCalledWith(1, 0, input)
+    expect(predicate).toHaveBeenCalledWith(2, 1, input)
+    expect(predicate).toHaveBeenCalledWith(3, 2, input)
+    expect(predicate).toHaveBeenCalledWith(4, 3, input)
+    expect(predicate).toHaveBeenCalledWith(5, 4, input)
+  })
+})

package/src/util/array/arrSome.ts

@@ -0,0 +1,23 @@
+import type { ArrayPredicate } from './types/ArrayPredicate'
+
+/**
+ * Checks if at least one element in the array satisfies the provided predicate.
+ * @param predicate The predicate function to apply to each element.
+ * @template T The type of elements in the input array.
+ * @returns Returns `true` if at least one element in the array passes the test implemented by the provided function, otherwise `false`.
+ * @param input The array to check.
+ * @example ```ts
+ * const numbers = [1, 2, 3, 4, 5];
+ * const isEven = (num) => num % 2 === 0;
+ * arrSome(numbers, isEven);
+ * //=> true
+ * ```
+ */
+export function arrSome<T>(input: Array<T>, predicate: ArrayPredicate<T>): boolean {
+  for (let i = 0, len = input.length; i < len; i++) {
+    if (predicate(input[i], i, input) === true) {
+      return true
+    }
+  }
+  return false
+}

package/src/util/array/types/ArrayPredicate.ts

@@ -0,0 +1,10 @@
+/**
+ * Type definition for a predicate function that operates on arrays.
+ * @remarks This type is useful when you want to create a function that can be used with methods like `Array.prototype.filter`.
+ * @typeparam T - The type of elements in the array.
+ * @param value - The current element being processed in the array.
+ * @param index - The index of the current element being processed in the array.
+ * @param array - The array `ArrayPredicate` was called upon.
+ * @returns A boolean indicating whether the current element passes the test.
+ */
+export type ArrayPredicate<T> = (value: T, index: number, array: T[]) => boolean

package/src/util/db/JsonDB.test.ts

@@ -0,0 +1,214 @@
+import { JsonDB } from './JsonDB'
+import { readJsonFileSafeSync } from '../fs/readJsonFile/readJsonFileSafeSync'
+import { writeJsonFileSafe } from '../fs/writeJsonFile/writeJsonFileSafe'
+
+jest.mock('../fs/readJsonFile/readJsonFileSafeSync', () => ({
+  ...jest.requireActual('../fs/readJsonFile/readJsonFileSafeSync'),
+  readJsonFileSafeSync: jest.fn(),
+}))
+
+jest.mock('../fs/writeJsonFile/writeJsonFileSafe', () => ({
+  ...jest.requireActual('../fs/writeJsonFile/writeJsonFileSafe'),
+  writeJsonFileSafe: jest.fn(),
+}))
+
+describe('JsonDB', () => {
+  let jsonDB: JsonDB
+  const filepath = 'test.json'
+  const readJsonFileSafeSyncMock = readJsonFileSafeSync as jest.Mock
+
+  beforeEach(() => {
+    jsonDB = new JsonDB(filepath)
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe('constructor', () => {
+    it('should initialize data with an empty object if the file does not exist', () => {
+      readJsonFileSafeSyncMock.mockReturnValueOnce(null)
+      const jsonDB = new JsonDB(filepath)
+      expect(jsonDB.get()).toEqual({})
+    })
+
+    it('should initialize data with the contents of the file if it exists', () => {
+      const data = { key: 'value' }
+      readJsonFileSafeSyncMock.mockReturnValueOnce(data)
+      const jsonDB = new JsonDB(filepath)
+      expect(jsonDB.get()).toEqual(data)
+    })
+  })
+
+  describe('setFilepath', () => {
+    it('should set the filepath property', () => {
+      const newFilepath = 'new-test.json'
+      jsonDB.setFilepath(newFilepath)
+      expect(jsonDB['filepath']).toEqual(newFilepath)
+    })
+
+    it('should save the data to the JSON file if save is true', () => {
+      const newFilepath = 'new-test.json'
+      jsonDB.setFilepath(newFilepath, true)
+      expect(writeJsonFileSafe).toHaveBeenCalledWith(newFilepath, jsonDB.get(), { spaces: jsonDB['indents'] })
+    })
+
+    it('should not save the data to the JSON file if save is false', () => {
+      const newFilepath = 'new-test.json'
+      jsonDB.setFilepath(newFilepath, false)
+      expect(writeJsonFileSafe).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('save', () => {
+    it('should save the data to the JSON file', async () => {
+      await jsonDB.save()
+      expect(writeJsonFileSafe).toHaveBeenCalledWith(filepath, jsonDB.get(), { spaces: jsonDB['indents'] })
+    })
+
+    it('should save the data to the JSON file with the specified indents', async () => {
+      const indents = 2
+      await jsonDB.save(indents)
+      expect(writeJsonFileSafe).toHaveBeenCalledWith(filepath, jsonDB.get(), { spaces: indents })
+    })
+  })
+
+  describe('set', () => {
+    it('should set the data to the specified value if prefix is not provided', () => {
+      const value = { key: 'value' }
+      jsonDB.set(undefined, value)
+      expect(jsonDB.get()).toEqual(value)
+    })
+
+    it('should set the value at the specified prefix', () => {
+      const prefix = 'key'
+      const value = { key: 'value' }
+      jsonDB.set(prefix, value)
+      expect(jsonDB.get(prefix)).toEqual(value)
+    })
+
+    it('should create nested objects if the prefix contains dot-separated keys', () => {
+      const prefix = 'key1.key2.key3'
+      const value = 'value'
+      jsonDB.set(prefix, value)
+      expect(jsonDB.get()).toEqual({ key1: { key2: { key3: value } } })
+    })
+
+    it('should save the data to the JSON file if save is true', () => {
+      const value = { key: 'value' }
+      jsonDB.set(undefined, value, true)
+      expect(writeJsonFileSafe).toHaveBeenCalledWith(filepath, jsonDB.get(), { spaces: jsonDB['indents'] })
+    })
+
+    it('should not save the data to the JSON file if save is false', () => {
+      const value = { key: 'value' }
+      jsonDB.set(undefined, value, false)
+      expect(writeJsonFileSafe).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('get', () => {
+    it('should return the value associated with the key', () => {
+      const prefix = 'key'
+      const value = { key: 'value' }
+      jsonDB.set(prefix, value)
+      const result = jsonDB.get(prefix)
+      expect(result).toEqual(value)
+    })
+
+    it('should throw an error if no entry is found at the specified key', () => {
+      const prefix = 'key'
+      expect(() => jsonDB.get(prefix)).toThrowError(`No entry at '${prefix}'`)
+    })
+
+    it('should clone the value before returning it', () => {
+      const prefix = 'key'
+      const value = { key: 'value' }
+      jsonDB.set(prefix, value)
+      const result = jsonDB.get(prefix)
+      expect(result).not.toBe(value)
+    })
+  })
+
+  describe('getSafe', () => {
+    it('should return the value associated with the key', () => {
+      const prefix = 'key'
+      const value = { key: 'value' }
+      jsonDB.set(prefix, value)
+      const result = jsonDB.getSafe(prefix)
+      expect(result).toEqual(value)
+    })
+
+    it('should return undefined if no entry is found at the specified key', () => {
+      const prefix = 'key'
+      const result = jsonDB.getSafe(prefix)
+      expect(result).toBeUndefined()
+    })
+
+    it('should clone the value before returning it', () => {
+      const prefix = 'key'
+      const value = { key: 'value' }
+      jsonDB.set(prefix, value)
+      const result = jsonDB.getSafe(prefix)
+      expect(result).not.toBe(value)
+    })
+  })
+
+  describe('has', () => {
+    it('should return true if the key exists', () => {
+      const prefix = 'key'
+      const value = { key: 'value' }
+      jsonDB.set(prefix, value)
+      const result = jsonDB.has(prefix)
+      expect(result).toBe(true)
+    })
+
+    it('should return false if the key does not exist', () => {
+      const prefix = 'key'
+      const result = jsonDB.has(prefix)
+      expect(result).toBe(false)
+    })
+  })
+
+  describe('delete', () => {
+    it('should delete the data if prefix is not provided', () => {
+      const prefix = 'key'
+      const value = { key: 'value' }
+      jsonDB.set(prefix, value)
+      jsonDB.delete()
+      expect(jsonDB.get()).toEqual({})
+    })
+
+    it('should delete the value at the specified prefix', () => {
+      const prefix = 'key'
+      const value = { key: 'value' }
+      jsonDB.set(prefix, value)
+      jsonDB.delete(prefix)
+      expect(jsonDB.getSafe(prefix)).toBeUndefined()
+    })
+
+    it('should delete nested objects if the prefix contains dot-separated keys', () => {
+      const prefix = 'key1.key2.key3'
+      const value = { key: 'value' }
+      jsonDB.set(prefix, value)
+      jsonDB.delete(prefix)
+      expect(jsonDB.getSafe(prefix)).toBeUndefined()
+    })
+
+    it('should save the data to the JSON file if save is true', () => {
+      const prefix = 'key'
+      const value = { key: 'value' }
+      jsonDB.set(prefix, value)
+      jsonDB.delete(prefix, true)
+      expect(writeJsonFileSafe).toHaveBeenCalledWith(filepath, jsonDB.get(), { spaces: jsonDB['indents'] })
+    })
+
+    it('should not save the data to the JSON file if save is false', () => {
+      const prefix = 'key'
+      const value = { key: 'value' }
+      jsonDB.set(prefix, value, false)
+      jsonDB.delete(prefix, false)
+      expect(writeJsonFileSafe).not.toHaveBeenCalled()
+    })
+  })
+})

package/src/util/db/JsonDB.ts

@@ -0,0 +1,138 @@
+import { ensureThat } from '../validation/ensureThat'
+import { isObject } from '../validation/isObject'
+import type { JsonObject } from '../types/JsonObject'
+import type { JsonValue } from '../types/JsonValue'
+import { readJsonFileSafeSync } from '../fs/readJsonFile/readJsonFileSafeSync'
+import { writeJsonFileSafe } from '../fs/writeJsonFile/writeJsonFileSafe'
+
+/**
+ * Represents a simple JSON file database.
+ */
+export class JsonDB {
+  /**
+   * The data stored in the JSON database.
+   */
+  protected data: JsonObject
+
+  /**
+   * Creates a new instance of the JsonDB class.
+   * @param filepath - The filepath where the data file is stored or to be stored.
+   */
+  constructor(protected filepath: string, protected indents = 0) {
+    this.data = readJsonFileSafeSync(this.filepath) ?? {}
+  }
+
+  /**
+   * Saves the data to the JSON file.
+   */
+  async save(indents = this.indents): Promise<void> {
+    return await writeJsonFileSafe(this.filepath, this.data, { spaces: indents })
+  }
+
+  /**
+   * Sets the filepath of the JSON file.
+   * @param filepath - The new filepath.
+   */
+  setFilepath(filepath: string, save = true): void {
+    if (this.filepath === filepath) return
+    this.filepath = filepath
+    if (save) this.save()
+  }
+
+  /**
+   * Sets a value in the JSON database.
+   * @param prefix - Object path prefix as dot-separated keys.
+   * @param value - The value to set.
+   * @param save - Whether to save the data to the JSON file.
+   */
+  set(prefix?: string, value: JsonValue = {}, save = true): void {
+    if (!prefix) {
+      this.data = ensureThat(value, isObject) as JsonObject
+    } else {
+      const keys = prefix.split('.')
+      const lastKey = keys.pop() as string
+      let node: JsonObject = this.data
+      for (const key of keys) {
+        if (!Object.hasOwn(node, key)) {
+          node[key] = {}
+        }
+        node = node[key] as JsonObject
+      }
+      node[lastKey] = this.cloneDeep(value)
+    }
+    if (save) this.save()
+  }
+
+  /**
+   * Gets a value from the JSON database.
+   * @param prefix - Object path prefix as dot-separated keys.
+   * @returns The value associated with the key.
+   * @throws An error if no entry is found at the specified key.
+   */
+  get<T = JsonValue>(prefix?: string): T {
+    const value = this.getSafe(prefix)
+    if (value === undefined) throw new Error(`No entry at '${prefix}'`)
+    return this.cloneDeep(value) as T
+  }
+
+  /**
+   * Gets a value from the JSON database safely.
+   * @param prefix - Object path prefix as dot-separated keys.
+   * @returns The value associated with the key, or undefined if no entry is found.
+   */
+  getSafe<T = JsonValue>(prefix?: string): T | undefined {
+    if (!prefix) return this.cloneDeep(this.data) as T
+    const keys = prefix.split('.')
+    let node: JsonObject = this.data
+    for (const key of keys) {
+      if (!Object.hasOwn(node, key)) {
+        return undefined
+      }
+      node = node[key] as JsonObject
+    }
+    return this.cloneDeep(node) as T
+  }
+
+  /**
+   * Checks if a key exists in the JSON database.
+   * @param prefix - Object path prefix as dot-separated keys.
+   * @returns True if the key exists, false otherwise.
+   */
+  has(prefix?: string): boolean {
+    if (!prefix) return true
+    return this.getSafe(prefix) !== undefined
+  }
+
+  /**
+   * Deletes a value from the JSON database.
+   * @param prefix - Object path prefix as dot-separated keys.
+   * @param save - Whether to save the data to the JSON file.
+   */
+  delete(prefix?: string, save = true): void {
+    if (!prefix) {
+      this.data = {}
+    } else {
+      const keys = prefix.split('.')
+      const lastKey = keys.pop() as string
+      let node: JsonObject = this.data
+      for (const key of keys) {
+        if (!Object.hasOwn(node, key)) {
+          return
+        }
+        node = node[key] as JsonObject
+      }
+      delete node[lastKey]
+    }
+    if (save) this.save()
+  }
+
+  /**
+   * Creates a deep clone of an object.
+   * @param obj - The object to clone.
+   * @returns The cloned object.
+   */
+  protected cloneDeep<T extends JsonValue>(obj: T): T {
+    if (typeof obj !== 'object') return obj
+    return JSON.parse(JSON.stringify(obj)) as T
+  }
+}