Class VineDate

VineDate represents a Date object created by parsing a string or number value as a date. It accepts various date formats and converts them to JavaScript Date objects, with comprehensive validation rules for date comparisons and ranges.

Example

const schema = vine.date()
  .after('today')
  .before('2025-12-31')

const result = await vine.validate({
  schema,
  data: '2025-06-15'
})

Hierarchy (View Summary)

BaseLiteralType<
    string
    | number,
    VineGlobalTransforms extends { date: infer D } ? D : Date,
    VineGlobalTransforms extends { date: infer D } ? D : Date,
>
- VineDate

Constructors

constructor

new VineDate(
options?: Partial<FieldOptions> & DateFieldOptions,
validations?: Validation<any>[],
): VineDate
Creates a new VineDate instance with optional configuration.
Parameters
- Optionaloptions: Partial<FieldOptions> & DateFieldOptions
  Field options including date formats and nullability
- Optionalvalidations: Validation<any>[]
  Initial set of validations to apply
Returns VineDate
Overrides BaseLiteralType.constructor
- Defined in src/schema/date/main.ts:125

Properties

[ITYPE]

"[ITYPE]": string | number

Define the input type of the schema for TypeScript inference

[OTYPE]

"[OTYPE]": Date

The output value type of the field after validation. The property points to a type only and not the real value.

[COTYPE]

"[COTYPE]": Date

Type marker for camelCase output type inference

`Optional`dataTypeValidator

dataTypeValidator?: Validation<any>

The validation to use for validating the schema data type. Using a data type validator guards custom rules to only run when the data type validation passes.

Example

class StringSchema extends BaseLiteralType {
  dataTypeValidator = stringDataTypeRule
}

`Static`rules

rules: {
    equals: (
        ...options: [
            options: { expectedValue: string
            | ((field: FieldContext) => string) } & DateEqualsOptions,
        ],
    ) => Validation<
        { expectedValue: string
        | ((field: FieldContext) => string) } & DateEqualsOptions,
    >;
    after: (
        ...options: [
            options: {
                expectedValue: | string & { _?: undefined }
                | "today"
                | "tomorrow"
                | ((field: FieldContext) => string);
            } & DateEqualsOptions,
        ],
    ) => Validation<
        {
            expectedValue: | string & { _?: undefined }
            | "today"
            | "tomorrow"
            | ((field: FieldContext) => string);
        } & DateEqualsOptions,
    >;
    afterOrEqual: (
        ...options: [
            options: {
                expectedValue: | "today"
                | "tomorrow"
                | string & { _?: undefined }
                | ((field: FieldContext) => string);
            } & DateEqualsOptions,
        ],
    ) => Validation<
        {
            expectedValue: | "today"
            | "tomorrow"
            | string & { _?: undefined }
            | ((field: FieldContext) => string);
        } & DateEqualsOptions,
    >;
    before: (
        ...options: [
            options: {
                expectedValue: | "today"
                | string & { _?: undefined }
                | "yesterday"
                | ((field: FieldContext) => string);
            } & DateEqualsOptions,
        ],
    ) => Validation<
        {
            expectedValue: | "today"
            | string & { _?: undefined }
            | "yesterday"
            | ((field: FieldContext) => string);
        } & DateEqualsOptions,
    >;
    beforeOrEqual: (
        ...options: [
            options: {
                expectedValue: | "today"
                | "yesterday"
                | string & { _?: undefined }
                | ((field: FieldContext) => string);
            } & DateEqualsOptions,
        ],
    ) => Validation<
        {
            expectedValue: | "today"
            | "yesterday"
            | string & { _?: undefined }
            | ((field: FieldContext) => string);
        } & DateEqualsOptions,
    >;
    sameAs: (
        ...options: [options: { otherField: string } & DateEqualsOptions],
    ) => Validation<{ otherField: string } & DateEqualsOptions>;
    notSameAs: (
        ...options: [options: { otherField: string } & DateEqualsOptions],
    ) => Validation<{ otherField: string } & DateEqualsOptions>;
    afterField: (
        ...options: [options: { otherField: string } & DateEqualsOptions],
    ) => Validation<{ otherField: string } & DateEqualsOptions>;
    afterOrSameAs: (
        ...options: [options: { otherField: string } & DateEqualsOptions],
    ) => Validation<{ otherField: string } & DateEqualsOptions>;
    beforeField: (
        ...options: [options: { otherField: string } & DateEqualsOptions],
    ) => Validation<{ otherField: string } & DateEqualsOptions>;
    beforeOrSameAs: (
        ...options: [options: { otherField: string } & DateEqualsOptions],
    ) => Validation<{ otherField: string } & DateEqualsOptions>;
    weekend: (...options: [options?: undefined]) => Validation<undefined>;
    weekday: (...options: [options?: undefined]) => Validation<undefined>;
} = ...

Static collection of all available validation rules for dates

[UNIQUE_NAME]

"[UNIQUE_NAME]": string = 'vine.date'

Unique name identifier for union type resolution

[SUBTYPE]

"[SUBTYPE]": string = 'date'

The subtype identifier for the literal schema field

options

options: FieldOptions & DateFieldOptions

Configuration options for this field including bail mode, nullability, and parsing

Methods

toJSONSchema

toJSONSchema(): JSONSchema7
Transforms your schema type into JSONSchema7

Returns JSONSchema7
Inherited from BaseLiteralType.toJSONSchema
- Defined in src/schema/base/literal.ts:661

parse

parse(callback: ParseFn): this
Define a method to parse the input value. The method is invoked before any validation and hence you must perform type-checking to know the value you are working it.
Parameters
- callback: ParseFn
Returns this
Inherited from BaseLiteralType.parse
- Defined in src/schema/base/literal.ts:684

use

use(validation: Validation<any> | RuleBuilder): this
Adds a validation rule to the schema's validation chain. Rules are executed in the order they are added.
Parameters
- validation: Validation<any> | RuleBuilder
  The validation rule or rule builder to add
Returns this
This schema instance for method chaining
Example
```
vine.string().use(minLength({ length: 3 }))
vine.number().use(customRule({ strict: true }))
```
Inherited from BaseLiteralType.use
- Defined in src/schema/base/literal.ts:700

bail

bail(state: boolean): VineDate
Enable/disable bail mode for this field. In bail mode, field validations stop after the first error.
Parameters
- state: boolean
  Whether to enable bail mode
Returns VineDate
This schema instance for method chaining
Example
```
vine.string().bail(false) // Continue validation after first error
vine.number().bail(true)  // Stop after first error (default)
```
Inherited from BaseLiteralType.bail
- Defined in src/schema/base/literal.ts:716

optional

optional(): OptionalModifier<VineDate>
Mark the field under validation as optional. An optional field allows both null and undefined values.

Returns OptionalModifier<VineDate>
Inherited from BaseLiteralType.optional
- Defined in src/schema/base/literal.ts:725

nullable

nullable(): NullableModifier<VineDate>
Mark the field under validation to be null. The null value will be written to the output as well.

If optional and nullable are used together, then both undefined and null values will be allowed.

Returns NullableModifier<VineDate>
Inherited from BaseLiteralType.nullable
- Defined in src/schema/base/literal.ts:736

transform

transform<TransformedOutput>(
transformer: Transformer<VineDate, TransformedOutput>,
): TransformModifier<VineDate, TransformedOutput>
Apply transform on the final validated value. The transform method may convert the value to any new datatype.
Type Parameters
- TransformedOutput
Parameters
- transformer: Transformer<VineDate, TransformedOutput>
Returns TransformModifier<VineDate, TransformedOutput>
Inherited from BaseLiteralType.transform
- Defined in src/schema/base/literal.ts:752

[PARSE]

"[PARSE]"(
    propertyName: string,
    refs: RefsStore,
    options: ParserOptions,
): FieldNode & {} & { subtype: string }
Compiles the literal schema type into a compiler node. This method transforms the schema definition into a format that the validation compiler can process.
Parameters
- propertyName: string
  Name of the property being compiled
- refs: RefsStore
  Reference store for the compiler
- options: ParserOptions
  Parser options including camelCase conversion
Returns FieldNode & {} & { subtype: string }
Compiled literal node with subtype information
Inherited from BaseLiteralType.[PARSE]
- Defined in src/schema/base/literal.ts:768

`Static`transform

transform(transformer: (value: Date) => Date): void
Sets a global transformer function for all date values. The transformer is applied to every validated date value.
Parameters
- transformer: (value: Date) => Date
  Function that transforms a Date object to a custom type
Returns void
Example
```
VineDate.transform((value) => value.toISOString())
```
- Defined in src/schema/date/main.ts:68

[IS_OF_TYPE]

"[IS_OF_TYPE]"(value: unknown): boolean
Type checker function to determine if a value can be parsed as a date. Required for "unionOfTypes" functionality.
Parameters
- value: unknown
  The value to check
Returns boolean
True if the value can be parsed as a valid date
- Defined in src/schema/date/main.ts:110

equals

equals(
expectedValue: string | ((field: FieldContext) => string),
options?: DateEqualsOptions,
): this
Validates the date to be equal to the expected value. By default, compares day, month, and year.
Parameters
- expectedValue: string | ((field: FieldContext) => string)
  The expected date value or 'today'
- Optionaloptions: DateEqualsOptions
  Comparison options (compare unit and format)
Returns this
This date schema instance for method chaining
Example
```
vine.date().equals('2025-01-01')
vine.date().equals('today')
vine.date().equals('2025-01-01', { compare: 'month' })
```
- Defined in src/schema/date/main.ts:143

after

after(
    expectedValue:
        | "today"
        | "tomorrow"
        | string & { _?: undefined }
        | ((field: FieldContext) => string),
    options?: DateEqualsOptions,
): this
Validates the date to be after the expected value. By default, compares day, month, and year.
Parameters
- expectedValue:
      | "today"
      | "tomorrow"
      | string & { _?: undefined }
      | ((field: FieldContext) => string)
  The expected date value, 'today', or 'tomorrow'
- Optionaloptions: DateEqualsOptions
  Comparison options (compare unit and format)
Returns this
This date schema instance for method chaining
Example
```
vine.date().after('today')
vine.date().after('2025-01-01')
vine.date().after('tomorrow', { compare: 'hour' })
```
- Defined in src/schema/date/main.ts:163

afterOrEqual

afterOrEqual(
    expectedValue:
        | "today"
        | "tomorrow"
        | string & { _?: undefined }
        | ((field: FieldContext) => string),
    options?: DateEqualsOptions,
): this
Validates the date to be after or equal to the expected value. By default, compares day, month, and year.
Parameters
- expectedValue:
      | "today"
      | "tomorrow"
      | string & { _?: undefined }
      | ((field: FieldContext) => string)
  The expected date value, 'today', or 'tomorrow'
- Optionaloptions: DateEqualsOptions
  Comparison options (compare unit and format)
Returns this
This date schema instance for method chaining
Example
```
vine.date().afterOrEqual('today')
vine.date().afterOrEqual('2025-01-01')
```
- Defined in src/schema/date/main.ts:186

before

before(
    expectedValue:
        | "today"
        | "yesterday"
        | string & { _?: undefined }
        | ((field: FieldContext) => string),
    options?: DateEqualsOptions,
): this
Validates the date to be before the expected value. By default, compares day, month, and year.
Parameters
- expectedValue:
      | "today"
      | "yesterday"
      | string & { _?: undefined }
      | ((field: FieldContext) => string)
  The expected date value, 'today', or 'yesterday'
- Optionaloptions: DateEqualsOptions
  Comparison options (compare unit and format)
Returns this
This date schema instance for method chaining
Example
```
vine.date().before('today')
vine.date().before('2025-12-31')
vine.date().before('yesterday')
```
- Defined in src/schema/date/main.ts:210

beforeOrEqual

beforeOrEqual(
    expectedValue:
        | "today"
        | "yesterday"
        | string & { _?: undefined }
        | ((field: FieldContext) => string),
    options?: DateEqualsOptions,
): this
Validates the date to be before or equal to the expected value. By default, compares day, month, and year.
Parameters
- expectedValue:
      | "today"
      | "yesterday"
      | string & { _?: undefined }
      | ((field: FieldContext) => string)
  The expected date value, 'today', or 'yesterday'
- Optionaloptions: DateEqualsOptions
  Comparison options (compare unit and format)
Returns this
This date schema instance for method chaining
Example
```
vine.date().beforeOrEqual('today')
vine.date().beforeOrEqual('2025-12-31')
```
- Defined in src/schema/date/main.ts:233

sameAs

sameAs(otherField: string, options?: DateEqualsOptions): this
Validates the date to be equal to another field's value. By default, compares day, month, and year.
Parameters
- otherField: string
  The name of the other field to compare with
- Optionaloptions: DateEqualsOptions
  Comparison options (compare unit and format)
Returns this
This date schema instance for method chaining
Example
```
vine.date().sameAs('startDate')
vine.date().sameAs('birthDate', { compare: 'month' })
```
- Defined in src/schema/date/main.ts:256

notSameAs

notSameAs(otherField: string, options?: DateEqualsOptions): this
Validates the date to be different from another field's value. By default, compares day, month, and year.
Parameters
- otherField: string
  The name of the other field to compare with
- Optionaloptions: DateEqualsOptions
  Comparison options (compare unit and format)
Returns this
This date schema instance for method chaining
Example
```
vine.date().notSameAs('endDate')
vine.date().notSameAs('previousDate')
```
- Defined in src/schema/date/main.ts:272

afterField

afterField(otherField: string, options?: DateEqualsOptions): this
Validates the date to be after another field's value. By default, compares day, month, and year.
Parameters
- otherField: string
  The name of the other field to compare with
- Optionaloptions: DateEqualsOptions
  Comparison options (compare unit and format)
Returns this
This date schema instance for method chaining
Example
```
vine.date().afterField('startDate')
vine.date().afterField('createdAt', { compare: 'minute' })
```
- Defined in src/schema/date/main.ts:288

afterOrSameAs

afterOrSameAs(otherField: string, options?: DateEqualsOptions): this
Validates the date to be after or equal to another field's value. By default, compares day, month, and year.
Parameters
- otherField: string
  The name of the other field to compare with
- Optionaloptions: DateEqualsOptions
  Comparison options (compare unit and format)
Returns this
This date schema instance for method chaining
Example
```
vine.date().afterOrSameAs('startDate')
```
- Defined in src/schema/date/main.ts:303

beforeField

beforeField(otherField: string, options?: DateEqualsOptions): this
Validates the date to be before another field's value. By default, compares day, month, and year.
Parameters
- otherField: string
  The name of the other field to compare with
- Optionaloptions: DateEqualsOptions
  Comparison options (compare unit and format)
Returns this
This date schema instance for method chaining
Example
```
vine.date().beforeField('endDate')
vine.date().beforeField('expiresAt')
```
- Defined in src/schema/date/main.ts:319

beforeOrSameAs

beforeOrSameAs(otherField: string, options?: DateEqualsOptions): this
Validates the date to be before or equal to another field's value. By default, compares day, month, and year.
Parameters
- otherField: string
  The name of the other field to compare with
- Optionaloptions: DateEqualsOptions
  Comparison options (compare unit and format)
Returns this
This date schema instance for method chaining
Example
```
vine.date().beforeOrSameAs('endDate')
```
- Defined in src/schema/date/main.ts:334

weekend

weekend(): this
Validates the date to fall on a weekend (Saturday or Sunday).

Returns this
This date schema instance for method chaining
Example
```
vine.date().weekend()
```
- Defined in src/schema/date/main.ts:346

weekday

weekday(): this
Validates the date to fall on a weekday (Monday to Friday).

Returns this
This date schema instance for method chaining
Example
```
vine.date().weekday()
```
- Defined in src/schema/date/main.ts:358

clone

clone(): this
Clones the VineDate schema type. The applied options and validations are copied to the new instance.

Returns this
A cloned instance of this VineDate schema
Overrides BaseLiteralType.clone
- Defined in src/schema/date/main.ts:368

Class VineDate

Example

Hierarchy (View Summary)

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns VineDate

Properties

[ITYPE]

[OTYPE]

[COTYPE]

OptionaldataTypeValidator

Example

Staticrules

[UNIQUE_NAME]

[SUBTYPE]

options

Methods

toJSONSchema

Returns JSONSchema7

parse

Parameters

Returns this

use

Parameters

Returns this

Example

bail

Parameters

Returns VineDate

Example

optional

Returns OptionalModifier<VineDate>

nullable

Returns NullableModifier<VineDate>

meta

Parameters

Returns MetaModifier<VineDate>

transform

Type Parameters

Parameters

Returns TransformModifier<VineDate, TransformedOutput>

[PARSE]

Parameters

Returns FieldNode & {} & { subtype: string }

Statictransform

Parameters

Returns void

Example

[IS_OF_TYPE]

Parameters

Returns boolean

equals

Parameters

Returns this

Example

after

Parameters

Returns this

Example

afterOrEqual

Parameters

Returns this

Example

before

Parameters

Returns this

Example

beforeOrEqual

Parameters

Returns this

Example

sameAs

Parameters

Returns this

Example

`Optional`dataTypeValidator

`Static`rules

`Static`transform