If you need to reuse it across various fields, use this wrapping function:

function uniqueArray(schema: ZodType) {
  return z
    .array(schema)
    .refine((items) => new Set(items).size === items.length, {
      message: 'All items must be unique, no duplicate values allowed',
    });
}
  

const schema = {
  setString: uniqueArray(z.string().minLength(87)),
  setNumber: uniqueArray(z.number()),
  setBoolean: uniqueArray(z.boolean()),
 }

Hello @joaoGabriel55

The method looks dope but I don't see how one can get info about which specific elements are duplicated. I think that would be a great addition. Let me give an example:

// We have the following schema
const fruitsEnum = zod.enum([ 'apple', 'banana', 'grapes' ])

// ...and let's say a DTO (for example for an endpoint that will receive fruits idk)
const fruitDto = z.object({
    fruits: z.array(fruitsEnum).uniqueness()
})
 
// ...and we want to send this array to our endpoint
const fruitsArrayWithDuplicates = [ 'apple', 'banana', 'grapes', 'apple' ]

const fruitsRequestObject = {
    fruits: fruitsArrayWithDuplicates
}

// when we send the array with duplicates
postFruits('/fruits', fruitsRequestObject)

// We should throw an error, because we have the fruit 'apple' twice

Following the example. What I am interested in is to have a way of informing the user Hey, you have sent the fruit 'apple' twice, AKA know exactly which element(s) have been duplicated so we can inform the user.

Currently I don't see that implemented as you are just converting the array to a Set and checking the size against the original array (correct me if I am wrong)

It would be a great addition to the method (or maybe another method specifically checking which elements get duplicated).

I would love to hear your feedback on this proposal. I can't think rn how an API for that would look like exactly, and I am not interested in the concrete implementation, but rather if you think it would make sense to have it implemented

Cheers,
Valentin

@ValTashkov this sounds great! One nitpick tho. uniqueness should take a configuration which asks the user whether he would like to view duplicate objects since I believe displaying it by default is computationally more expensive than just saying duplicate items were found. What do you reckon?

Yes, an option that accepts a callback that has an array of the duplicated elements as first argument and returns a custom message with the duplicates should do the trick. I imagine something like this:

const users =[
   {
      id: 1,
      name: "Pesho"
    },
 {
      id: 2,
      name: "Gosho"
    }
{
      id: 1,
      name: "Pesho"
    }
]
z.array(users).uniquness(
      (user) => user.name,

     // duplicatedUsersArray = [ { id: 1, name: 'Pesho' } ]
     (duplicatedUsersArray) => `Duplicated users found: ${duplicatedUsersArray.map(user=>user.name).join(', ')}` 
)

  // And the error would look like this:
  // Duplicated users found: Pesho

I know the example is a bit complex, but wanted to show that this solution can also work with objects as well

I see one issue with this. If the array consisted of large and deep objects, JSON.stringify would be slow and subsequently, logging the entire object wouldn't be performant. Maybe instead of printing the object itself, the object's index in the array can be printed.

I don't see where we would need JSON.stringify in this example, even with nested objects

We add second argument to the method, that is a callback that takes as first argument an array of the duplicated items. After that you can do whatever you like. In my case I am mapping the array of user to just the names

I believe this is customer's concern, not zod's

It seems to work, but its a transformation stage, not a validation. Right now thanks to your suggestion I'm using uniqueBy instead to check only a specified attribute in the object:

import {uniqBy} from 'lodash';

z.array(
  z.object({
    name: z.string(),
    locale: z.string(),
  })
).transform((value) => uniqBy(value, 'locale'));

@Manuel-Bauer here is my solution with errors assigned to fields

z.array({
      value: z.string()
}).superRefine((items, ctx) => {
      const uniqueValues = new Map<string, number>()
      items.forEach((item, idx) => {
        const firstAppearanceIndex = uniqueValues.get(item.value)
        if (firstAppearanceIndex !== undefined) {
          ctx.addIssue({
            code: z.ZodIssueCode.custom,
            message: `Value must be unique`,
            path: [...ctx.path, idx, 'value'],
          })
          ctx.addIssue({
            code: z.ZodIssueCode.custom,
            message: `Value must be unique`,
            path: [...ctx.path, firstAppearanceIndex, 'value'],
          })
          return
        }
        uniqueValues.set(item.value., idx)
      })
    })

@Manuel-Bauer here is my solution with errors assigned to fields

z.array({
      value: z.string()
}).superRefine((items, ctx) => {
      const uniqueValues = new Map<string, number>()
      items.forEach((item, idx) => {
        const firstAppearanceIndex = uniqueValues.get(item.value)
        if (firstAppearanceIndex !== undefined) {
          ctx.addIssue({
            code: z.ZodIssueCode.custom,
            message: `Value must be unique`,
            path: [...ctx.path, idx, 'value'],
          })
          ctx.addIssue({
            code: z.ZodIssueCode.custom,
            message: `Value must be unique`,
            path: [...ctx.path, firstAppearanceIndex, 'value'],
          })
          return
        }
        uniqueValues.set(item.value., idx)
      })
    })

This worked great for me, however I had to remove the first item in the path array (...ctx.path) to actually display the custom issue code.

z.array({
      value: z.string()
}).superRefine((items, ctx) => {
      const uniqueValues = new Map<string, number>()
      items.forEach((item, idx) => {
        const firstAppearanceIndex = uniqueValues.get(item.value)
        if (firstAppearanceIndex !== undefined) {
          ctx.addIssue({
            code: z.ZodIssueCode.custom,
            message: `Value must be unique`,
            path: [...ctx.path, idx, 'value'],
          })
          ctx.addIssue({
            code: z.ZodIssueCode.custom,
            message: `Value must be unique`,
            path: [...ctx.path, firstAppearanceIndex, 'value'],
          })
          return
        }
        uniqueValues.set(item.value., idx)
      })
    })

I had to change this part from path: [...ctx.path, idx, 'value'], to just path: [idx, 'value'], to get it to work but sweet ty

Did that and updated the zod issue code while I was at it:

function arrayUnique<O, I>(schema: z.ZodType<O, I>) {
  return z.array(schema).superRefine((array, ctx) => {
    const uniqueValues = new Map<string, number>();

    array.forEach((item, i) => {
      const itemString = JSON.stringify(item);
      const firstAppearanceIndex = uniqueValues.get(itemString);

      if (firstAppearanceIndex !== undefined) {
        const message = `Invalid input: expected unique array elements, recieved duplicate ${itemString.substring(
          0,
          Math.min(50, itemString.length),
        )}${itemString.length > 50 ? '...' : ''}`;

        ctx.addIssue({
          code: 'custom',
          message,
          path: [i],
        });
        ctx.addIssue({
          code: 'custom',
          message,
          path: [firstAppearanceIndex],
        });

        return;
      }
      uniqueValues.set(itemString, i);
    });
  });
}

Zod sets didn't exist when I originally upvoted this question a while back IIRC. Glad to see they do now! 🎉

You can write a custom validation function and use refine or superRefine.

schema.superRefine((data, ctx) => {
    const ids = data.items.map(item => item.id);
    const uniqueIds = new Set(ids);
    
    if (ids.length !== uniqueIds.size) {
        ctx.addIssue({
            code: z.ZodIssueCode.custom,
            message: `Items must have unique ids.`,
            path: ["items"],
        });
    }
});