How return array of objects in response?

[HardCoreQual]

I don't want structure { data: [{}, {}] } because it's not compatible with already exist REST Api and blocked migration

need return simple [{}, {}]

express-zod-api source code

express-zod-api/src/common-helpers.ts

export type IOSchema =
| z.ZodObject<any, U>
| z.ZodUnion<[IOSchema, ...IOSchema[]]>
| z.ZodIntersection<IOSchema, IOSchema>
| z.ZodDiscriminatedUnion<string, z.Primitive, z.ZodObject<any, U>>
| z.ZodArray<z.ZodObject>

[RobinTail]

Hello @HardCoreQual .

Thank you for the question.
In your case you gonna need a custom ResultHandler instead of the default one.
Here are the parts of the documentation on that:
https://github.com/RobinTail/express-zod-api#response-customization
https://github.com/RobinTail/express-zod-api#non-object-response

IOSchema is object based entity that middlewares and endpoints operate.
ResultHandler is the entity that is responsible for the final and consistent responses that can be anything.
You can also find examples of custom ResultHandlers here:
https://github.com/RobinTail/express-zod-api/blob/master/example/factories.ts

Please let me know if you need more information on the topic.

[RobinTail]

Here is an example implementation, @HardCoreQual .
I did not test it yet, but it might be something similar.
This ResultHandler transmits the value of the array field of your endpoint output.

export const arrayResultHandler = createResultHandler({
  getPositiveResponse: <OUT extends IOSchema>(output: OUT) =>
    createApiResponse(
      z.array(z.any()),
    ),
  getNegativeResponse: () => createApiResponse(z.string()),
  handler: ({ error, input, output, request, response, logger }) => {
    if (error) {
      response.status(getStatusCodeFromError(error)).send(error.message);
      return;
    }
    if ("array" in output && Array.isArray(output.array)) {
      response.status(200).json(output.array);
    } else {
      response.status(400).send("Array is missing");
    }
  },
});

[RobinTail]

Regarding your suggestion on including ZodArray to IOSchema,

@HardCoreQual

export type IOSchema = 
...
| z.ZodArray<z.ZodObject>

I initially did not plan to do this in principle and do not want to, because I consider it contrary to best practices and hindering the development of the endpoint preserving its backwards compatibility.

The temptation to return just an array of objects is very strong, however, returning arrays once raises a question of limitations, the answer to which is pagination. Therefore, as your product evolves, you will soon realize that you would also like to return additional data or metadata, such as hasMoreObjects: boolean. In this case, if your endpoint returns an array, you can't just add that field without breaking backwards compatibility. So you gonna need a new major version of the endpoint and changes on the frontend.

Therefore, I would like this library to encourage more provident architectural decisions.
However, as I wrote above, you still have the opportunity to achieve what you want with the help of a custom ResultHandler.

[McMerph]

@RobinTail

However, as I wrote above, you still have the opportunity to achieve what you want with the help of a custom ResultHandler.

I have implemented custom ResultHandler with support for returning an array as a response.
But there is a problem with generating OpenAPI spec if I add an example.
Specifically, I'm adding 1 example (an array with 2 elements), but there are 2 examples (2 elements of array) in the generated OpenAPI spec.
And if I add test:

test("should return array of arrays", () => {
  expect(
    getExamples(
      withMeta(z.array(z.number().int())).example([1, 2]).example([3, 4]),
      false
    )
  ).toEqual([
    [1, 2],
    [3, 4],
  ]);
});

then it fails with:

 FAIL  tests/unit/common-helpers.spec.ts
  ● Common Helpers › getExamples() › should return array of arrays

    expect(received).toEqual(expected) // deep equality

    - Expected  - 4
    + Received  + 0

      Array [
    -   Array [
        1,
        2,
    -   ],
    -   Array [
        3,
        4,
    -   ],
      ]

So, getExamples merges the arrays into one.
I believe it is because of concat at

express-zod-api/src/common-helpers.ts

Line 125 in 1f6a943

return carry.concat(

Is it a bug or an expected behaviour?

[RobinTail]

This is actually an issue, @McMerph .
There should be a special handling for examples of arrays.
Good finding.

[RobinTail]

Made this issue out of it:
#892

[RobinTail]

Fixed

[gmazoni]

createApiResponse is deprecated, can you help me to achieve the same effect?

I am trying:

getPositiveResponse: (output: IOSchema | z.ZodArray<z.ZodObject<any>>) =>
    z.object({
      statusCode: z.number().default(200),
      data: output,
    }),

but the build of the factory complains about the output

[RobinTail]

Yeah, it is no longer needed and has been removed, @gmazoni
Functions assigned to getPositiveResponse and getNegativeResponse props can immediately return the schema assuming the MIME type JSON and status codes 200/400 accordingly.
If you want to customize it, the functions can return object of the following type:

https://github.com/RobinTail/express-zod-api/blob/master/src/api-response.ts

Here you can also find an example of creating a custom ResultHandler:

https://github.com/RobinTail/express-zod-api/blob/master/example/factories.ts

[RobinTail]

but the build of the factory complains about the output

try removing this: : IOSchema | z.ZodArray<z.ZodObject<any>> , @gmazoni .

[RobinTail]

Also, @gmazoni you wanted the ResultHandler to respond with array, so your schema should most likely be:

const arrayRespondingFactory = new EndpointsFactory({
  config,
  resultHandler: createResultHandler({
    getPositiveResponse: (output) =>
      "shape" in output ? output.shape.array : z.array(z.any()),
    getNegativeResponse: () => z.string(),
    handler: ({ response, output }) => {
      if ("array" in output && Array.isArray(output.array)) {
        response.status(200).json(output.array);
      } else {
        response.status(500).send("Array is missing");
      }
    },
  }),
});

meaning that the endpoints you create on this Factory should result in object having array property that will be used as the response.

[RobinTail]

🚀 Good news, array lovers and legacy API migrators:
the new feature has been just released in version 11.7.0 that should help you to achieve the desired response easier: arrayResultHandler and arrayEndpointsFactory.
The details in Readme and Changelog.