@palmares/schemas 0.1.20 → 0.1.22

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);
-  });
-});

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');
-  });
-});
-