Merge branch 'develop' into next

Author: Julien-R44

package.json

@@ -1,7 +1,10 @@
 {
 	"name": "@adonisjs/validator",
-	"version": "13.0.2-3",
 	"description": "Validator for adonis framework",
+	"version": "13.0.2-3",
+	"engines": {
+		"node": ">=18.16.0"
+	},
 	"main": "build/index.js",
 	"type": "module",
 	"files": [
@@ -14,9 +17,6 @@
 		"./validator_provider": "./build/providers/validator_provider.js",
 		"./types": "./build/src/types.js"
 	},
-	"engines": {
-		"node": ">=18.16.0"
-	},
 	"scripts": {
 		"pretest": "npm run lint",
 		"test": "c8 npm run quick:test",
@@ -75,22 +75,26 @@
 	"peerDependencies": {
 		"@adonisjs/core": "^6.2.0"
 	},
-	"keywords": [
-		"validator",
-		"schema-validation",
-		"adonisjs",
-		"adonisjs-validator"
-	],
-	"license": "MIT",
 	"author": "virk,adonisjs",
+	"license": "MIT",
+	"homepage": "https://github.com/adonisjs/validator#readme",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/adonisjs/validator.git"
 	},
 	"bugs": {
 		"url": "https://github.com/adonisjs/validator/issues"
 	},
-	"homepage": "https://github.com/adonisjs/validator#readme",
+	"keywords": [
+		"validator",
+		"schema-validation",
+		"adonisjs",
+		"adonisjs-validator"
+	],
+	"eslintConfig": {
+		"extends": "@adonisjs/eslint-config/package"
+	},
+	"prettier": "@adonisjs/prettier-config",
 	"commitlint": {
 		"extends": [
 			"@commitlint/config-conventional"
@@ -116,9 +120,5 @@
 			"test_factories/**",
 			".yalc/**"
 		]
-	},
-	"eslintConfig": {
-		"extends": "@adonisjs/eslint-config/package"
-	},
-	"prettier": "@adonisjs/prettier-config"
+	}
 }

src/schema/index.ts

@@ -118,6 +118,28 @@ number.nullableAndOptional = function nullableAndOptionalNumber(rules?: Rule[])
   >
 }
 
+/**
+ * bigint schema type
+ */
+function bigint(rules?: Rule[]) {
+  return getLiteralType('bigint', false, false, undefined, rules || []) as ReturnType<BigIntType>
+}
+bigint.optional = function optionalBigInt(rules?: Rule[]) {
+  return getLiteralType('bigint', true, false, undefined, rules || []) as ReturnType<
+    BigIntType['optional']
+  >
+}
+bigint.nullable = function nullableBigInt(rules?: Rule[]) {
+  return getLiteralType('bigint', false, true, undefined, rules || []) as ReturnType<
+    BigIntType['nullable']
+  >
+}
+bigint.nullableAndOptional = function nullableAndOptionalBigInt(rules?: Rule[]) {
+  return getLiteralType('bigint', true, true, undefined, rules || []) as ReturnType<
+    BigIntType['nullableAndOptional']
+  >
+}
+
 /**
  * Date schema type
  */
@@ -385,6 +407,7 @@ export const schema: Schema = {
   string,
   boolean,
   number,
+  bigint,
   date,
   object,
   array,

src/validations/primitives/number.ts

@@ -47,6 +47,11 @@ export const number: SyncValidation = {
       return
     }
 
+    if (castedValue === Infinity || castedValue === -Infinity) {
+      errorReporter.report(pointer, RULE_NAME, DEFAULT_MESSAGE, arrayExpressionPointer)
+      return
+    }
+
     /**
      * Mutate the value
      */

tests/schema.spec.ts

@@ -475,6 +475,116 @@ test.group('Schema | Number', () => {
   })
 })
 
+test.group('Schema | BigInt', () => {
+  test('define schema with bigint rule', ({ assert }) => {
+    assert.deepEqual(
+      schema.create({
+        username: schema.bigint(),
+      }).tree,
+      {
+        username: {
+          type: 'literal',
+          subtype: 'bigint',
+          optional: false,
+          nullable: false,
+          rules: [
+            {
+              name: 'required',
+              allowUndefineds: true,
+              async: false,
+              compiledOptions: [],
+            },
+            {
+              name: 'bigint',
+              allowUndefineds: false,
+              async: false,
+              compiledOptions: [],
+            },
+          ],
+        },
+      }
+    )
+  })
+
+  test('define schema with optional bigint rule', ({ assert }) => {
+    assert.deepEqual(
+      schema.create({
+        username: schema.bigint.optional(),
+      }).tree,
+      {
+        username: {
+          type: 'literal',
+          subtype: 'bigint',
+          optional: true,
+          nullable: false,
+          rules: [
+            {
+              name: 'bigint',
+              allowUndefineds: false,
+              async: false,
+              compiledOptions: [],
+            },
+          ],
+        },
+      }
+    )
+  })
+
+  test('define schema with nullable bigint rule', ({ assert }) => {
+    assert.deepEqual(
+      schema.create({
+        username: schema.bigint.nullable(),
+      }).tree,
+      {
+        username: {
+          type: 'literal',
+          subtype: 'bigint',
+          optional: false,
+          nullable: true,
+          rules: [
+            {
+              name: 'nullable',
+              allowUndefineds: true,
+              async: false,
+              compiledOptions: [],
+            },
+            {
+              name: 'bigint',
+              allowUndefineds: false,
+              async: false,
+              compiledOptions: [],
+            },
+          ],
+        },
+      }
+    )
+  })
+
+  test('define schema with both optional and nullable bigint rule', ({ assert }) => {
+    assert.deepEqual(
+      schema.create({
+        username: schema.bigint.nullableAndOptional(),
+      }).tree,
+      {
+        username: {
+          type: 'literal',
+          subtype: 'bigint',
+          optional: true,
+          nullable: true,
+          rules: [
+            {
+              name: 'bigint',
+              allowUndefineds: false,
+              async: false,
+              compiledOptions: [],
+            },
+          ],
+        },
+      }
+    )
+  })
+})
+
 test.group('Schema | Date', () => {
   test('define schema with date rule', ({ assert }) => {
     assert.deepEqual(

tests/validations/number.spec.ts

@@ -21,6 +21,33 @@ function compile() {
 test.group('Number', () => {
   validate(number, test, 'helloworld', 10, compile())
 
+  test('report error when value is near Infinity', ({ assert }) => {
+    const reporter = new ApiErrorReporter(new MessagesBag({}), false)
+    number.validate(
+      '-3177777777777777777777777777777777777777777777777777777777777777777777777770000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111',
+      compile().compiledOptions,
+      {
+        errorReporter: reporter,
+        field: 'age',
+        pointer: 'age',
+        tip: {},
+        root: {},
+        refs: {},
+        mutate: () => {},
+      }
+    )
+
+    assert.deepEqual(reporter.toJSON(), {
+      errors: [
+        {
+          field: 'age',
+          rule: 'number',
+          message: 'number validation failed',
+        },
+      ],
+    })
+  })
+
   test('report error when value is not a valid number', ({ assert }) => {
     const reporter = new ApiErrorReporter(new MessagesBag({}), false)
     number.validate(null, compile().compiledOptions, {