@palmares/schemas 0.1.21 → 0.1.22

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

@@ -1,66 +0,0 @@
-import * as p from '@palmares/schemas';
-import { describe } from '@palmares/tests';
-
-import type JestTestAdapter from '@palmares/jest-tests';
-
-describe<JestTestAdapter>('Boolean Tests', ({ test }) => {
-  test('optional', async ({ expect }) => {
-    const booleanSchema = p.boolean();
-    const booleanSchemaWithCustomMessage = p.boolean().nonOptional({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        booleanSchema.parse(undefined as any),
-        booleanSchemaWithCustomMessage.parse(undefined as any),
-        booleanSchema.parse(true)
-      ]);
-
-    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(true);
-  });
-
-  test('nullable', async ({ expect }) => {
-    const booleanSchema = p.boolean();
-    const booleanSchemaWithCustomMessage = p.boolean().nonNullable({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        booleanSchema.parse(null as any),
-        booleanSchemaWithCustomMessage.parse(null as any),
-        booleanSchema.parse(true)
-      ]);
-
-    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(true);
-  });
-
-  test('true and false values', async ({ expect }) => {
-    const booleanSchema = p.boolean().trueValues(['Y']).falseValues(['N']);
-
-    const [{ errors: errorsTrue, parsed: parsedTrue }, { errors: errorsFalse, parsed: parsedFalse }] =
-      await Promise.all([booleanSchema.parse('Y'), booleanSchema.parse('N')]);
-
-    expect((errorsTrue || []).length).toBe(0);
-    expect((errorsFalse || []).length).toBe(0);
-    expect(parsedTrue).toBe(true);
-    expect(parsedFalse).toBe(false);
-  });
-
-  test('number and string values', async ({ expect }) => {
-    const booleanSchema = p.boolean().allowNumber().allowString();
-
-    const [{ errors: errorsNumber, parsed: parsedNumber }, { errors: errorsString, parsed: parsedString }] =
-      await Promise.all([booleanSchema.parse(1), booleanSchema.parse('true')]);
-
-    expect((errorsNumber || []).length).toBe(0);
-    expect((errorsString || []).length).toBe(0);
-    expect(parsedNumber).toBe(true);
-    expect(parsedString).toBe(true);
-  });
-});

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

@@ -1,102 +0,0 @@
-import * as p from '@palmares/schemas';
-import { describe } from '@palmares/tests';
-
-import type JestTestAdapter from '@palmares/jest-tests';
-
-describe<JestTestAdapter>('Datetime Tests', ({ test }) => {
-  test('optional', async ({ expect }) => {
-    const datetimeSchema = p.datetime();
-    const datetimeSchemaWithCustomMessage = p.datetime().nonOptional({ message: 'hello' });
-    const now = new Date();
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        datetimeSchema.parse(undefined as any),
-        datetimeSchemaWithCustomMessage.parse(undefined as any),
-        datetimeSchema.parse(now)
-      ]);
-
-    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.toISOString()).toBe(now.toISOString());
-  });
-
-  test('nullable', async ({ expect }) => {
-    const datetimeSchema = p.datetime();
-    const datetimeSchemaWithCustomMessage = p.datetime().nonNullable({ message: 'hello' });
-    const now = new Date();
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        datetimeSchema.parse(null as any),
-        datetimeSchemaWithCustomMessage.parse(null as any),
-        datetimeSchema.parse(now)
-      ]);
-
-    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.toISOString()).toBe(now.toISOString());
-  });
-
-  test('below', async ({ expect }) => {
-    const nowMinus10Minutes = new Date();
-    nowMinus10Minutes.setMinutes(-10);
-    const nowMinus20Minutes = new Date();
-    nowMinus20Minutes.setMinutes(-20);
-    const datetimeSchema = p.datetime().below(nowMinus10Minutes);
-    const datetimeSchemaWithCustomMessage = p
-      .datetime()
-      .below(nowMinus10Minutes, { message: 'hello', inclusive: false });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        datetimeSchema.parse(nowMinus10Minutes),
-        datetimeSchemaWithCustomMessage.parse(nowMinus10Minutes),
-        datetimeSchema.parse(nowMinus20Minutes)
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('below');
-    expect(errorsOnFail?.[0]?.message).toBe('Value is not below the specified date');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed.toISOString()).toBe(nowMinus20Minutes.toISOString());
-  });
-
-  test('above', async ({ expect }) => {
-    const nowPlus10Minutes = new Date();
-    nowPlus10Minutes.setMinutes(nowPlus10Minutes.getMinutes() + 10);
-    const nowPlus20Minutes = new Date();
-    nowPlus20Minutes.setMinutes(nowPlus20Minutes.getMinutes() + 20);
-    const datetimeSchema = p.datetime().above(nowPlus10Minutes);
-    const datetimeSchemaWithCustomMessage = p
-      .datetime()
-      .below(nowPlus10Minutes, { message: 'hello', inclusive: false });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        datetimeSchema.parse(nowPlus10Minutes),
-        datetimeSchemaWithCustomMessage.parse(nowPlus10Minutes),
-        datetimeSchema.parse(nowPlus20Minutes)
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('above');
-    expect(errorsOnFail?.[0]?.message).toBe('Value is not above the specified date');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed.toISOString()).toBe(nowPlus20Minutes.toISOString());
-  });
-
-  test('allowString', async ({ expect }) => {
-    const datetimeSchema = p.datetime().allowString();
-    const now = new Date();
-
-    const { errors: errorsOnValid, parsed } = await datetimeSchema.parse(now.toISOString());
-
-    expect((errorsOnValid || []).length).toBe(0);
-    expect((parsed as Date).toISOString()).toBe(now.toISOString());
-  });
-});

package/__tests__/src/core/index.ts

@@ -1,35 +0,0 @@
-import { domain } from '@palmares/core';
-import { testDomainModifier, } from '@palmares/tests';
-import { databaseDomainModifier } from '@palmares/databases';
-import { migrate } from 'drizzle-orm/better-sqlite3/migrator';
-
-import * as models from './models';
-import { db } from '../settings';
-
-export default domain('testingZodSchemas', __dirname, {
-  commands: {
-    drizzleMigrate: {
-      description: 'Migrate the database using drizzle',
-      keywordArgs: undefined,
-      positionalArgs: undefined,
-      handler: () => {
-        migrate(db as any, { migrationsFolder: './.drizzle/migrations' });
-      }
-    }
-  },
-  modifiers: [testDomainModifier, databaseDomainModifier] as const,
-  getMigrations: () => [],
-  getModels: () => models,
-  getTests: () => [
-    //__dirname + '/test.test.ts',
-    //__dirname + '/numbers.test.ts',
-    //__dirname + '/boolean.test.ts',
-    //__dirname + '/datetime.test.ts',
-    //__dirname + '/object.test.ts',
-    //__dirname + '/union.test.ts',
-    //__dirname + '/array.test.ts',
-    //__dirname + '/types.test.ts',
-    //__dirname + '/string.test.ts',
-    __dirname + '/model.test.ts'
-  ]
-});

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

@@ -1,260 +0,0 @@
-import * as p from '@palmares/schemas';
-import { afterAll, beforeAll, describe } from '@palmares/tests';
-import { Company, User } from './models';
-
-describe('Model tests', ({ test }) => {
-  beforeAll(async () => {
-    await Company.default.set({
-      name: 'Targaryen',
-      usersOfCompany: [{
-        name: 'Rhaenyra Targaryen',
-        age: 25
-      }, {
-        name: 'Aegon Targaryen',
-        age: 21
-      }]
-    }, {
-      includes: [{
-        model: User
-      }]
-    })
-    await Company.default.set({
-      name: 'Stark',
-      usersOfCompany: [{
-        name: 'Arya Stark',
-        age: 22
-      }, {
-        name: 'Ned Stark',
-        age: 46
-      }, {
-        name: 'Sansa Stark',
-        age: 26
-      }]
-    }, {
-      includes: [{
-        model: User
-      }]
-    })
-  });
-
-
-  test('basic', async ({ expect }) => {
-    const modelWithAllFields = p.modelSchema(User, {
-      omit: []
-    });
-    const modelWithFieldsOmitted = p.modelSchema(User, {
-      omit: ['id', 'createdAt']
-    });
-    const modelWithAFewFieldsShown = p.modelSchema(User, {
-      show: ['name', 'age', 'companyId']
-    });
-    const data = await User.default.get({
-      search: {
-        name: {
-          like: '%Stark'
-        }
-      }
-    })
-
-    const [
-      dataWithAllFields,
-      dataWithFieldsOmitted,
-      dataWithFewFieldsShown,
-      { parsed: parsedDataWithAllFields, errors: errorsOfAllFields },
-      { parsed: parsedDataWithFieldsOmitted, errors: errorsOfFieldsOmitted },
-      { parsed: parsedDataWithFewFieldsShown, errors: errorsOfAFewFieldsShown }
-    ] = await Promise.all([
-      modelWithAllFields.data(structuredClone(data[0])),
-      modelWithFieldsOmitted.data(structuredClone(data[0])),
-      modelWithAFewFieldsShown.data(structuredClone(data[0])),
-      modelWithAllFields.parse(structuredClone(data[0])),
-      modelWithFieldsOmitted.parse(structuredClone(data[0])),
-      modelWithAFewFieldsShown.parse(structuredClone(data[0])),
-    ])
-
-    expect(
-      Object.keys(dataWithAllFields).every((key) => ['id', 'name', 'age', 'updatedAt', 'createdAt', 'companyId'].includes(key))
-    ).toBe(true);
-    expect(
-      Object.keys(dataWithFieldsOmitted).every((key) => ['name', 'age', 'updatedAt', 'companyId'].includes(key)) &&
-      Object.keys(dataWithFieldsOmitted).every((key) => !['id', 'createdAt'].includes(key))
-    ).toBe(true);
-    expect(
-      Object.keys(dataWithFewFieldsShown).every((key) => ['age', 'name', 'companyId'].includes(key)) &&
-      Object.keys(dataWithFewFieldsShown).every((key) => !['createdAt', 'id', 'updatedAt'].includes(key))
-    ).toBe(true);
-    expect(
-      Object.keys(parsedDataWithAllFields).every((key) => ['id', 'name', 'age', 'updatedAt', 'createdAt', 'companyId'].includes(key))
-    ).toBe(true);
-    expect(
-      Object.keys(parsedDataWithFieldsOmitted).every((key) => ['name', 'age', 'updatedAt', 'companyId'].includes(key)) &&
-      Object.keys(parsedDataWithFieldsOmitted).every((key) => !['id', 'createdAt'].includes(key))
-    ).toBe(true);
-    expect(
-      Object.keys(parsedDataWithFewFieldsShown).every((key) => ['age', 'name', 'companyId'].includes(key)) &&
-      Object.keys(parsedDataWithFewFieldsShown).every((key) => !['createdAt', 'id', 'updatedAt'].includes(key))
-    ).toBe(true);
-    expect((errorsOfAllFields || []).length).toBe(0);
-    expect((errorsOfFieldsOmitted || []).length).toBe(0);
-    expect((errorsOfAFewFieldsShown || []).length).toBe(0);
-  });
-
-  test('array', async ({expect}) => {
-    const modelWithAllFields = p.modelSchema(User, {
-      many: true,
-      omit: []
-    });
-    const modelWithFieldsOmitted = p.modelSchema(User, {
-      many: true,
-      omit: ['id', 'createdAt']
-    });
-    const modelWithAFewFieldsShown = p.modelSchema(User, {
-      many: true,
-      show: ['name', 'age', 'companyId']
-    });
-    const data = await User.default.get({
-      search: {
-        name: {
-          like: '%Stark'
-        }
-      }
-    });
-
-    const [
-      dataWithAllFields,
-      dataWithFieldsOmitted,
-      dataWithFewFieldsShown,
-      { parsed: parsedDataWithAllFields, errors: errorsOfAllFields },
-      { parsed: parsedDataWithFieldsOmitted, errors: errorsOfFieldsOmitted },
-      { parsed: parsedDataWithFewFieldsShown, errors: errorsOfAFewFieldsShown }
-    ] = await Promise.all([
-      modelWithAllFields.data(structuredClone(data)),
-      modelWithFieldsOmitted.data(structuredClone(data)),
-      modelWithAFewFieldsShown.data(structuredClone(data)),
-      modelWithAllFields.parse(structuredClone(data)),
-      modelWithFieldsOmitted.parse(structuredClone(data)),
-      modelWithAFewFieldsShown.parse(structuredClone(data)),
-    ])
-
-    expect(
-      Object.keys(dataWithAllFields[0]).every((key) => ['id', 'name', 'age', 'updatedAt', 'createdAt', 'companyId'].includes(key))
-    ).toBe(true);
-    expect(
-      Object.keys(dataWithFieldsOmitted[0]).every((key) => ['name', 'age', 'updatedAt', 'companyId'].includes(key)) &&
-      Object.keys(dataWithFieldsOmitted[0]).every((key) => !['id', 'createdAt'].includes(key))
-    ).toBe(true);
-    expect(
-      Object.keys(dataWithFewFieldsShown[0]).every((key) => ['age', 'name', 'companyId'].includes(key)) &&
-      Object.keys(dataWithFewFieldsShown[0]).every((key) => !['createdAt', 'id', 'updatedAt'].includes(key))
-    ).toBe(true);
-    expect(
-      Object.keys(parsedDataWithAllFields[0]).every((key) => ['id', 'name', 'age', 'updatedAt', 'createdAt', 'companyId'].includes(key))
-    ).toBe(true);
-    expect(
-      Object.keys(parsedDataWithFieldsOmitted[0]).every((key) => ['name', 'age', 'updatedAt', 'companyId'].includes(key)) &&
-      Object.keys(parsedDataWithFieldsOmitted[0]).every((key) => !['id', 'createdAt'].includes(key))
-    ).toBe(true);
-    expect(
-      Object.keys(parsedDataWithFewFieldsShown[0]).every((key) => ['age', 'name', 'companyId'].includes(key)) &&
-      Object.keys(parsedDataWithFewFieldsShown[0]).every((key) => !['createdAt', 'id', 'updatedAt'].includes(key))
-    ).toBe(true);
-    expect(dataWithAllFields.length).toBe(data.length);
-    expect(dataWithFieldsOmitted.length).toBe(data.length);
-    expect(dataWithFewFieldsShown.length).toBe(data.length);
-    expect(parsedDataWithAllFields.length).toBe(data.length);
-    expect(parsedDataWithFieldsOmitted.length).toBe(data.length);
-    expect(parsedDataWithFewFieldsShown.length).toBe(data.length);
-    expect((errorsOfAllFields || []).length).toBe(0);
-    expect((errorsOfFieldsOmitted || []).length).toBe(0);
-    expect((errorsOfAFewFieldsShown || []).length).toBe(0);
-  });
-
-  test('auto join', async ({ expect }) => {
-    const companyModel = p.modelSchema(Company, {
-      omit: ['translatable'],
-    }).optional({ outputOnly: true });
-    const userModel = p.modelSchema(User, {
-      many: true,
-      omit: []
-    }).optional({ outputOnly: true });
-
-    const arrayModelDirectly = p.modelSchema(User, {
-      many: true,
-      fields: {
-        company: companyModel
-      },
-      omit: [],
-    });
-    const arrayModelIndirectly = p.modelSchema(Company, {
-      many: true,
-      fields: {
-        usersOfCompany: userModel
-      },
-      omit: [],
-    })
-    const objectModelDirectly = p.modelSchema(User, {
-      fields: {
-        company: companyModel
-      },
-      omit: [],
-    });
-
-    const objectModelIndirectly = p.modelSchema(Company, {
-      fields: {
-        usersOfCompany: userModel
-      },
-      omit: [],
-    });
-
-    const userData = await User.default.get({
-      search: {
-        name: {
-          like: '%Stark'
-        }
-      }
-    });
-    const companyData = await Company.default.get({
-      search: {
-        name: 'Targaryen'
-      }
-    });
-
-    const [
-      arrayModelDirectlyData,
-      arrayModelIndirectlyData,
-      objectModelDirectlyData,
-      objectModelIndirectlyData
-    ] = await Promise.all([
-      arrayModelDirectly.data(structuredClone(userData)),
-      arrayModelIndirectly.data(structuredClone(companyData)),
-      objectModelDirectly.data(structuredClone(userData[0])),
-      objectModelIndirectly.data(structuredClone(companyData[0]))
-    ]);
-
-    expect(arrayModelDirectlyData.length).toBe(3);
-    expect(arrayModelDirectlyData[0].company.name).toBe('Stark');
-    expect(arrayModelDirectlyData[2].company.name).toBe('Stark')
-    expect(arrayModelIndirectlyData[0].usersOfCompany.length).toBe(2);
-    expect(arrayModelIndirectlyData[0].usersOfCompany[0].companyId).toBe(arrayModelIndirectlyData[0].id as number);
-    expect(objectModelDirectlyData.company.name).toBe('Stark');
-    expect(objectModelIndirectlyData.usersOfCompany.length).toBe(2);
-    expect(objectModelIndirectlyData.usersOfCompany[0].companyId).toBe(objectModelIndirectlyData.id as number);
-  });
-
-  afterAll(async () => {
-    await User.default.remove({
-      search: {
-        name: {
-          in: ['Arya Stark', 'Ned Stark',  'Sansa Stark', 'Sansa Start', 'Rhaenyra Targaryen', 'Aegon Targaryen']
-        }
-      }
-    });
-    await Company.default.remove({
-      search: {
-        name: {
-          in: ['Stark', 'Targaryen']
-        }
-      }
-    });
-  });
-});

package/__tests__/src/core/models.ts

@@ -1,50 +0,0 @@
-import {
-  AutoField,
-  CharField,
-  DateField,
-  ForeignKeyField,
-  IntegerField,
-  Model,
-  ON_DELETE,
-  TranslatableField,
-  define
-} from '@palmares/databases';
-
-import type { ModelOptionsType } from '@palmares/databases';
-
-export const Company = define('Company', {
-  fields: {
-    id: AutoField.new(),
-    name: CharField.new({ maxLength: 255 }),
-    translatable: TranslatableField.new({
-      // eslint-disable-next-line ts/require-await
-      translate: async () => {
-        return `d.real('translatable')`;
-      }
-    })
-  },
-  options: {
-    tableName: 'companies'
-  }
-});
-
-export class User extends Model<User>() {
-  fields = {
-    id: AutoField.new(),
-    companyId: ForeignKeyField.new({
-      onDelete: ON_DELETE.CASCADE,
-      relatedName: 'usersOfCompany',
-      relationName: 'company',
-      toField: 'id',
-      relatedTo: Company
-    }),
-    name: CharField.new({ maxLength: 255, dbIndex: true, allowNull: true }),
-    age: IntegerField.new({ dbIndex: true }),
-    updatedAt: DateField.new({ autoNow: true }),
-    createdAt: DateField.new({ autoNowAdd: true })
-  };
-
-  options: ModelOptionsType<User> = {
-    tableName: 'users'
-  };
-}

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

@@ -1,177 +0,0 @@
-import * as p from '@palmares/schemas';
-import { describe } from '@palmares/tests';
-
-import type JestTestAdapter from '@palmares/jest-tests';
-
-describe<JestTestAdapter>('Number Tests', ({ test }) => {
-  test('optional', async ({ expect }) => {
-    const numberSchema = p.number();
-    const numberSchemaWithCustomMessage = p.number().nonOptional({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        numberSchema.parse(undefined as any),
-        numberSchemaWithCustomMessage.parse(undefined as any),
-        numberSchema.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 numberSchema = p.number();
-    const numberSchemaWithCustomMessage = p.number().nonNullable({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        numberSchema.parse(null as any),
-        numberSchemaWithCustomMessage.parse(null as any),
-        numberSchema.parse(1)
-      ]);
-
-    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(1);
-  });
-
-  test('maxDigits', async ({ expect }) => {
-    const numberSchema = p.number().maxDigits(5);
-    const numberSchemaWithCustomMessage = p.number().maxDigits(5, { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        numberSchema.parse(1234567),
-        numberSchemaWithCustomMessage.parse(1234567),
-        numberSchema.parse(1)
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('maxDigits');
-    expect(errorsOnFail?.[0]?.message).toBe('The number should have at most 5 digits');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe(1);
-  });
-
-  test('decimalPlaces', async ({ expect }) => {
-    const numberSchema = p.number().decimalPlaces(2);
-    const numberSchemaWithCustomMessage = p.number().decimalPlaces(2, { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        numberSchema.parse(123.4567),
-        numberSchemaWithCustomMessage.parse(123.4567),
-        numberSchema.parse(1)
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('decimalPlaces');
-    expect(errorsOnFail?.[0]?.message).toBe('The number should have 2 decimal places');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe(1);
-  });
-
-  test('is', async ({ expect }) => {
-    const numberSchema = p.number().is([1, 2]);
-    const numberSchemaWithCustomMessage = p.number().is([1, 2], { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        numberSchema.parse(123.4567 as any),
-        numberSchemaWithCustomMessage.parse(123.4567 as any),
-        numberSchema.parse(1)
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('is');
-    expect(errorsOnFail?.[0]?.message).toBe('The value should be equal to 1,2');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe(1);
-  });
-
-  test('is', async ({ expect }) => {
-    const numberSchema = p.number().is([1, 2]);
-    const numberSchemaWithCustomMessage = p.number().is([1, 2], { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        numberSchema.parse(123.4567 as any),
-        numberSchemaWithCustomMessage.parse(123.4567 as any),
-        numberSchema.parse(1)
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('is');
-    expect(errorsOnFail?.[0]?.message).toBe('The value should be equal to 1,2');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe(1);
-  });
-
-  test('integer', async ({ expect }) => {
-    const numberSchema = p.number().integer();
-    const numberSchemaWithCustomMessage = p.number().integer({ message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        numberSchema.parse(123.4567 as any),
-        numberSchemaWithCustomMessage.parse(123.4567 as any),
-        numberSchema.parse(1)
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('integer');
-    expect(errorsOnFail?.[0]?.message).toBe('The number should be an integer.');
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe(1);
-  });
-
-  test('max', async ({ expect }) => {
-    const numberSchema = p.number().max(100, { inclusive: true });
-    const numberSchemaWithCustomMessage = p.number().max(100, { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([
-        numberSchema.parse(123 as any),
-        numberSchemaWithCustomMessage.parse(123 as any),
-        numberSchema.parse(100)
-      ]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('max');
-    expect(errorsOnFail?.[0]?.message).toBe(
-      'The number is greater than the allowed 100. The value 100 is accepted as well.'
-    );
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe(100);
-  });
-
-  test('min', async ({ expect }) => {
-    const numberSchema = p.number().min(100, { inclusive: true });
-    const numberSchemaWithCustomMessage = p.number().min(100, { message: 'hello' });
-
-    const [{ errors: errorsOnFail }, { errors: errorsOnFailWithCustomMessage }, { errors: errorsOnValid, parsed }] =
-      await Promise.all([numberSchema.parse(1), numberSchemaWithCustomMessage.parse(1), numberSchema.parse(100)]);
-
-    expect(errorsOnFailWithCustomMessage?.[0]?.message).toBe('hello');
-    expect(errorsOnFail?.[0]?.code).toBe('min');
-    expect(errorsOnFail?.[0]?.message).toBe(
-      'The number is less than the allowed 100. The value 100 is accepted as well.'
-    );
-    expect((errorsOnValid || []).length).toBe(0);
-    expect(parsed).toBe(100);
-  });
-
-  test('allowString', async ({ expect }) => {
-    const numberSchema = p.number().allowString();
-
-    const { errors, parsed } = await numberSchema.parse('100');
-
-    expect((errors || []).length).toBe(0);
-    expect(parsed).toBe(100);
-  });
-});