@palmares/schemas 0.0.1 → 0.1.1

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

@@ -0,0 +1,260 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,177 @@
+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

@@ -0,0 +1,198 @@
+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');
+  });
+});