feat: add bigint type validation

Author: MaximeMRF

adonis-typings/validator.ts

@@ -388,6 +388,28 @@ declare module '@ioc:Adonis/Core/Validator' {
     }
   }
 
+  /**
+   * Signature to define a bigint or bigint number type
+   */
+  export interface BigIntType {
+    (rules?: Rule[]): {
+      t: bigint
+      getTree(): SchemaLiteral
+    }
+    optional(rules?: Rule[]): {
+      t?: bigint
+      getTree(): SchemaLiteral
+    }
+    nullable(rules?: Rule[]): {
+      t: bigint | null
+      getTree(): SchemaLiteral
+    }
+    nullableAndOptional(rules?: Rule[]): {
+      t?: bigint | null
+      getTree(): SchemaLiteral
+    }
+  }
+
   /**
    * Signature to define an object with members or an optional object
    * with members.
@@ -640,6 +662,7 @@ declare module '@ioc:Adonis/Core/Validator' {
     string: StringType
     boolean: BooleanType
     number: NumberType
+    bigint: BigIntType
     date: DateType
     enum: EnumType
     enumSet: EnumSetType

src/Schema/index.ts

@@ -20,6 +20,7 @@ import {
   StringType,
   ObjectType,
   NumberType,
+  BigIntType,
   EnumSetType,
   BooleanType,
   TypedSchema,
@@ -117,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
  */
@@ -359,6 +382,7 @@ export const schema: Schema = {
   string,
   boolean,
   number,
+  bigint,
   date,
   object,
   array,

src/Validations/index.ts

@@ -41,6 +41,7 @@ export { oneOf as enum } from './primitives/enum'
 export { enumSet } from './primitives/enumSet'
 export { file } from './primitives/file'
 export { number } from './primitives/number'
+export { bigint } from './primitives/bigint'
 export { object } from './primitives/object'
 export { string } from './primitives/string'
 

src/Validations/primitives/bigint.ts

@@ -0,0 +1,55 @@
+/*
+ * @adonisjs/validator
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { SyncValidation } from '@ioc:Adonis/Core/Validator'
+import { wrapCompile } from '../../Validator/helpers'
+
+const DEFAULT_MESSAGE = 'bigint validation failed'
+const RULE_NAME = 'bigint'
+
+/**
+ * Ensure the value is a valid bigint. Numeric string will be casted
+ * to valid bigint
+ */
+export const bigint: SyncValidation = {
+  compile: wrapCompile(RULE_NAME),
+  validate(value, _, { mutate, errorReporter, pointer, arrayExpressionPointer }) {
+    if (typeof value === 'bigint') {
+      return
+    }
+
+    /**
+     * Report error when value is not a bigint and neither a string
+     */
+    if (typeof value !== 'string') {
+      errorReporter.report(pointer, RULE_NAME, DEFAULT_MESSAGE, arrayExpressionPointer)
+      return
+    }
+
+    /**
+     * Attempt to cast bigint like string to a bigint. In case of
+     * failure report the validation error
+     */
+    const castedValue = Number(value)
+    if (isNaN(castedValue)) {
+      errorReporter.report(pointer, RULE_NAME, DEFAULT_MESSAGE, arrayExpressionPointer)
+      return
+    }
+
+    if (castedValue === Infinity || castedValue === -Infinity) {
+      errorReporter.report(pointer, RULE_NAME, DEFAULT_MESSAGE, arrayExpressionPointer)
+      return
+    }
+
+    /**
+     * Mutate the value
+     */
+    mutate(castedValue)
+  },
+}

test/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(

test/validations/bigint.spec.ts

@@ -0,0 +1,131 @@
+/*
+ * @adonisjs/validator
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { test } from '@japa/runner'
+import { rules } from '../../src/Rules'
+import { validate } from '../fixtures/rules/index'
+import { MessagesBag } from '../../src/MessagesBag'
+import { ApiErrorReporter } from '../../src/ErrorReporter'
+import { bigint } from '../../src/Validations/primitives/bigint'
+
+function compile() {
+  return bigint.compile('literal', 'bigint', rules['bigint']().options, {})
+}
+
+test.group('BigInt', () => {
+  validate(bigint, test, 'helloworld', 10n, compile())
+
+  test('report error when value is near Infinity', ({ assert }) => {
+    const reporter = new ApiErrorReporter(new MessagesBag({}), false)
+    bigint.validate(
+      '-3177777777777777777777777777777777777777777777777777777777777777777777777770000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111',
+      compile().compiledOptions,
+      {
+        errorReporter: reporter,
+        field: 'age',
+        pointer: 'age',
+        tip: {},
+        root: {},
+        refs: {},
+        mutate: () => {},
+      }
+    )
+
+    assert.deepEqual(reporter.toJSON(), {
+      errors: [
+        {
+          field: 'age',
+          rule: 'bigint',
+          message: 'bigint validation failed',
+        },
+      ],
+    })
+  })
+
+  test('report error when value is not a valid bigint', ({ assert }) => {
+    const reporter = new ApiErrorReporter(new MessagesBag({}), false)
+    bigint.validate(null, compile().compiledOptions, {
+      errorReporter: reporter,
+      field: 'age',
+      pointer: 'age',
+      tip: {},
+      root: {},
+      refs: {},
+      mutate: () => {},
+    })
+
+    assert.deepEqual(reporter.toJSON(), {
+      errors: [
+        {
+          field: 'age',
+          rule: 'bigint',
+          message: 'bigint validation failed',
+        },
+      ],
+    })
+  })
+
+  test('cast bigint like string to a valid bigint', ({ assert }) => {
+    const reporter = new ApiErrorReporter(new MessagesBag({}), false)
+    let value: any = '21'
+
+    bigint.validate(value, compile().compiledOptions, {
+      errorReporter: reporter,
+      field: 'age',
+      pointer: 'age',
+      tip: {},
+      root: {},
+      refs: {},
+      mutate: (newValue) => {
+        value = newValue
+      },
+    })
+
+    assert.deepEqual(reporter.toJSON(), { errors: [] })
+    assert.equal(value, 21n)
+  })
+
+  test('work fine when value is a valid bigint', ({ assert }) => {
+    const reporter = new ApiErrorReporter(new MessagesBag({}), false)
+    bigint.validate(21n, compile().compiledOptions, {
+      errorReporter: reporter,
+      field: 'age',
+      pointer: 'age',
+      tip: {},
+      root: {},
+      refs: {},
+      mutate: () => {},
+    })
+
+    assert.deepEqual(reporter.toJSON(), { errors: [] })
+  })
+
+  test('report error when value is a string that cannot be casted to a bigint', ({ assert }) => {
+    const reporter = new ApiErrorReporter(new MessagesBag({}), false)
+    bigint.validate('hello-world', compile().compiledOptions, {
+      errorReporter: reporter,
+      field: 'age',
+      pointer: 'age',
+      tip: {},
+      root: {},
+      refs: {},
+      mutate: () => {},
+    })
+
+    assert.deepEqual(reporter.toJSON(), {
+      errors: [
+        {
+          field: 'age',
+          rule: 'bigint',
+          message: 'bigint validation failed',
+        },
+      ],
+    })
+  })
+})