Custom Result Handler Response Structures

[marcelmatko]

How can I customize the result handler so I enforce a certain structure for positive responses, basically I want to have message field on root level the same as success and data fields and then in data field we can append any fields that are provided within data object?

Wanted output:

{
    "success": true,
    "message": string, // a default fallback message if not provided
    "data": {...} // any fields we return within data object or simply null if none
}

Current output by the provided code:

{
    "success": true,
    "data": {
        "message": "No rate limit exceeded."
    }
}

export const customResultHandler = new ResultHandler({
  positive: (data) => ({
    schema: z.object({ data }),
    mimeType: "application/json",
  }),
  negative: z.object({
    success: z.boolean(),
    error: z.object({
      message: z.string(),
    }),
  }),
  handler: ({ error, input, output, request, response, logger }) => {
    if (error) {
      const { statusCode } = ensureHttpError(error);
      const message = getMessageFromError(error);

      if (error instanceof InputValidationError) {
        return void response.status(400).json({
          success: false,
          error: {
            message: message,
          },
        });
      }

      return void response.status(statusCode).json({
        success: false,
        error: {
          message: message,
        },
      });
    }
    response.status(200).json({ success: true, data: output });
  },
});

[RobinTail]

You should add that message property both into positive schema and handler implementation (where you do .json()), @marcelmatko

Since data technically can be anything object-based, your implementation would need to ensure the presence of the message prop within data in order to pull it on top.

if (data && "message" in data && typeof data.message === "string") {
  // ...
}

Schemas are used by Documentation and Integration generators, and they also enforce the constraints on .json() within handler.

[marcelmatko]

Is this the correct way of doing it?

Route handler:

return {
  message: result.message,
  data: {
    testField: "test",
  },
};

ResultHandler:

export const customResultHandler = new ResultHandler({
  positive: (data) => ({
    schema: z.object({
      success: z.literal(true),
      message: z.string(),
      data: z.any(),
    }),
    mimeType: "application/json",
  }),
  negative: z.object({
    success: z.literal(false),
    error: z.object({
      message: z.string(),
    }),
  }),
  handler: ({ error, input, output, request, response, logger }) => {
    if (error) {
      const { statusCode } = ensureHttpError(error);
      const message = getMessageFromError(error);

      if (error instanceof InputValidationError) {
        return void response.status(400).json({
          success: false,
          error: {
            message: message,
          },
        });
      }

      return void response.status(statusCode).json({
        success: false,
        error: {
          message: message,
        },
      });
    }

    const outputObj = output && typeof output === "object" ? output : {};
    const message =
      typeof outputObj.message === "string"
        ? outputObj.message
        : "Operation completed successfully";

    const data = outputObj.data !== undefined ? outputObj.data : null;

    response.status(200).json({
      success: true,
      message,
      data,
    });
  },
});

[RobinTail]

looks like the real thing, @marcelmatko 👍🏽

I'd also try to avoid z.any in positive schema

Maybe this (I tried to describe your implementation in the schema):

  // the fn argument is the output schema of an Endpoint
  positive: (output) => z.object({
      success: z.literal(true),
      message: z.string(),
      data: output instanceof z.ZodObject && "data" in output.shape ? output.shape.data : z.null()
  }),
  // json mime type is default, so that line could be safely removed

[RobinTail]

Also, you may not wrap the actual data into data in your endpoint output.

return {
  message: result.message,
  testField: "test",
};

Then the implementation of result handler could do:

const {message, ...data} = output;

And the schema would be

{
  positive: z.object({
    success: z.literal(true),
    message: z.string(),
    data: output instanceof z.ZodObject ? output.omit({ message: true }) : z.null()
  })
}

.omit() makes a schema without certain props, @marcelmatko

[marcelmatko]

Exactly what I was looking for, thank you very much for taking your time and helping me out :)