TypeScript error when pass schema to a function

[AmirL]

I've got an amazing type of error message today.

export const timestampToDate = (data: number): Date => {
  const timestamp = new Date(data);
  if (isNaN(timestamp.getTime())) {
    throw new Error('Invalid timestamp');
  }
  return timestamp;
};

export const timestampToDateSchema = z.coerce.number().transform(timestampToDate);
  
  
export const MyUsersSchema = z.array(
  z.object({
    created: timestampToDateSchema,
  }),
);

  async do<T>(data, schema: z.ZodType<T>) {
    return schema.parse(data);
  }
  
const myUsers = MyUsersSchema.parseAsync([]);
const myUsers2 = this.do([], MyUsersSchema);

As you can see, both myUsers, and myUsers2 should be typed the same. But Typescript shows an error for myUsers2

Argument of type 'ZodArray<ZodObject<{ created: ZodEffects<ZodNumber, Date, number>; }, "strip", ZodTypeAny, { created: Date; }, { created: number; }>, "many">' is not assignable to parameter of type 'ZodType<{ created: Date; }[], ZodTypeDef, { created: Date; }[]>'.
  Types of property '_input' are incompatible.
    Type '{ created: number; }[]' is not assignable to type '{ created: Date; }[]'.
      Type '{ created: number; }' is not assignable to type '{ created: Date; }'.
        Types of property 'created' are incompatible.
          Type 'number' is not assignable to type 'Date'.

So it creates a type, which conflicts with the type itself.

created has a Date type for ZodType Input, but also it has a number type for Output

[AmirL]

Simple fix to avoid type error:

  async do<T>(data, schema: z.ZodType<T, any, any>): Promise<T> {
    return schema.parse(data);
  }

[JacobWeisenburger]

The code example you gave is not valid JavaScript. Please send a full reproducible code example that is valid JavaScript.

[AmirL]

@JacobWeisenburger sure, I've created example in StackBlitz:
https://stackblitz.com/edit/typescript-xpn5el?file=index.ts

import { z } from 'zod';

export const timestampToDate = (data: number): Date => {
  const timestamp = new Date(data);
  if (isNaN(timestamp.getTime())) {
    throw new Error('Invalid timestamp');
  }
  return timestamp;
};

export const timestampToDateSchema = z.coerce
  .number()
  .transform(timestampToDate);

export const MyUsersSchema = z.array(
  z.object({
    created: timestampToDateSchema,
  })
);

function bugExample<T>(data, schema: z.ZodType<T>) {
  return schema.parse(data);
}

// It's ok here
const myUsers = MyUsersSchema.parseAsync([]);
// But got TS error here.
const myUsers2 = bugExample([], MyUsersSchema);

[JacobWeisenburger]

Is this what you are looking for?

export const timestampToDate = ( data: number ): Date => {
    const timestamp = new Date( data )
    if ( isNaN( timestamp.getTime() ) ) {
        throw new Error( 'Invalid timestamp' )
    }
    return timestamp
}

export const timestampToDateSchema = z.coerce
    .number()
    .transform( timestampToDate )

export const MyUsersSchema = z.array(
    z.object( {
        created: timestampToDateSchema,
    } )
)

function bugExample<Output, Input> ( data: unknown, schema: z.ZodType<Output, z.ZodTypeDef, Input> ) {
    return schema.parse( data )
}

const myUsers = MyUsersSchema.parseAsync( [] ) // It's ok here
const myUsers2 = bugExample( [], MyUsersSchema ) // fixed

If you found my answer satisfactory, please consider supporting me. Even a small amount is greatly appreciated. Thanks friend! 🙏
https://github.com/sponsors/JacobWeisenburger

[Panth977]

@AmirL if you want to accept only one Type arg... you can do

import { z } from 'zod';

export const timestampToDate = (data: number): Date => {
    const timestamp = new Date(data);
    if (isNaN(timestamp.getTime())) {
        throw new Error('Invalid timestamp');
    }
    return timestamp;
};

export const timestampToDateSchema = z.coerce.number().transform(timestampToDate);

export const MyUsersSchema = z.array(
    z.object({
        created: timestampToDateSchema,
    })
);

// function bugExample<T>(data: unknown, schema: z.ZodType<T>) {
//     return schema.parse(data);
// }
function bugExample<ZT extends z.ZodType>(data: unknown, schema: ZT): Promise<ZT['_output']> {
    return schema.parseAsync(data);
}

const myUsers = MyUsersSchema.parseAsync([]);
const myUsers2 = bugExample([], MyUsersSchema);