50+ endpoints and typescript composite yields to TS7056 error.

[PeterMK85]

Versions

   "@zodios/core": "10.9.4",
   "zod": "3.22.1"

Number of Endpoints: 73
Number of Schemas: 403

I tried the 11.0.0-beta.19 version, failed with the same.

Context

We are trying to switch from an open api -> axios setup (used swagger-typescript-api) into a open api -> zodios setup (used openapi-zod-client).

We also using the composite flag from typescript in the monorepo, to improve typescript performance.

Issue

I use the example as a base, to illustrate the possible rootcause, the actual contract file I can provide on request but it seems not related to the actual setup, it's more about the complexity / amount of the endpoints.

Actual TS error:

The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed.

The issue reported from the following approaches
new Zodios(baseUrl, endpoints, options)
and the
makeApi(endpoints)

If I start to reduce the number of endpoint and shared schemas it will start to pass.

Simple example:

Schemas + client

import { Zodios, type ZodiosOptions } from '@zodios/core'
import { z } from 'zod'

export const Category = z.object({ id: z.number().int(), name: z.string() }).partial()
export type Category = z.infer<typeof Category>
export const Tag = z.object({ id: z.number().int(), name: z.string() }).partial()
export type Tag = z.infer<typeof Tag>
export const Pet = z.object({
    id: z.number().int().optional(),
    name: z.string(),
    category: Category.optional(),
    photoUrls: z.array(z.string()),
    tags: z.array(Tag).optional(),
    status: z.enum(['available', 'pending', 'sold']).optional(),
})
export type Pet = z.infer<typeof Pet>
export const createApiClient = (baseUrl: string, options?: ZodiosOptions) =>
    new Zodios(
        baseUrl,
        [
            {
                method: 'put',
                path: '/pet',
                alias: 'updatepet',
                description: `Update an existing pet by Id`,
                requestFormat: 'json',
                parameters: [
                    {
                        name: 'body',
                        description: `Update an existent pet in the store`,
                        type: 'Body',
                        schema: Pet,
                    },
                ],
                response: Pet,
                errors: [
                    {
                        status: 400,
                        description: `Invalid ID supplied`,
                        schema: z.void(),
                    },
                    {
                        status: 404,
                        description: `Pet not found`,
                        schema: z.void(),
                    },
                    {
                        status: 405,
                        description: `Validation exception`,
                        schema: z.void(),
                    },
                ],
            },
        ],
        options,
    )

Typescript d.ts file output

import { type ZodiosOptions } from '@zodios/core';
import { z } from 'zod';
export declare const Category: z.ZodObject<{
    id: z.ZodOptional<z.ZodNumber>;
    name: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    id?: number | undefined;
    name?: string | undefined;
}, {
    id?: number | undefined;
    name?: string | undefined;
}>;
export type Category = z.infer<typeof Category>;
export declare const Tag: z.ZodObject<{
    id: z.ZodOptional<z.ZodNumber>;
    name: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    id?: number | undefined;
    name?: string | undefined;
}, {
    id?: number | undefined;
    name?: string | undefined;
}>;
export type Tag = z.infer<typeof Tag>;
export declare const Pet: z.ZodObject<{
    id: z.ZodOptional<z.ZodNumber>;
    name: z.ZodString;
    category: z.ZodOptional<z.ZodObject<{
        id: z.ZodOptional<z.ZodNumber>;
        name: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        id?: number | undefined;
        name?: string | undefined;
    }, {
        id?: number | undefined;
        name?: string | undefined;
    }>>;
    photoUrls: z.ZodArray<z.ZodString, "many">;
    tags: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodOptional<z.ZodNumber>;
        name: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        id?: number | undefined;
        name?: string | undefined;
    }, {
        id?: number | undefined;
        name?: string | undefined;
    }>, "many">>;
    status: z.ZodOptional<z.ZodEnum<["available", "pending", "sold"]>>;
}, "strip", z.ZodTypeAny, {
    name: string;
    photoUrls: string[];
    id?: number | undefined;
    category?: {
        id?: number | undefined;
        name?: string | undefined;
    } | undefined;
    tags?: {
        id?: number | undefined;
        name?: string | undefined;
    }[] | undefined;
    status?: "available" | "pending" | "sold" | undefined;
}, {
    name: string;
    photoUrls: string[];
    id?: number | undefined;
    category?: {
        id?: number | undefined;
        name?: string | undefined;
    } | undefined;
    tags?: {
        id?: number | undefined;
        name?: string | undefined;
    }[] | undefined;
    status?: "available" | "pending" | "sold" | undefined;
}>;
export type Pet = z.infer<typeof Pet>;
export declare const createApiClient: (baseUrl: string, options?: ZodiosOptions) => import("@zodios/core").ZodiosInstance<[{
    method: "put";
    path: "/pet";
    alias: "updatepet";
    description: "Update an existing pet by Id";
    requestFormat: "json";
    parameters: [{
        name: "body";
        description: string;
        type: "Body";
        schema: z.ZodObject<{
            id: z.ZodOptional<z.ZodNumber>;
            name: z.ZodString;
            category: z.ZodOptional<z.ZodObject<{
                id: z.ZodOptional<z.ZodNumber>;
                name: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                id?: number | undefined;
                name?: string | undefined;
            }, {
                id?: number | undefined;
                name?: string | undefined;
            }>>;
            photoUrls: z.ZodArray<z.ZodString, "many">;
            tags: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodOptional<z.ZodNumber>;
                name: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                id?: number | undefined;
                name?: string | undefined;
            }, {
                id?: number | undefined;
                name?: string | undefined;
            }>, "many">>;
            status: z.ZodOptional<z.ZodEnum<["available", "pending", "sold"]>>;
        }, "strip", z.ZodTypeAny, {
            name: string;
            photoUrls: string[];
            id?: number | undefined;
            category?: {
                id?: number | undefined;
                name?: string | undefined;
            } | undefined;
            tags?: {
                id?: number | undefined;
                name?: string | undefined;
            }[] | undefined;
            status?: "available" | "pending" | "sold" | undefined;
        }, {
            name: string;
            photoUrls: string[];
            id?: number | undefined;
            category?: {
                id?: number | undefined;
                name?: string | undefined;
            } | undefined;
            tags?: {
                id?: number | undefined;
                name?: string | undefined;
            }[] | undefined;
            status?: "available" | "pending" | "sold" | undefined;
        }>;
    }];
    response: z.ZodObject<{
        id: z.ZodOptional<z.ZodNumber>;
        name: z.ZodString;
        category: z.ZodOptional<z.ZodObject<{
            id: z.ZodOptional<z.ZodNumber>;
            name: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            id?: number | undefined;
            name?: string | undefined;
        }, {
            id?: number | undefined;
            name?: string | undefined;
        }>>;
        photoUrls: z.ZodArray<z.ZodString, "many">;
        tags: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodOptional<z.ZodNumber>;
            name: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            id?: number | undefined;
            name?: string | undefined;
        }, {
            id?: number | undefined;
            name?: string | undefined;
        }>, "many">>;
        status: z.ZodOptional<z.ZodEnum<["available", "pending", "sold"]>>;
    }, "strip", z.ZodTypeAny, {
        name: string;
        photoUrls: string[];
        id?: number | undefined;
        category?: {
            id?: number | undefined;
            name?: string | undefined;
        } | undefined;
        tags?: {
            id?: number | undefined;
            name?: string | undefined;
        }[] | undefined;
        status?: "available" | "pending" | "sold" | undefined;
    }, {
        name: string;
        photoUrls: string[];
        id?: number | undefined;
        category?: {
            id?: number | undefined;
            name?: string | undefined;
        } | undefined;
        tags?: {
            id?: number | undefined;
            name?: string | undefined;
        }[] | undefined;
        status?: "available" | "pending" | "sold" | undefined;
    }>;
    errors: [{
        status: 400;
        description: string;
        schema: z.ZodVoid;
    }, {
        status: 404;
        description: string;
        schema: z.ZodVoid;
    }, {
        status: 405;
        description: string;
        schema: z.ZodVoid;
    }];
}]>;

What I tried to illustrate above, that with a single endpoint and with very 3 simple schemas, typescript compilation produced 260% larger file, and it seems it tries to calculate the type of every schema at least twice. (schema declaration and the API response/body declaration. In comprehension the exported type, where I just rely on z.infer it preserves as a reference.

Actual fails stats:

With the very same structure as above:
Client + Schemas LOC: 5048
When I store every endpoint as a const and remove the makeApi/newZodios and TS success on compile, LOC: 432500

Do you have any suggestion? Do I missed something?

[ecyrbe]

Are you exporting your types in a separate library ? if everything is on your app, you don't need to emit .d.ts and you can just revert to :

  declaration: false,
  composition: false

in your tsconfig file.

this is the easiest way to work around the issue.

Another way, would be to explicitely name the exported client and only have this one typed :

const createApiClientInternal = (baseUrl: string, options?: ZodiosOptions) =>
    new Zodios( baseUrl, ...);
type ApiClientInternal = ReturnType<typeof createApiClientInternal>;
export interface ApiClient extends ApiClientInternal {};
export createApiClient: (baseUrl: string, options?: ZodiosOptions) => ApiClient = createApiClientInternal;

not sure this last one would work. just an idea to try.

[PeterMK85]

Are you exporting your types in a separate library ? if everything is on your app, you don't need to emit .d.ts and you can just revert to

This is our main initative, to switch to composite TS setup, to gain speed improvement, at the moment both TS/eslint painfully slow since we partially migrated to Zodios.

I phrased in the original:

We also using the composite flag from typescript in the monorepo, to improve typescript performance.

For composite you need to emit and build declaration at the end of day.

Another way, would be to explicitely name the exported client and only have this one typed :

I tried something similar, but it does not work, I ended up with the following approach:

type example = {
    label: string
}

const exampleSchema: z.ZodType<example> = z.object({ 
   label: z.string()
})

const endpoints = makeApi([    {
        method: 'post',
        path: '/api/ui/v1/example',
        alias: 'example',
        description: `Example`,
        requestFormat: 'json',
        parameters: [
            {
                name: 'body',
                type: 'Body',
                schema: exampleSchema,
            },
        ],
        }])

Pros:

• Reduced the LOC from the ~500 000 range -> 12000 and so far no TS7056

Cons:

• I need to create another schema definition which is not using the type from ZodType to be able to work with it

[Dimava]

@PeterMK85
You may use

export interface zSimple<T> extends z.Schema<T> {}
function zSimple<T extends z.Schema>(schema: T): zSimple<z.infer<T>> {
    return schema
}
export const Pet = zSimple(z.object({
    id: z.number().int().optional(),
    name: z.string(),
    category: Category.optional(),
    photoUrls: z.array(z.string()),
    tags: z.array(Tag).optional(),
    status: z.enum(['available', 'pending', 'sold']).optional(),
}))

to decrease the code generated by Zod itself:

// no `z.Thing`s everywhere
export declare const Pet: zSimple<{
    name: string;
    photoUrls: string[];
    id?: number | undefined;
    category?: {
        id?: number | undefined;
        name?: string | undefined;
    } | undefined;
    tags?: {
        id?: number | undefined;
        name?: string | undefined;
    }[] | undefined;
    status?: "available" | "pending" | "sold" | undefined;
}>;
export type Pet = z.infer<typeof Pet>;

(this may have some (type, not runtime) consequences, but if the types are not morphing and not modified elswhere this works.)

If you want to reduce code duplication, you may use interfaces:

export interface zSimple<T> extends z.Schema<T> {}
function zSimple<T extends z.Schema>(schema: T): zSimple<z.infer<T>> {
    return schema
}
export type Id<T> = T
const _Pet = zSimple(z.object({
    id: z.number().int().optional(),
    name: z.string(),
    category: Category.optional(),
    photoUrls: z.array(z.string()),
    tags: z.array(Tag).optional(),
    status: z.enum(['available', 'pending', 'sold']).optional(),
}))
export interface Pet extends Id<z.infer<typeof _Pet>> {}
export const Pet = _Pet as zSimple<Pet> 

// d.ts
    parameters: [{
        name: "body";
        description: string;
        type: "Body";
        schema: zSimple<Pet>;
    }];

[stale]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[Dimava]

@ecyrbe can you please configure stalebot to ONLY add "stale" tag and do that after at least half a year?
I don't see the point in many issues getting closed for no reason

[antonio-ivanovski]

Should be re-opened until maybe fixed with #237