Class CamelCasePlugin

src/plugin/camel-case/camel-case-plugin.ts:121–174

 * ```
 */
export class CamelCasePlugin implements KyselyPlugin {
  readonly #camelCase: StringMapper
  readonly #snakeCase: StringMapper
  readonly #snakeCaseTransformer: SnakeCaseTransformer

  constructor(readonly opt: CamelCasePluginOptions = {}) {
    this.#camelCase = createCamelCaseMapper(opt)
    this.#snakeCase = createSnakeCaseMapper(opt)

    this.#snakeCaseTransformer = new SnakeCaseTransformer(
      this.snakeCase.bind(this),
    )
  }

  transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
    return this.#snakeCaseTransformer.transformNode(args.node, args.queryId)
  }

  async transformResult(
    args: PluginTransformResultArgs,
  ): Promise<QueryResult<UnknownRow>> {
    if (args.result.rows && Array.isArray(args.result.rows)) {
      return {
        ...args.result,
        rows: args.result.rows.map((row) => this.mapRow(row)),
      }
    }

    return args.result
  }

  protected mapRow(row: UnknownRow): UnknownRow {
    return Object.keys(row).reduce<UnknownRow>((obj, key) => {
      let value = row[key]

      if (Array.isArray(value)) {
        value = value.map((it) => (canMap(it, this.opt) ? this.mapRow(it) : it))
      } else if (canMap(value, this.opt)) {
        value = this.mapRow(value)
      }

      obj[this.camelCase(key)] = value
      return obj
    }, {})
  }

  protected snakeCase(str: string): string {
    return this.#snakeCase(str)
  }

  protected camelCase(str: string): string {
    return this.#camelCase(str)
  }
}

function canMap(
  obj: unknown,