Response object keys in snake_case

[mastermunj]

Hi,

I want to be able to ensure that all the keys in json response are always in snake_case. For most of the cases where the returned values are model(s), it gets serialized and the output is as expected.

In cases where a custom object is created based on certain logic, the returned output does not get serialize, making camelCase keys go in the output.

Possible solutions that come in my mind:

• Use snake_case in code. <= This doesn't seem right.
• Intercept response just before its sent to client and change keys of the output object. <= How to achieve this?

Please guide on another better approach if any.

[popovicieduard]

You can make use of transformers, here is a package: https://github.com/kmorpex/adonis-bublebee-ts#readme

[mastermunj]

Transformers require specific programming for each returned object, which I believe will be too much of work. I am thinking more of a magic method, which will process the json data, just before its being sent to client, for converting keys into snake_case.

[thetutlage]

There can't be any magic unless you are ready to write your own code, since traversing over the complete response to re-create is a wild approach.

Anyways, you can create a middleware and use the downstream to update the response.

import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'

export default class Transformer {
  public async handle({ response }: HttpContextContract, next: () => Promise<void>) {
    // code for middleware goes here. ABOVE THE NEXT CALL
    await next()

    const body = response.lazyBody[0]

    const newBody = Object.keys(body).reduce((result, key) => {
      result[key.toUpperCase()] = body[key]
      return result
    }, {})

    response.send(newBody)
  }
}

You have to self manage the treatment for different data types

[mastermunj]

I tried using lazyBody, but it holds the actual value returned by controller instead the actual json being sent as response. Is there a way we could understand how Adonis processes whole lazyBody to generate final json?

[thetutlage]

You have to self read the code of the http-server repo

[mastermunj]

Hi @thetutlage,

I went through http-server repo and figured that this is where the actual response is sent.

Is there a possibility to add an event that allows an opportunity to work on data just before it's sent out on response. That way one will not have to manage the treatment of different data types.

Or if you could help with a better approach, it will be great help.

[mastermunj]

Okay, so here's something I have been able to put together that seems to work.

import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import _ from 'lodash';
import { safeParse, safeStringify } from '@poppinss/utils';

export default class ResponseResponseCaseConverter {
  public async handle({ params, request, response }: HttpContextContract, next: () => Promise<void>): Promise<void> {
    request.updateBody(this.toCamelCase(request.all()));
    request.updateQs(this.toCamelCase(params));

    await next();

    const body = response.lazyBody[0];
    try {
      if (typeof body === 'object') {
        response.send(this.toSnakeCase(safeParse(safeStringify(body))));
      }
    } catch (error) {}
  }

  private toCamelCase(object: Record<string, unknown>): Record<string, unknown> {
    const transformed = _.transform(object, (result: Record<string, unknown>, value, key: string) => {
      result[_.camelCase(key)] = _.isObject(value) ? this.toCamelCase(value as Record<string, unknown>) : value;
    });
    return _.assign(object, transformed);
  }

  private toSnakeCase(object: Record<string, unknown>): Record<string, unknown> {
    const transformed = _.transform(object, (result: Record<string, unknown>, value, key: string) => {
      result[_.snakeCase(key)] = _.isObject(value) ? this.toSnakeCase(value as Record<string, unknown>) : value;
    });
    return _.assign(object, transformed);
  }
}