index.ts

/* eslint-disable @typescript-eslint/no-unsafe-type-assertion */

type PropertyValue<V> =
  | {
      propertyFound: false
    }
  | {
      propertyFound: true
      propertyValue: V
    }

export class Configurator<D extends Record<string, unknown>> {
  readonly #defaultValues: D
  #userConfiguration: Record<string, unknown>

  /**
   * Initializes the Configurator.
   * @param defaultValues - An object with the property values to use when not set in the userConfig.
   *  All keys should correspond to the value being returned.
   *  ex. { propertyOne: 5, 'propertyTwo.inner': 'value' }
   * @param userConfiguration - The values that should be used when available.
   *  ex. { propertyOne: 7, propertyTwo: { inner: 'userValue' } }
   */
  constructor(
    defaultValues: D,
    userConfiguration: Record<string, unknown> = {}
  ) {
    this.#defaultValues = defaultValues
    this.#userConfiguration = userConfiguration
  }

  /**
   * Retrieves a property value, checking in the following order.
   * - User configuration
   * - Default values
   * - Fallback value
   * @param propertyName - The property key.
   * @param fallbackValue - An optional value if the property is not found in the user configuration or the default values.
   * @returns A property value.
   */
  getConfigProperty<K extends keyof D>(
    propertyName: K | string,
    fallbackValue?: D[K]
  ): D[K] | undefined {
    const userPropertyValue =
      this.#getPropertyFromUserConfiguration(propertyName)

    if (userPropertyValue.propertyFound) {
      return userPropertyValue.propertyValue as D[K] | undefined
    }

    const defaultPropertyValue =
      this.#getPropertyFromDefaultValues(propertyName)

    if (defaultPropertyValue.propertyFound) {
      return defaultPropertyValue.propertyValue as D[K] | undefined
    }

    return fallbackValue
  }

  /**
   * Checks if the default value for the property has been overwritten with a different value in the user configuration.
   * @param propertyName - The property key.
   * @returns `true` if the user configuration has a different value compared to the default.
   */
  isDefaultValueOverwritten(propertyName: keyof D): boolean {
    const userPropertyValue =
      this.#getPropertyFromUserConfiguration(propertyName)

    if (!userPropertyValue.propertyFound) {
      return false
    }

    const defaultPropertyValue =
      this.#getPropertyFromDefaultValues(propertyName)

    return (
      !defaultPropertyValue.propertyFound ||
      userPropertyValue.propertyValue !== defaultPropertyValue.propertyValue
    )
  }

  /**
   * Checks if the property has been set in the default values object.
   * @param propertyName - The property key.
   * @returns `true` if the property key is found in the default values object.
   */
  isPropertyInDefaultValues(propertyName: string): boolean {
    return this.#getPropertyFromDefaultValues(propertyName).propertyFound
  }

  /**
   * Checks if the property has been set in the user configuration.
   * @param propertyName - The property key.
   * @returns `true` if the property key is found in the user configuration.
   */
  isPropertyInUserConfig(propertyName: string): boolean {
    return this.#getPropertyFromUserConfiguration(propertyName).propertyFound
  }

  /**
   * Updates the user configuration.
   * @param userConfiguration - The values that should be used when available.
   *  ex. { propertyOne: 7, propertyTwo: { inner: 'userValue' } }
   */
  setUserConfig(userConfiguration: Record<string, unknown>): void {
    this.#userConfiguration = userConfiguration
  }

  #getPropertyFromDefaultValues<K extends keyof D>(
    propertyName: K
  ): PropertyValue<D[K]> {
    if (Object.hasOwn(this.#defaultValues, propertyName)) {
      return {
        propertyFound: true,
        propertyValue: this.#defaultValues[propertyName]
      }
    }

    return {
      propertyFound: false
    }
  }

  #getPropertyFromUserConfiguration<K extends keyof D>(
    propertyName: K
  ): PropertyValue<D[K]> {
    /*
     * If the propertyName is in the userConfig as is
     * Return the value from the userConfig
     */

    if (Object.hasOwn(this.#userConfiguration, propertyName)) {
      return {
        propertyFound: true,
        propertyValue: (this.#userConfiguration as Record<K, unknown>)[
          propertyName
        ] as D[K]
      }
    }

    let currentObject: unknown = this.#userConfiguration

    /*
     * Split the propertyName and search the userConfig
     */

    const propertyNameSplit = (propertyName as string).split('.')

    for (const propertyNamePiece of propertyNameSplit) {
      if (
        typeof currentObject === 'object' &&
        currentObject !== null &&
        Object.hasOwn(currentObject, propertyNamePiece)
      ) {
        currentObject = currentObject[propertyNamePiece]
        continue
      }

      return {
        propertyFound: false
      }
    }

    return {
      propertyFound: true,
      propertyValue: currentObject as D[K]
    }
  }
}