Usage with Schema validation libraries like Zod

[severi]

Does someone have experiences with using dynamodb-toolbox with another schema validation library like Zod (https://zod.dev/).

Our current implementation quite heavily relies on having our data models defined as Zod schemas that we have used for data validation. We are looking to integrate Dynamodb-Toolbox to our software, but I am bit struggling with the requirement of having to define the object schemas in dynamodb-toolbox completely. This is especially problematic for large discriminated unions, where object attributes can vary a lot depending on the type of the item being stored.

The only solution I have come up so far would be to copy-paste our schemas from Zod models to dynamodb-toolbox attributes, but especially for those discriminated unions this feels somewhat cumbersome and error prone (If I understand correctly the only way to implement discriminated unions with dynamodb-toolbox would be to have all the attributes listed and marked as optional

so a simple example for this would be something like

import { z } from 'zod';

const VehicleSchema = z.object({
  id: z.string(),
  itemType: z.literal('VEHICLE'),
  licencePlateNumber: z.string(),
});

const HouseSchema = z.object({
  id: z.string(),
  itemType: z.literal('HOUSE'),
  city: z.string(),
});


const ItemModelZod = z.discriminatedUnion('itemType', [VehicleSchema, HouseSchema]);


const itemEntity = new Entity({
  name: 'item',
  attributes: {
    itemType: {
      partitionKey: true,
    },
    sk: {
      hidden: true,
      sortKey: true,
      default: (data: { id: string; itemType: string }) => `item#${data.id}`,
    },
    id: 'string',
    licencePlateNumber: {}, // i.e just allow anything here, the actual validation / typeconversion would happen through zod before put operations / after read operations
    city: {},
  },
  table: MyTable
} as const);

But syncing more complex discriminated unions to attributes like this is not really feasible. Would there for example be some possibility to allow "any" other attrbitutes to be passed to the entity besides the ones defined in its definition? Currently this seems to throw an error likes this

"Field 'licencePlateNumber' does not have a mapping or alias" ( in case licencePlateNumber was not defined in the attributes but nevertheless passed to the put-action.

[naorpeled]

Hey @severi,
sorry for the huge delay 😢

this is not something we currently support but will definitely consider adding it to v1 🙏

[THOUSAND-SKY]

Did this get added into v1? I see that the new schema definition is zod-like, but reusing the zod definitions is what I really want.

Meanwhile I'm using this: https://gitlab.com/monster-space-network/typemon/dynamon/ , writing an Entity wrapper is quite straightforward (though I didn't go all the way) and works with zod (to a degree).

[naorpeled]

Hey @THOUSAND-SKY,
not yet, v1 is in beta atm,
will discuss this feature request with Thomas and see how we can prioritize this

(cc @ThomasAribart)

[ThomasAribart]

@THOUSAND-SKY this is definitely something we can look into for the v1 👍 DynamoDB-Toolbox schemas differ from zod schemas (key attributes, savedAs etc.) so we cannot fully rely on zod but it should possible to derive the former from the latter, both through types and at runtime (´schema: fromZodSchema(zodSchema)´)

Although we have higher priorities right now so don't expect it before the end of the year :/