custom data on schema

[leolmi]

it could be very useful to have the possibility to add customizable attributes in the definitions of a schema:

const Foo = z.object({
  myProperty: z.string({
    description: 'my property description',
    customData: {
      // my custom data
    }
  })
});

or something like

const Foo = z.object({
  myProperty: z.string().customData({
      // my custom data
  })
});

so they would be present in the schema

export interface JSONSchema7 {
  ...
  customData?: any;
  ...
}

and they would be accessible from the serialized schema:

const schema = zodToJsonSchema(Foo, {$refStrategy: 'none'});

const myProperty = (<JSONSchema7>schema).properties['myProperty'];

console.log('custom data from schema', myProperty.customData); 

[JacobWeisenburger]

Can you not just do something like this?

const Foo = {
    customData: {
        // my custom data
    },
    schema: z.object( {
        myProperty: z.string( {
            description: 'my property description',
        } )
    } )
}

[stephenh]

Oh nice! This would be great; I have a library that currently uses a non-zod/custom API that looks like:

    const a = createObjectState<AuthorInput>(
      {
        books: {
          type: "list",
          config: {
            title: { type: "value", rules: [required] },
            delete: { type: "value", isDeleteKey: true },
          },
        },
      },
      {},
    );

Which could be like { delete: z.boolean() } or what not, but I need a spot for isDeleteKey to go, b/c that's special to my application.

This API is definitely doable:

const isPii = Symbol("isPii");
const annotatedString = z
  .string()
  .annotate(isPii, true);
annotatedString.meta[isPii]; // true

But @nicknotfun FWIW if there was a way to add my own fluent methods, like:

const annotatedString = s.string().isPii();

That would be amazing.

Maybe via TypeScript's declaration merging? Like on the Tanstack router...

https://tanstack.com/router/v1/docs/guide/type-safety#exported-hooks-components-and-utilities

Like let me do some sort of:

declare module 'zod' {
  interface ... {
    isPii(): boolean
  }
}
import { registerAnnotation } from "zod";
registerAnnotation("isPii");

Dunno, something like that. Thanks!

[nicknotfun]

I do like the idea of a fluent API, but couldn't figure an easy way to do it. I'd just love something like this at-minimum [we're forking zod to use this for our own purposes]. I don't think my annotation data precludes a fluent interface

[stephenh]

Ah yep, @nicknotfun agreed that your annotation approach doesn't preclude the fluent interface, and would probably be a great place for some eventual fluent API to store it's data in...

[nicknotfun]

Btw @leolmi - the commit you refer to is my feature request - I am not a maintainer so unsure when it'd get integrated.

[leolmi]

Ok thanks @nicknotfun , I hope they consider your implementation soon