after date validation not working properly on production environment

[leocabeza]

On my local environment, date validation works as expected, but on my prod environment. I get an deliveryDate.after validation error (on a flashMessage).

I'm guessing it has something to do with the date being localized. But I can't figure out why it's working in my local env and not on my production server, It's being sent by the form in this format: "dd/MM/YYYY".

Any pointers or any more info you need, just let me know. Thanks in advance.

Here's the code:

// Model:

import { DateTime } from 'luxon'
import {
  BaseModel,
  beforeSave,
  column,
  computed,
} from '@ioc:Adonis/Lucid/Orm'

export default class Order extends BaseModel {
  @column({ isPrimary: true })
  public id: number

  @column.date()
  public deliveryDate: DateTime

  @beforeSave()
  public static async formatDate(order: Order) {
    if (order.$dirty.deliveryDate) {
      order.deliveryDate = DateTime.fromFormat(order.$dirty.deliveryDate, 'dd/MM/yyyy', {
        locale: 'es-CO',
      }).setLocale('en-US')
    }
  }
}

// View:

@layout('layouts/main')

@set('title', 'Nueva órden')

@section('main')
  @if(flashMessages.has('success'))
    <div class="notification is-success">
      <button class="delete"></button>
      {{ flashMessages.get('success') }}
    </div>
  @endif

  <form class="box" action="{{ route('OrdersController.store') }}" method="POST">
    {{ csrfField() }}

    <div class="field {{flashMessages.has('errors.deliveryDate') ? 'errored' : ''}}">
      <label for="deliveryDate" class="label">Fecha de entrega</label>
      <div class="control">
        <input
          id="deliveryDate"
          type="date"
          class="input {{flashMessages.has('errors.deliveryDate') ? 'is-danger' : ''}}"
          name="deliveryDate"
          value="{{ flashMessages.get('deliveryDate') || '' }}"
        />

        @if(flashMessages.has('errors.deliveryDate'))
          <p class="help is-danger">{{flashMessages.get('errors.deliveryDate')}}</p>
        @end
      </div>
    </div>
    <div class="field is-grouped is-grouped-right">
      <p class="control">
        <button class="button is-primary" type="submit">
          <span class="icon-text">
            <span class="icon">
              <ion-icon name="save"></ion-icon>
            </span>
            <span>Guardar</span>
          </span>
        </button>
      </p>
    </div>
  </form>
@end

// Controller:

export default class OrdersController {
  private orderValidation = {
    messages: {
      'deliveryDate.after': 'La fecha de entrega debe ser mayor al día de hoy',
      'deliveryDate.required': 'La fecha de entrega es requerida',
    },
    schema: schema.create({
      deliveryDate: schema.date(
        {
          format: 'dd/MM/yyyy',
        },
        [rules.after('today')]
      ),
    }),
  }

  public async store({ request, response, session }: HttpContextContract) {
    /* This is all because I can't add a custom array validator rule */
    /* That implementation is not in this code for simplicity purposes */
    let payload = {}
    session.flashExcept(['_csrf'])

    try {
      await request.validate(this.orderValidation)
    } catch (error) {
      payload = error.messages
    }

    const orderBody = request.only([
      'deliveryDate',
    ])

    if (Object.values(payload).length > 0) {
      session.flash({
        errors: payload,
      })
      response.redirect().toRoute('orders.create')
      return
    }

    const order = await Order.create(orderBody)

    session.flash('success', '¡La Órden fue creada con éxito!')
    response.redirect().toRoute('orders.show', { id: order.id })
  }
}

// Kernel:

/*
|--------------------------------------------------------------------------
| Application middleware
|--------------------------------------------------------------------------
|
| This file is used to define middleware for HTTP requests. You can register
| middleware as a `closure` or an IoC container binding. The bindings are
| preferred, since they keep this file clean.
|
*/

import Server from '@ioc:Adonis/Core/Server'

/*
|--------------------------------------------------------------------------
| Global middleware
|--------------------------------------------------------------------------
|
| An array of global middleware, that will be executed in the order they
| are defined for every HTTP requests.
|
*/
Server.middleware.register([
  () => import('@ioc:Adonis/Core/BodyParser'),
  () => import('@ioc:Adonis/Addons/Shield'),
  () => import('App/Middleware/DetectUserLocale'),
])

/*
|--------------------------------------------------------------------------
| Named middleware
|--------------------------------------------------------------------------
|
| Named middleware are defined as key-value pair. The value is the namespace
| or middleware function and key is the alias. Later you can use these
| alias on individual routes. For example:
|
| { auth: () => import('App/Middleware/Auth') }
|
| and then use it as follows
|
| Route.get('dashboard', 'UserController.dashboard').middleware('auth')
|
*/
Server.middleware.registerNamed({})

/* Auth related middleware */
Server.middleware.registerNamed({
  auth: () => import('App/Middleware/Auth'),
})

// Bodyparser

/**
 * Config source: https://git.io/Jfefn
 *
 * Feel free to let us know via PR, if you find something broken in this config
 * file.
 */

import { BodyParserConfig } from '@ioc:Adonis/Core/BodyParser'

const bodyParserConfig: BodyParserConfig = {
  /*
  |--------------------------------------------------------------------------
  | White listed methods
  |--------------------------------------------------------------------------
  |
  | HTTP methods for which body parsing must be performed. It is a good practice
  | to avoid body parsing for `GET` requests.
  |
  */
  whitelistedMethods: ['POST', 'PUT', 'PATCH', 'DELETE'],

  /*
  |--------------------------------------------------------------------------
  | JSON parser settings
  |--------------------------------------------------------------------------
  |
  | The settings for the JSON parser. The types defines the request content
  | types which gets processed by the JSON parser.
  |
  */
  json: {
    encoding: 'utf-8',
    limit: '1mb',
    strict: true,
    types: [
      'application/json',
      'application/json-patch+json',
      'application/vnd.api+json',
      'application/csp-report',
    ],
  },

  /*
  |--------------------------------------------------------------------------
  | Form parser settings
  |--------------------------------------------------------------------------
  |
  | The settings for the `application/x-www-form-urlencoded` parser. The types
  | defines the request content types which gets processed by the form parser.
  |
  */
  form: {
    encoding: 'utf-8',
    limit: '1mb',
    queryString: {},

    /*
    |--------------------------------------------------------------------------
    | Convert empty strings to null
    |--------------------------------------------------------------------------
    |
    | Convert empty form fields to null. HTML forms results in field string
    | value when the field is left blank. This option normalizes all the blank
    | field values to "null"
    |
    */
    convertEmptyStringsToNull: true,

    types: ['application/x-www-form-urlencoded'],
  },

  /*
  |--------------------------------------------------------------------------
  | Raw body parser settings
  |--------------------------------------------------------------------------
  |
  | Raw body just reads the request body stream as a plain text, which you
  | can process by hand. This must be used when request body type is not
  | supported by the body parser.
  |
  */
  raw: {
    encoding: 'utf-8',
    limit: '1mb',
    queryString: {},
    types: ['text/*'],
  },

  /*
  |--------------------------------------------------------------------------
  | Multipart parser settings
  |--------------------------------------------------------------------------
  |
  | The settings for the `multipart/form-data` parser. The types defines the
  | request content types which gets processed by the form parser.
  |
  */
  multipart: {
    /*
    |--------------------------------------------------------------------------
    | Auto process
    |--------------------------------------------------------------------------
    |
    | The auto process option will process uploaded files and writes them to
    | the `tmp` folder. You can turn it off and then manually use the stream
    | to pipe stream to a different destination.
    |
    | It is recommended to keep `autoProcess=true`. Unless you are processing bigger
    | file sizes.
    |
    */
    autoProcess: true,

    /*
    |--------------------------------------------------------------------------
    | Files to be processed manually
    |--------------------------------------------------------------------------
    |
    | You can turn off `autoProcess` for certain routes by defining
    | routes inside the following array.
    |
    | NOTE: Make sure the route pattern starts with a leading slash.
    |
    | Correct
    | ```js
    | /projects/:id/file
    | ```
    |
    | Incorrect
    | ```js
    | projects/:id/file
    | ```
    */
    processManually: [],

    /*
    |--------------------------------------------------------------------------
    | Temporary file name
    |--------------------------------------------------------------------------
    |
    | When auto processing is on. We will use this method to compute the temporary
    | file name. AdonisJs will compute a unique `tmpPath` for you automatically,
    | However, you can also define your own custom method.
    |
    */
    // tmpFileName () {
    // },

    /*
    |--------------------------------------------------------------------------
    | Encoding
    |--------------------------------------------------------------------------
    |
    | Request body encoding
    |
    */
    encoding: 'utf-8',

    /*
    |--------------------------------------------------------------------------
    | Convert empty strings to null
    |--------------------------------------------------------------------------
    |
    | Convert empty form fields to null. HTML forms results in field string
    | value when the field is left blank. This option normalizes all the blank
    | field values to "null"
    |
    */
    convertEmptyStringsToNull: true,

    /*
    |--------------------------------------------------------------------------
    | Max Fields
    |--------------------------------------------------------------------------
    |
    | The maximum number of fields allowed in the request body. The field includes
    | text inputs and files both.
    |
    */
    maxFields: 1000,

    /*
    |--------------------------------------------------------------------------
    | Request body limit
    |--------------------------------------------------------------------------
    |
    | The total limit to the multipart body. This includes all request files
    | and fields data.
    |
    */
    limit: '20mb',

    /*
    |--------------------------------------------------------------------------
    | Types
    |--------------------------------------------------------------------------
    |
    | The types that will be considered and parsed as multipart body.
    |
    */
    types: ['multipart/form-data'],
  },
}

export default bodyParserConfig

[leocabeza]

I ended up using:

deliveryDate: schema.date(
      {
        format: 'dd/MM/yyyy',
      },
      [rules.afterOrEqual('today')]
    ),