@palmares/schemas 0.1.21 → 0.1.23

package/__tests__/src/core/object.test.ts

@@ -1,218 +0,0 @@
-import * as p from '@palmares/schemas';
-import { describe } from '@palmares/tests';
-
-import type JestTestAdapter from '@palmares/jest-tests';
-
-describe<JestTestAdapter>('Object Tests', ({ test }) => {
-  test('optional', async ({ expect }) => {
-    const objectSchema = p.object({
-      name: p.string(),
-      age: p.number()
-    });
-    const objectSchemaWithCustomMessage = p
-      .object({
-        name: p.string(),
-        age: p.number()
-      })
-      .nonOptional({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        objectSchema.parse(undefined as any),
-        objectSchemaWithCustomMessage.parse(undefined as any),
-        objectSchema.parse({
-          name: 'John',
-          age: 30
-        })
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('required');
-    expect(errorsOnFail?.[0]?.message).toBe('Required');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed.age).toBe(30);
-    expect(parsed.name).toBe('John');
-  });
-
-  test('nullable', async ({ expect }) => {
-    const objectSchema = p.object({
-      name: p.string(),
-      age: p.number()
-    });
-    const objectSchemaWithCustomMessage = p
-      .object({
-        name: p.string(),
-        age: p.number()
-      })
-      .nonNullable({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        objectSchema.parse(null as any),
-        objectSchemaWithCustomMessage.parse(null as any),
-        objectSchema.parse({
-          name: 'John',
-          age: 30
-        })
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('null');
-    expect(errorsOnFail?.[0]?.message).toBe('Cannot be null');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed.age).toBe(30);
-    expect(parsed.name).toBe('John');
-  });
-
-  test('optional on key', async ({ expect }) => {
-    const objectSchema = p.object({
-      name: p.string(),
-      age: p.number()
-    });
-    const objectSchemaWithCustomMessage = p.object({
-      name: p.string(),
-      age: p.number().nonOptional({ message: 'hello' })
-    });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        objectSchema.parse({
-          name: 'John'
-        } as any),
-        objectSchemaWithCustomMessage.parse({
-          name: 'John'
-        } as any),
-        objectSchema.parse({
-          name: 'John',
-          age: 30
-        })
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('required');
-    expect(errorsOnFail?.[0]?.message).toBe('Required');
-    expect(errorsOnFail?.[0]?.path?.[0]).toBe('age');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed.age).toBe(30);
-    expect(parsed.name).toBe('John');
-  });
-
-  test('nullable on key', async ({ expect }) => {
-    const objectSchema = p.object({
-      name: p.string(),
-      age: p.number()
-    });
-    const objectSchemaWithCustomMessage = p.object({
-      name: p.string(),
-      age: p.number().nonNullable({ message: 'hello' })
-    });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        objectSchema.parse({
-          name: 'John',
-          age: null
-        } as any),
-        objectSchemaWithCustomMessage.parse({
-          name: 'John',
-          age: null
-        } as any),
-        objectSchema.parse({
-          name: 'John',
-          age: 30
-        })
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('null');
-    expect(errorsOnFail?.[0]?.message).toBe('Cannot be null');
-    expect(errorsOnFail?.[0]?.path?.[0]).toBe('age');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed.age).toBe(30);
-    expect(parsed.name).toBe('John');
-  });
-
-  test('max from string and number', async ({ expect }) => {
-    const objectSchema = p.object({
-      name: p.string().maxLength(10),
-      age: p.number().max(10)
-    });
-
-    const [{ errors: errorsWhenString }, { errors: errorWhenNumber }] = await Promise.all([
-      objectSchema.parse({
-        name: 'John12345789123',
-        age: 10
-      } as any),
-      objectSchema.parse({
-        name: 'John',
-        age: 12
-      } as any)
-    ]);
-
-    expect(errorsWhenString?.[0]?.code).toBe('maxLength');
-    expect(errorWhenNumber?.[0]?.code).toBe('max');
-  });
-
-  test('min from string and number', async ({ expect }) => {
-    const objectSchema = p.object({
-      name: p.string().minLength(10),
-      age: p.number().min(10)
-    });
-
-    const [{ errors: errorsWhenString }, { errors: errorWhenNumber }] = await Promise.all([
-      objectSchema.parse({
-        name: 'John',
-        age: 11
-      } as any),
-      objectSchema.parse({
-        name: 'John123456789123',
-        age: 9
-      } as any)
-    ]);
-
-    expect(errorsWhenString?.[0]?.code).toBe('minLength');
-    expect(errorWhenNumber?.[0]?.code).toBe('min');
-  });
-
-  test('nested issue', async ({ expect }) => {
-    const objectSchema = p.object({
-      nested: p.object({
-        name: p.string(),
-        age: p.number().max(10)
-      }),
-      value: p.number()
-    });
-
-    const { errors } = await objectSchema.parse({
-      nested: {
-        name: 'John',
-        age: 12
-      },
-      value: 20
-    });
-
-    expect(errors?.[0]?.code).toBe('max');
-    expect(errors?.[0]?.path?.[0]).toBe('nested');
-    expect(errors?.[0]?.path?.[1]).toBe('age');
-  });
-
-  test('nested issue error message', async ({ expect }) => {
-    const schema = p.object({
-      name: p.string(),
-      age: p.number(),
-    }).toInternal(async (data) => {
-      return {
-        name: 'Hello ' + data.name,
-        age: data.age,
-      };
-    }).toRepresentation(async (data) => {
-      return {
-        name: 'Hello from backend',
-      };
-    });
-
-    const data = await schema.data({ name: 'John', age: 20 });
-    expect(data.name).toBe('Hello from backend');
-  });
-});
-

package/__tests__/src/core/string.test.ts

@@ -1,222 +0,0 @@
-import * as p from '@palmares/schemas';
-import { describe } from '@palmares/tests';
-
-import type JestTestAdapter from '@palmares/jest-tests';
-
-describe<JestTestAdapter>('String Schema', ({ test }) => {
-  test('optional', async ({ expect }) => {
-    const stringSchema = p.string();
-    const stringSchemaWithCustomMessage = p.string().nonOptional({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse(undefined as any),
-        stringSchemaWithCustomMessage.parse(undefined as any),
-        stringSchema.parse('a')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('required');
-    expect(errorsOnFail?.[0]?.message).toBe('Required');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('a');
-  });
-
-  test('nullable', async ({ expect }) => {
-    const stringSchema = p.string();
-    const stringSchemaWithCustomMessage = p.string().nonNullable({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse(null as any),
-        stringSchemaWithCustomMessage.parse(null as any),
-        stringSchema.parse('a')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('null');
-    expect(errorsOnFail?.[0]?.message).toBe('Cannot be null');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('a');
-  });
-
-  test('is', async ({ expect }) => {
-    const stringSchema = p.string().is(['a', 'b']);
-    const stringSchemaWithCustomMessage = p.string().is(['a', 'b'], { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('c' as any),
-        stringSchemaWithCustomMessage.parse('c' as any),
-        stringSchema.parse('a')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('is');
-    expect(errorsOnFail?.[0]?.message).toBe('The value should be equal to a, b');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('a');
-  });
-
-  test('includes', async ({ expect }) => {
-    const stringSchema = p.string().includes('Hello');
-    const stringSchemaWithCustomMessage = p.string().includes('Hello', { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('World'),
-        stringSchemaWithCustomMessage.parse('World'),
-        stringSchema.parse('Hello World')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('includes');
-    expect(errorsOnFail?.[0]?.message).toBe(`The string value should include the following substring 'Hello'`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('Hello World');
-  });
-
-  test('maxLength', async ({ expect }) => {
-    const stringSchema = p.string().maxLength(8);
-    const stringSchemaWithCustomMessage = p.string().maxLength(8, { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('Hello World'),
-        stringSchemaWithCustomMessage.parse('Hello World'),
-        stringSchema.parse('Hello')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('maxLength');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should have a maximum length of 8`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('Hello');
-  });
-
-  test('minLength', async ({ expect }) => {
-    const stringSchema = p.string().minLength(8);
-    const stringSchemaWithCustomMessage = p.string().minLength(8, { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse(''),
-        stringSchemaWithCustomMessage.parse(''),
-        stringSchema.parse('Hello World')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('minLength');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should have a minimum length of 8`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('Hello World');
-  });
-
-  test('startsWith', async ({ expect }) => {
-    const stringSchema = p.string().startsWith('Hello');
-    const stringSchemaWithCustomMessage = p.string().startsWith('Hello', { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('Palmares, the best FW in the world!!!!!'),
-        stringSchemaWithCustomMessage.parse(`I actually think it's bad`),
-        stringSchema.parse('Hello, World')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('startsWith');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should start with Hello`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('Hello, World');
-  });
-
-  test('endsWith', async ({ expect }) => {
-    const stringSchema = p.string().endsWith('World');
-    const stringSchemaWithCustomMessage = p.string().endsWith('World', { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('Palmares, the best FW in the world!!!!!'),
-        stringSchemaWithCustomMessage.parse(`I actually think it's bad`),
-        stringSchema.parse('Hello, World')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('endsWith');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should end with World`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('Hello, World');
-  });
-
-  test('endsWith', async ({ expect }) => {
-    const stringSchema = p.string().endsWith('World');
-    const stringSchemaWithCustomMessage = p.string().endsWith('World', { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('Palmares, the best FW in the world!!!!!'),
-        stringSchemaWithCustomMessage.parse(`I actually think it's bad`),
-        stringSchema.parse('Hello, World')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('endsWith');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should end with World`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('Hello, World');
-  });
-
-  test('regex', async ({ expect }) => {
-    const regex = new RegExp('Hello', 'g');
-    const stringSchema = p.string().regex(regex);
-    const stringSchemaWithCustomMessage = p.string().regex(regex, { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('Palmares, the best FW in the world!!!!!'),
-        stringSchemaWithCustomMessage.parse(`I actually think it's bad`),
-        stringSchema.parse('Hello, World')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('regex');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should match the following regex '/Hello/g'`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('Hello, World');
-  });
-
-  test('uuid', async ({ expect }) => {
-    const stringSchema = p.string().uuid();
-    const stringSchemaWithCustomMessage = p.string().uuid({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('Palmares, the best FW in the world!!!!!'),
-        stringSchemaWithCustomMessage.parse(`I actually think it's bad`),
-        stringSchema.parse('f54bb64b-0aed-47f9-976e-a8900d86f6c9')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('uuid');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should be a valid UUID`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('f54bb64b-0aed-47f9-976e-a8900d86f6c9');
-  });
-
-  test('email', async ({ expect }) => {
-    const stringSchema = p.string().email();
-    const stringSchemaWithCustomMessage = p.string().email({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        stringSchema.parse('Palmares, the best FW in the world!!!!!'),
-        stringSchemaWithCustomMessage.parse(`I actually think it's bad`),
-        stringSchema.parse('test@test.com')
-      ]);
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('email');
-    expect(errorsOnFail?.[0]?.message).toBe(`The value should be a valid email`);
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('test@test.com');
-  });
-});

package/__tests__/src/core/test.test.ts

@@ -1,59 +0,0 @@
-import * as p from '@palmares/schemas';
-import { describe } from '@palmares/tests';
-
-import type JestTestAdapter from '@palmares/jest-tests';
-
-describe<JestTestAdapter>('Basic Schemas', ({ test }) => {
-  test('basic representation', async ({ expect }) => {
-    const basicSchema = p.number();
-
-    const data = await basicSchema.data(2);
-
-    expect(data).toBe(2);
-  });
-
-  test('basic to representation', async ({ expect }) => {
-    const defaultMessage = 'This used to be a number';
-    // eslint-disable-next-line ts/require-await
-    const numberSchema = p.number().toRepresentation(async () => {
-      return defaultMessage;
-    });
-
-    // eslint-disable-next-line ts/require-await
-    const schemaTransformingData = p.number().toRepresentation(async (data) => {
-      return {
-        number: data,
-        message: defaultMessage
-      };
-    });
-
-    const stringMessage = await numberSchema.data(2);
-    const objectMessage = await schemaTransformingData.data(2);
-
-    expect(stringMessage).toBe(defaultMessage);
-    expect(objectMessage.message).toBe(defaultMessage);
-    expect(objectMessage.number).toBe(2);
-  });
-
-  test('basic internal', async ({ expect }) => {
-    // eslint-disable-next-line ts/require-await
-    const internalSchema = p.number().toInternal(async (data) => {
-      return data * 2;
-    });
-
-    const { parsed } = await internalSchema.parse(2);
-
-    expect(parsed).toBe(4);
-  });
-
-  test('basic validation', async ({ expect }) => {
-    // eslint-disable-next-line ts/require-await
-    const internalSchema = p.number().toValidate(async () => {
-      return 'Should fail';
-    });
-
-    const { errors } = await internalSchema.parse(2);
-
-    expect((errors?.length || 0) > 0).toBe(true);
-  });
-});

package/__tests__/src/core/types.test.ts

@@ -1,97 +0,0 @@
-import * as p from '@palmares/schemas';
-import { describe } from '@palmares/tests';
-
-import type JestTestAdapter from '@palmares/jest-tests';
-
-describe<JestTestAdapter>('Schema Types', ({ test }) => {
-  test('number schema', async ({ expect }) => {
-    const numberSchema = p.number();
-
-    const { errors } = await numberSchema.parse('value' as any);
-
-    expect((errors?.length || 0) > 0).toBe(true);
-  });
-
-  test('boolean schema', async ({ expect }) => {
-    const booleanSchema = p.boolean();
-
-    const { errors } = await booleanSchema.parse('value' as any);
-
-    expect((errors?.length || 0) > 0).toBe(true);
-  });
-
-  test('date schema', async ({ expect }) => {
-    const dateSchema = p.datetime();
-
-    const { errors } = await dateSchema.parse('value' as any);
-
-    expect((errors?.length || 0) > 0).toBe(true);
-  });
-
-  test('string schema', async ({ expect }) => {
-    const stringSchema = p.string();
-
-    const { errors } = await stringSchema.parse(2 as any);
-
-    expect((errors?.length || 0) > 0).toBe(true);
-  });
-
-  test('array schema', async ({ expect }) => {
-    const tupleSchema = p.array(p.number(), p.string());
-    const arraySchema = p.array([p.number()]);
-
-    const [
-      { errors: errorsOfInvalidArray },
-      { errors: errorsOfInvalidTuple },
-      { errors: errorsOfValidArray, parsed: parsedArray },
-      { errors: errorsOfValidTuple, parsed: parsedTuple }
-    ] = await Promise.all([
-      arraySchema.parse('value' as any),
-      tupleSchema.parse([1, 2, 3] as any),
-      arraySchema.parse([1, 2, 3]),
-      tupleSchema.parse([1, 'string'])
-    ]);
-
-    expect((errorsOfInvalidArray?.length || 0) > 0).toBe(true);
-    expect((errorsOfInvalidTuple?.length || 0) > 0).toBe(true);
-    expect(errorsOfValidArray?.length || 0).toBe(0);
-    expect(errorsOfValidTuple?.length || 0).toBe(0);
-    expect(parsedArray[0]).toBe(1);
-    expect(parsedArray[1]).toBe(2);
-    expect(parsedArray[2]).toBe(3);
-    expect(parsedTuple[0]).toBe(1);
-    expect(parsedTuple[1]).toBe('string');
-  });
-
-  test('object schema', async ({ expect }) => {
-    const objectSchema = p.object({
-      number: p.number(),
-      string: p.string()
-    });
-
-    const [{ errors: errorsOfInvalid }, { errors: errorsOfValid, parsed }] = await Promise.all([
-      objectSchema.parse('value' as any),
-      objectSchema.parse({
-        number: 1,
-        string: 'string'
-      })
-    ]);
-
-    expect((errorsOfInvalid?.length || 0) > 0).toBe(true);
-    expect((errorsOfValid?.length || 0) === 0).toBe(true);
-    expect(parsed.number).toBe(1);
-    expect(parsed.string).toBe('string');
-  });
-
-  test('union schema', async ({ expect }) => {
-    const unionSchema = p.union([p.string(), p.number()]);
-
-    const [{ errors: errorsOfInvalid }, { errors: errorsOfValid, parsed }] = await Promise.all([
-      unionSchema.parse(true as any),
-      unionSchema.parse(2)
-    ]);
-    expect((errorsOfInvalid?.length || 0) > 0).toBe(true);
-    expect((errorsOfValid?.length || 0) === 0).toBe(true);
-    expect(parsed).toBe(2);
-  });
-});

package/__tests__/src/core/union.test.ts

@@ -1,99 +0,0 @@
-import * as p from '@palmares/schemas';
-import { getDefaultAdapter } from '@palmares/schemas';
-import { describe } from '@palmares/tests';
-
-import type JestTestAdapter from '@palmares/jest-tests';
-
-describe<JestTestAdapter>('Union Tests', ({ test }) => {
-  test('optional', async ({ expect }) => {
-    const unionSchema = p.union([p.number(), p.string()]);
-    const unionSchemaWithCustomMessage = p.union([p.number(), p.string()]).nonOptional({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        unionSchema.parse(undefined as any),
-        unionSchemaWithCustomMessage.parse(undefined as any),
-        unionSchema.parse(1)
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('required');
-    expect(errorsOnFail?.[0]?.message).toBe('Required');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe(1);
-  });
-
-  test('nullable', async ({ expect }) => {
-    const unionSchema = p.union([p.number(), p.string()]);
-    const unionSchemaWithCustomMessage = p.union([p.number(), p.string()]).nonNullable({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        unionSchema.parse(null as any),
-        unionSchemaWithCustomMessage.parse(null as any),
-        unionSchema.parse('teste')
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('null');
-    expect(errorsOnFail?.[0]?.message).toBe('Cannot be null');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe('teste');
-  });
-
-  test('in case of failure use the other', async ({ expect }) => {
-    const unionSchema = p.union([p.number().max(20), p.number().min(12)]);
-
-    const { errors, parsed } = await unionSchema.parse(25);
-    expect((errors || []).length).toBe(0);
-    expect(parsed).toBe(25);
-  });
-
-  test('in case of failure, show first', async ({ expect }) => {
-    const unionSchema = p.union([p.number().min(25), p.number().max(20)]);
-
-    const { errors } = await unionSchema.parse(23);
-    expect((errors || []).length > 0).toBe(true);
-  });
-
-  test('works when not defined on adapter', async ({ expect }) => {
-    const adapter = getDefaultAdapter();
-    const existingUnion = adapter.union;
-    adapter.union = undefined;
-    const unionSchema = p.union([p.number().min(25), p.number().max(20)]);
-    const { errors } = await unionSchema.parse(23);
-    expect((errors || []).length > 0).toBe(true);
-
-    adapter.union = existingUnion;
-  });
-
-  test('nested in case of failure use the other', async ({ expect }) => {
-    const unionSchema = p.object({
-      test: p.union([p.number().max(20), p.number().min(12)] as const)
-    });
-
-    const { errors, parsed } = await unionSchema.parse({
-      test: 23
-    });
-    expect((errors || []).length).toBe(0);
-    expect(parsed.test).toBe(23);
-  });
-
-  test('nested in case of failure, show first', async ({ expect }) => {
-    const unionSchema = p.object({ test: p.union([p.number().min(25), p.number().max(20)]) });
-
-    const { errors } = await unionSchema.parse({ test: 23 });
-    expect((errors || []).length > 0).toBe(true);
-  });
-
-  test('nested works when not defined on adapter', async ({ expect }) => {
-    const adapter = getDefaultAdapter();
-    const existingUnion = adapter.union;
-    adapter.union = undefined;
-    const unionSchema = p.object({ test: p.union([p.number().min(25), p.number().max(20)]) });
-    const { errors } = await unionSchema.parse({ test: 23 });
-    expect((errors || []).length > 0).toBe(true);
-
-    adapter.union = existingUnion;
-  });
-});