v3 function schemas don't show error for missing fields on returns

[mmahalwy]

Given code:

The function returns additional fields that are not on the returns schema. The expected behavior is that TS would throw an error due to key2 being an additional field on the type. Adding strict() does not fix this either

[colinhacks]

This is unfortunately an inevitable side-effect of how implement is...implemented. It doesn't force your function to conform to the exact type signature you've defined. Instead it allows any function that extends that type signature. The distinction is subtle and requires understanding of how type inference works in TS. This is necessary to allow type inference of the function's return type if you don't provide a .returns() schema:

z.function().args(z.string()).implement(arg => arg.length);
// inferred type: (arg: string)=>number

[mmahalwy]

@colinhacks Can there be a implementWithReturns function that would match the returns?

[colinhacks]

I just played around with this ideas and I can't get it to work. Here are the implementations of implement and strictImplement (my preferred name for implementWithReturns):

  implement = <F extends InnerTypeOfFunction<Args, Returns>>(func: F): F => {
    const validatedFunc = this.parse(func);
    return validatedFunc as any;
  };

  strictImplement = (
    func: InnerTypeOfFunction<Args, Returns>
  ): InnerTypeOfFunction<Args, Returns> => {
    const validatedFunc = this.parse(func);
    return validatedFunc as any;
  };

Even using strictImplement, your issue isn't resolved:

const func = z
  .function()
  .args(z.string())
  .returns(z.object({ name: z.string() }))
  .strictImplement((val) => {
    return { name: val, asdf: 1234 };
  });

This compiles just fine:

I'm afraid you're hitting against a fundamental property of structural type systems like TypeScript. Consider this:

type MyFunc = (arg: string) => { name: string };
const myFunc: MyFunc = (arg) => {
  return { name: arg, extraKey: 1234 };
};

This also compiles without error, even with the strictest compilation settings. I don't think this is possible.

[mmahalwy]

@colinhacks oh yeah, that's strange. Your example at the bottom should error, but TS allows it :S. Let me do some digging to whether there is an issue on the TS side for this.

[mmahalwy]

This does error:

type CustomType = { name: string };

const myFunc = (arg): CustomType => {
  return { name: arg, extraKey: 1234 };
};

Tracked here: microsoft/TypeScript#43365

[mmahalwy]

@colinhacks reporting back here, this issue is getting some 👀 from the TS type: microsoft/TypeScript#43365.

TLDR; have to explicitly set the return type for this to work ATM

type CustomType = { name: string };

const myFunc = (arg): CustomType => {
  return { name: arg, extraKey: 1234 };
};

A middle ground to work for this lib is to infer and set the return type for the function inside of implement. Kinda meh about that :S

[colinhacks]

Yeah not ideal. This isn't terrible though:

const func = z
  .function()
  .args(z.string())
  .returns(z.object({ name: z.string() }));

func.implement((arg): ReturnType<z.infer<typeof func>> => {
  // stuff
});

[mmahalwy]

Ah interesting. I was thinking of this:

export const func = z
  .function()
  .args(z.string())
  .returns(TestSchema)
  .implement((arg1): z.infer<typeof TestSchema> => {
    // write code
  })

[colinhacks]

Yep either one is good.

Note that if TestSchema contains transforms you'll want to use z.input instead of z.infer.