@finnair/v-validation-luxon 1.1.0-alpha.7 → 1.1.0

package/CHANGELOG.md

@@ -3,6 +3,33 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.1.0](https://github.com/finnair/v-validation/compare/v1.0.1...v1.1.0) (2022-08-29)
+
+
+### Features
+
+* Support for Luxon ([94b3806](https://github.com/finnair/v-validation/commit/94b38060e07feeb0abb8c81659d8bda537a4d9aa))
+
+
+
+
+
+# [1.1.0-alpha.9](https://github.com/finnair/v-validation/compare/v1.1.0-alpha.8...v1.1.0-alpha.9) (2022-08-19)
+
+**Note:** Version bump only for package @finnair/v-validation-luxon
+
+
+
+
+
+# [1.1.0-alpha.8](https://github.com/finnair/v-validation/compare/v1.1.0-alpha.7...v1.1.0-alpha.8) (2022-08-19)
+
+**Note:** Version bump only for package @finnair/v-validation-luxon
+
+
+
+
+
 # [1.1.0-alpha.7](https://github.com/finnair/v-validation/compare/v1.1.0-alpha.6...v1.1.0-alpha.7) (2022-08-18)
 
 **Note:** Version bump only for package @finnair/v-validation-luxon

package/README.md

@@ -4,7 +4,8 @@
 
 `@finnair/v-validation-luxon` is an extension to `@finnair/v-validation`.
 
-`Vluxon` extension uses custom wrapper types for Luxon DateTime to support full JSON roundtrip with strict validation.
+`Vluxon` extension provides custom wrapper types for Luxon DateTime to support full JSON roundtrip with strict validation.
+Also plain DateTime validators are provided and custom formats are easy to define (see the code for examples).
 
 [Documentation for `v-validation`](https://github.com/finnair/v-validation).
 
@@ -24,20 +25,67 @@ npm install @finnair/v-validation-luxon
 
 ## Vluxon
 
-`validateLuxon` functions can be used to build custom DateTime validators/converters
-by supplying a RegExp pattern and a wrapper class (subclass of LuxonDateTime).
-The wrapper class should guarantee proper `toJSON()` and other required properties
-for the type (e.g. timezone handling).
-
-Time zone 00:00 is serialized as `Z`.
-
-| Vluxon .          | Format                     | Description                                            |
-| ----------------- | -------------------------- | ------------------------------------------------------ |
-| date              | `YYYY-MM-DD`               | Local date.                                            |
-| dateUtc           | `YYYY-MM-DD`               | Date in UTC time zone.                                 |
-| dateTime          | `YYYY-MM-DDTHH:mm:ssZ`     | Date and time in local (parsed) time zone.             |
-| dateTimeUtc       | `YYYY-MM-DDTHH:mm:ssZ`     | Date and time in UTC time zone.                        |
-| dateTimeMillis    | `YYYY-MM-DDTHH:mm:ss.SSSZ` | Date and time with millis in local (parsed) time zone. |
-| dateTimeMillisUtc | `YYYY-MM-DDTHH:mm:ss.SSSZ` | Date and time with millis in UTC time zone.            |
-| time              | `HH:mm:ss`                 | Local time.                                            |
-| duration          | ISO 8601 Duration          | Luxon `Duration` with pattern validation.              |
+Vluxon contains both plain DateTime validators and also validators that return
+DateTime wrappers that guarantee some normalizations (zone, date and/or time) and
+especially JSON serialization in the given format. The wrappers are immutable and
+they allow easy access to the DateTime instance for further processing.
+`validateLuxon` function can be used to build custom DateTime validators/converters
+by supplying a RegExp pattern and a parser function.
+
+## Supported DateTime Wrapper Types
+
+| Class                  | Description                                                                                                 |
+| ---------------------- | ----------------------------------------------------------------------------------------------------------- |
+| LuxonDateTime          | Abstract base class for the wrappers.                                                                       |
+| LocalDateLuxon         | Input and JSON output in `yyyy-MM-dd` format. Time normalized to midnight UTC.                              |
+| LocalTimeLuxon         | Input and JSON output in `HH:mm:ss` format. Date normalized to 1970-01-01 UTC (Unix Epoch).                 |
+| DateTimeLuxon          | Input and JSON output in `yyyy-MM-ddTHH:mm:ssZ` format in local/given/parsed zone with milliseconds zeroed. |
+| DateTimeUtcLuxon       | Input and JSON output in `yyyy-MM-ddTHH:mm:ssZ` format in UTC zone with milliseconds zeroed.                |
+| DateTimeMillisLuxon    | Input and JSON output in `yyyy-MM-ddTHH:mm:ss.SSSZ` format in local/given/parsed zone.                      |
+| DateTimeMillisUtcLuxon | Input and JSON output in `yyyy-MM-ddTHH:mm:ss.SSSZ` format in UTC zone.                                     |
+
+### Constructors
+
+Wrapper types may be constructed with `new` from DateTime instance, but there are also shortcuts:
+
+| Static Method                                                          | Description                                                     |
+| ---------------------------------------------------------------------- | --------------------------------------------------------------- |
+| `now()`                                                                | Current time in `DateTime*` types.                              |
+| `nowUtc()`                                                             | Current UTC time in `Local*` types.                             |
+| `nowLocal(options?: DateTimeJSOptions)`                                | Current local time in `Local*` types (defaults to system zone). |
+| `fromISO(value: string, options?: DateTimeOptions)`                    | Parse from ISO format (see Luxon `DateTime.fromISO`).           |
+| `fromFormat(value: string, format: string, options?: DateTimeOptions)` | Parse from custom format (see Luxon `DateTime.fromFormat`).     |
+| `fromJSDate(date: Date, options?: { zone?: string \| Zone })`          | From JavaScript Date object (see Luxon `DateTime.fromJSDate`).  |
+| `fromMillis(millis: number, options?: DateTimeJSOptions)`              | From Unix millis timestamp (see Luxon `DateTime.fromMillis`).   |
+
+### Instance Methods
+
+Wrappers are meant to be as thin as possible with most of the DateTime functionality accessed directly from the wrapped
+DateTime instance which is public readonly fiedl. However there are a few convenience methods for working with the wrapper types:
+
+| Method                                       | Description                                                                                                        |
+| -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| `as(type)`                                   | Conversion to the given type that extends LuxonDateTime. Note that the conversion is not guaranted to be lossless. |
+| `wrap(fn: (dateTime: DateTime) => DateTime)` | Executes the given function on the wrapped DateTime and rewraps the result.                                        |
+| `apply<R>(fn: (dateTime: DateTime) => R): R` | Executes the given function on the wrapped DateTime and returns the result as it is.                               |
+| `valueOf()`                                  | Conversion to millis. This allows comparing wrapper types directly using `==`, `<`, `>`, `<=` or `>=`.             |
+| `equals(other: any)`                         | Type-aware equality.                                                                                               |
+| `toJSON()`                                   | Type-specific serialization (string).                                                                              |
+
+## Build-in Validators
+
+| Vluxon.             | Format                     | Description                                               |
+| ------------------- | -------------------------- | --------------------------------------------------------- |
+| localDate           | `yyyy-MM-dd`               | Local date (time normalized to midninght UTC).            |
+| localTime           | `HH:mm:ss`                 | Local time (date normalized to 1970-01-01).               |
+| dateTime            | `yyyy-MM-ddTHH:mm:ssZ`     | Date and time in local (parsed) time zone.                |
+| dateTimeUtc         | `yyyy-MM-ddTHH:mm:ssZ`     | Date and time in UTC time zone.                           |
+| dateTimeMillis      | `yyyy-MM-ddTHH:mm:ss.SSSZ` | Date and time with millis in local (parsed) time zone.    |
+| dateTimeMillisUtc   | `yyyy-MM-ddTHH:mm:ss.SSSZ` | Date and time with millis in UTC time zone.               |
+| dateTimeFromISO     | Any ISO                    | Plain Luxon DateTime from ISO format.                     |
+| dateTimeFromRFC2822 | RFC2822                    | Plain Luxon DateTime from RFC2822 format.                 |
+| dateTimeFromHTTP    | HTTP date-time             | Plain Luxon DateTime from HTTP format.                    |
+| dateTimeFromSQL     | SQL date-time              | Plain Luxon DateTime from SQL format.                     |
+| dateTimeFromSeconds | Unix timestamp (number)    | Plain Luxon DateTime from Unix timestamp in seconds.      |
+| dateTimeFromMillis  | Unix timestamp (number)    | Plain Luxon DateTime from Unix timestamp in milliseconds. |
+| duration            | ISO 8601 Duration          | Luxon `Duration` with pattern validation.                 |

package/dist/Vluxon.d.ts

@@ -1,6 +1,6 @@
 import { ValidationContext, Validator, ValidationResult } from '@finnair/v-validation';
 import { Path } from '@finnair/path';
-import { DateTime } from 'luxon';
+import { DateTime, DateTimeJSOptions, DateTimeOptions } from 'luxon';
 import { LuxonDateTime } from './luxon';
 export declare type LuxonInput = string | DateTime | LuxonDateTime;
 export interface ValidateLuxonParams {
@@ -8,20 +8,47 @@ export interface ValidateLuxonParams {
     path: Path;
     ctx: ValidationContext;
     type: string;
-    proto: any;
     pattern: RegExp;
-    parser: (value: string) => DateTime;
+    proto?: any;
+    parser: (value: string, match: RegExpExecArray) => DateTime;
 }
-export declare function validateLuxon({ value, path, ctx, type, proto, pattern, parser }: ValidateLuxonParams): ValidationResult;
+export declare function validateLuxon({ value, path, ctx, type, proto, pattern, parser }: ValidateLuxonParams): Promise<ValidationResult>;
+declare function localDate(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
+declare function localTime(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
+declare function dateTime(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
+declare function dateTimeUtc(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
+declare function dateTimeMillis(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
+declare function dateTimeMillisUtc(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
+declare function dateTimeFromISO(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
+declare function dateTimeFromRFC2822(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
+declare function dateTimeFromHTTP(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
+declare function dateTimeFromSQL(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
+export interface ValidateLuxonNumberParams {
+    value: any;
+    path: Path;
+    ctx: ValidationContext;
+    type: string;
+    parser: (value: number) => DateTime;
+}
+export declare function validateLuxonNumber({ value, path, ctx, type, parser }: ValidateLuxonNumberParams): Promise<ValidationResult>;
+declare function dateTimeFromMillis(options?: DateTimeJSOptions): import("@finnair/v-validation").ValidatorFnWrapper;
+declare function dateTimeFromSeconds(options?: DateTimeJSOptions): import("@finnair/v-validation").ValidatorFnWrapper;
 export declare class DurationValidator extends Validator {
     validatePath(value: any, path: Path, ctx: ValidationContext): Promise<ValidationResult>;
 }
 export declare const Vluxon: {
-    localDate: () => import("@finnair/v-validation").ValidatorFnWrapper;
-    localTime: () => import("@finnair/v-validation").ValidatorFnWrapper;
-    dateTime: () => import("@finnair/v-validation").ValidatorFnWrapper;
-    dateTimeUtc: () => import("@finnair/v-validation").ValidatorFnWrapper;
-    dateTimeMillis: () => import("@finnair/v-validation").ValidatorFnWrapper;
-    dateTimeMillisUtc: () => import("@finnair/v-validation").ValidatorFnWrapper;
+    localDate: typeof localDate;
+    localTime: typeof localTime;
+    dateTime: typeof dateTime;
+    dateTimeUtc: typeof dateTimeUtc;
+    dateTimeMillis: typeof dateTimeMillis;
+    dateTimeMillisUtc: typeof dateTimeMillisUtc;
+    dateTimeFromISO: typeof dateTimeFromISO;
+    dateTimeFromRFC2822: typeof dateTimeFromRFC2822;
+    dateTimeFromHTTP: typeof dateTimeFromHTTP;
+    dateTimeFromSQL: typeof dateTimeFromSQL;
+    dateTimeFromSeconds: typeof dateTimeFromSeconds;
+    dateTimeFromMillis: typeof dateTimeFromMillis;
     duration: () => DurationValidator;
 };
+export {};

package/dist/Vluxon.js

@@ -9,115 +9,187 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Vluxon = exports.DurationValidator = exports.validateLuxon = void 0;
+exports.Vluxon = exports.DurationValidator = exports.validateLuxonNumber = exports.validateLuxon = void 0;
 const v_validation_1 = require("@finnair/v-validation");
 const luxon_1 = require("luxon");
 const luxon_2 = require("./luxon");
 function validateLuxon({ value, path, ctx, type, proto, pattern, parser }) {
-    if ((0, v_validation_1.isNullOrUndefined)(value)) {
-        return ctx.failure(v_validation_1.defaultViolations.notNull(path), value);
-    }
-    if (value instanceof proto) {
-        return ctx.success(value);
-    }
-    else if (luxon_1.DateTime.isDateTime(value)) {
-        if (value.isValid) {
-            return ctx.success(new proto(value));
+    return __awaiter(this, void 0, void 0, function* () {
+        if ((0, v_validation_1.isNullOrUndefined)(value)) {
+            return ctx.failure(v_validation_1.defaultViolations.notNull(path), value);
         }
-    }
-    else if ((0, v_validation_1.isString)(value)) {
-        if (pattern.test(value)) {
-            const dateTime = parser(value);
-            if (dateTime.isValid) {
-                return ctx.success(new proto(dateTime));
+        if (proto && value instanceof proto) {
+            return ctx.success(value);
+        }
+        else if (luxon_1.DateTime.isDateTime(value)) {
+            if (value.isValid) {
+                return success(value);
             }
         }
-    }
-    return ctx.failure(v_validation_1.defaultViolations.date(value, path, type), value);
+        else if ((0, v_validation_1.isString)(value)) {
+            const match = pattern.exec(value);
+            if (match) {
+                const dateTime = parser(value, match);
+                if (dateTime.isValid) {
+                    return success(dateTime);
+                }
+            }
+        }
+        return ctx.failure(v_validation_1.defaultViolations.date(value, path, type), value);
+        function success(dateTime) {
+            return ctx.success(proto ? new proto(dateTime) : dateTime);
+        }
+    });
 }
 exports.validateLuxon = validateLuxon;
 const datePattern = /^\d{4}-\d{2}-\d{2}$/;
-function localDateValidator(value, path, ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return validateLuxon({
-            value,
-            path,
-            ctx,
-            type: 'Date',
-            proto: luxon_2.LocalDateLuxon,
-            pattern: datePattern,
-            parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
-        });
-    });
+function localDate(options = { setZone: true }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
+        value,
+        path,
+        ctx,
+        type: 'Date',
+        proto: luxon_2.LocalDateLuxon,
+        pattern: datePattern,
+        parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
+    }));
 }
 const timePattern = /^\d{2}:\d{2}:\d{2}$/;
-function localTimeValidator(value, path, ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return validateLuxon({
-            value,
-            path,
-            ctx,
-            type: 'Time',
-            proto: luxon_2.LocalTimeLuxon,
-            pattern: timePattern,
-            parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
-        });
-    });
+function localTime(options = { zone: luxon_1.FixedOffsetZone.utcInstance }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
+        value,
+        path,
+        ctx,
+        type: 'Time',
+        proto: luxon_2.LocalTimeLuxon,
+        pattern: timePattern,
+        parser: (value) => luxon_1.DateTime.fromISO(value, options),
+    }));
 }
 const dateTimePattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:Z|[+-]\d{2}(?::?\d{2})?)$/;
-function dateTimeValidator(value, path, ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return validateLuxon({
-            value,
-            path,
-            ctx,
-            type: 'DateTime',
-            proto: luxon_2.DateTimeLuxon,
-            pattern: dateTimePattern,
-            parser: (value) => luxon_1.DateTime.fromISO(value, { setZone: true }),
-        });
-    });
+function dateTime(options = { setZone: true }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
+        value,
+        path,
+        ctx,
+        type: 'DateTime',
+        proto: luxon_2.DateTimeLuxon,
+        pattern: dateTimePattern,
+        parser: (value) => luxon_1.DateTime.fromISO(value, options),
+    }));
 }
-function dateTimeUtcValidator(value, path, ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return validateLuxon({
-            value,
-            path,
-            ctx,
-            type: 'DateTime',
-            proto: luxon_2.DateTimeUtcLuxon,
-            pattern: dateTimePattern,
-            parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
-        });
-    });
+function dateTimeUtc(options = { zone: luxon_1.FixedOffsetZone.utcInstance }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
+        value,
+        path,
+        ctx,
+        type: 'DateTime',
+        proto: luxon_2.DateTimeUtcLuxon,
+        pattern: dateTimePattern,
+        parser: (value) => luxon_1.DateTime.fromISO(value, options),
+    }));
 }
 const dateTimeMillisPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}(?:Z|[+-]\d{2}(?::?\d{2})?)$/;
-function dateTimeMillisValidator(value, path, ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return validateLuxon({
-            value,
-            path,
-            ctx,
-            type: 'DateTimeMillis',
-            proto: luxon_2.DateTimeMillisLuxon,
-            pattern: dateTimeMillisPattern,
-            parser: (value) => luxon_1.DateTime.fromISO(value, { setZone: true }),
-        });
-    });
+function dateTimeMillis(options = { setZone: true }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
+        value,
+        path,
+        ctx,
+        type: 'DateTimeMillis',
+        proto: luxon_2.DateTimeMillisLuxon,
+        pattern: dateTimeMillisPattern,
+        parser: (value) => luxon_1.DateTime.fromISO(value, options),
+    }));
+}
+function dateTimeMillisUtc(options = { zone: luxon_1.FixedOffsetZone.utcInstance }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
+        value,
+        path,
+        ctx,
+        type: 'DateTimeMillis',
+        proto: luxon_2.DateTimeMillisUtcLuxon,
+        pattern: dateTimeMillisPattern,
+        parser: (value) => luxon_1.DateTime.fromISO(value, options),
+    }));
+}
+function dateTimeFromISO(options = { setZone: true }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
+        value,
+        path,
+        ctx,
+        type: 'ISODateTime',
+        pattern: /./,
+        parser: (value) => luxon_1.DateTime.fromISO(value, options),
+    }));
+}
+function dateTimeFromRFC2822(options = { setZone: true }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
+        value,
+        path,
+        ctx,
+        type: 'RFC2822DateTime',
+        pattern: /./,
+        parser: (value) => luxon_1.DateTime.fromRFC2822(value, options),
+    }));
+}
+function dateTimeFromHTTP(options = { setZone: true }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
+        value,
+        path,
+        ctx,
+        type: 'HTTPDateTime',
+        pattern: /./,
+        parser: (value) => luxon_1.DateTime.fromHTTP(value, options),
+    }));
+}
+function dateTimeFromSQL(options = { zone: luxon_1.FixedOffsetZone.utcInstance }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
+        value,
+        path,
+        ctx,
+        type: 'SQLDateTime',
+        pattern: /./,
+        parser: (value) => luxon_1.DateTime.fromSQL(value, options),
+    }));
 }
-function dateTimeMillisUtcValidator(value, path, ctx) {
+function validateLuxonNumber({ value, path, ctx, type, parser }) {
     return __awaiter(this, void 0, void 0, function* () {
-        return validateLuxon({
-            value,
-            path,
-            ctx,
-            type: 'DateTimeMillis',
-            proto: luxon_2.DateTimeMillisUtcLuxon,
-            pattern: dateTimeMillisPattern,
-            parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
-        });
+        if ((0, v_validation_1.isNullOrUndefined)(value)) {
+            return ctx.failure(v_validation_1.defaultViolations.notNull(path), value);
+        }
+        else if (luxon_1.DateTime.isDateTime(value)) {
+            if (value.isValid) {
+                return ctx.success(value);
+            }
+        }
+        else if (typeof value === 'number' && !Number.isNaN(value)) {
+            const dateTime = parser(value);
+            if (dateTime.isValid) {
+                return ctx.success(dateTime);
+            }
+        }
+        return ctx.failure(v_validation_1.defaultViolations.date(value, path, type), value);
     });
 }
+exports.validateLuxonNumber = validateLuxonNumber;
+function dateTimeFromMillis(options = { zone: luxon_1.FixedOffsetZone.utcInstance }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxonNumber({
+        value,
+        path,
+        ctx,
+        type: 'MillisDateTime',
+        parser: value => luxon_1.DateTime.fromMillis(value, options),
+    }));
+}
+function dateTimeFromSeconds(options = { zone: luxon_1.FixedOffsetZone.utcInstance }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxonNumber({
+        value,
+        path,
+        ctx,
+        type: 'SecondsDateTime',
+        parser: value => luxon_1.DateTime.fromSeconds(value, options),
+    }));
+}
 const durationPattern = /^P(?!$)(\d+(?:\.\d+)?Y)?(\d+(?:\.\d+)?M)?(\d+(?:\.\d+)?W)?(\d+(?:\.\d+)?D)?(T(?=\d)(\d+(?:\.\d+)?H)?(\d+(?:\.\d+)?M)?(\d+(?:\.\d+)?S)?)?$/;
 class DurationValidator extends v_validation_1.Validator {
     validatePath(value, path, ctx) {
@@ -140,11 +212,19 @@ class DurationValidator extends v_validation_1.Validator {
 }
 exports.DurationValidator = DurationValidator;
 exports.Vluxon = {
-    localDate: () => v_validation_1.V.fn(localDateValidator),
-    localTime: () => v_validation_1.V.fn(localTimeValidator),
-    dateTime: () => v_validation_1.V.fn(dateTimeValidator),
-    dateTimeUtc: () => v_validation_1.V.fn(dateTimeUtcValidator),
-    dateTimeMillis: () => v_validation_1.V.fn(dateTimeMillisValidator),
-    dateTimeMillisUtc: () => v_validation_1.V.fn(dateTimeMillisUtcValidator),
+    // DateTime wrapper validators
+    localDate,
+    localTime,
+    dateTime,
+    dateTimeUtc,
+    dateTimeMillis,
+    dateTimeMillisUtc,
+    // Plain DateTime validators
+    dateTimeFromISO,
+    dateTimeFromRFC2822,
+    dateTimeFromHTTP,
+    dateTimeFromSQL,
+    dateTimeFromSeconds,
+    dateTimeFromMillis,
     duration: () => new DurationValidator(),
 };

package/dist/luxon.d.ts

@@ -1,4 +1,4 @@
-import { DateTime, DateTimeJSOptions, DateTimeOptions } from 'luxon';
+import { DateTime, DateTimeJSOptions, DateTimeOptions, Zone } from 'luxon';
 export declare type LuxonDateTimeInput = DateTime | LuxonDateTime;
 export declare abstract class LuxonDateTime {
     readonly dateTime: DateTime;
@@ -19,8 +19,11 @@ export declare class LocalDateLuxon extends LuxonDateTime {
     static nowLocal(options?: DateTimeJSOptions): LocalDateLuxon;
     static nowUtc(): LocalDateLuxon;
     static fromISO(value: string, options?: DateTimeOptions): LocalDateLuxon;
-    static fromJSDate(date: Date, options?: DateTimeOptions): LocalDateLuxon;
-    static fromMillis(millis: number, options?: DateTimeOptions): LocalDateLuxon;
+    static fromFormat(value: string, format: string, options?: DateTimeOptions): LocalDateLuxon;
+    static fromJSDate(date: Date, options?: {
+        zone?: string | Zone;
+    }): LocalDateLuxon;
+    static fromMillis(millis: number, options?: DateTimeJSOptions): LocalDateLuxon;
     protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): LocalDateLuxon;
     toJSON(): string;
@@ -31,8 +34,11 @@ export declare class LocalTimeLuxon extends LuxonDateTime {
     static nowLocal(options?: DateTimeJSOptions): LocalTimeLuxon;
     static nowUtc(): LocalTimeLuxon;
     static fromISO(value: string, options?: DateTimeOptions): LocalTimeLuxon;
-    static fromJSDate(date: Date, options?: DateTimeOptions): LocalTimeLuxon;
-    static fromMillis(millis: number, options?: DateTimeOptions): LocalTimeLuxon;
+    static fromFormat(value: string, format: string, options?: DateTimeOptions): LocalTimeLuxon;
+    static fromJSDate(date: Date, options?: {
+        zone?: string | Zone;
+    }): LocalTimeLuxon;
+    static fromMillis(millis: number, options?: DateTimeJSOptions): LocalTimeLuxon;
     protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): LocalTimeLuxon;
     toJSON(): string;
@@ -43,8 +49,11 @@ export declare class DateTimeLuxon extends LuxonDateTime {
     constructor(input: LuxonDateTimeInput);
     static now(options?: DateTimeJSOptions): DateTimeLuxon;
     static fromISO(value: string, options?: DateTimeOptions): DateTimeLuxon;
-    static fromJSDate(date: Date, options?: DateTimeOptions): DateTimeLuxon;
-    static fromMillis(millis: number, options?: DateTimeOptions): DateTimeLuxon;
+    static fromFormat(value: string, format: string, options?: DateTimeOptions): DateTimeLuxon;
+    static fromJSDate(date: Date, options?: {
+        zone?: string | Zone;
+    }): DateTimeLuxon;
+    static fromMillis(millis: number, options?: DateTimeJSOptions): DateTimeLuxon;
     protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): DateTimeLuxon;
     toJSON(): string;
@@ -53,8 +62,11 @@ export declare class DateTimeUtcLuxon extends LuxonDateTime {
     constructor(input: LuxonDateTimeInput);
     static now(): DateTimeUtcLuxon;
     static fromISO(value: string, options?: DateTimeOptions): DateTimeUtcLuxon;
-    static fromJSDate(date: Date, options?: DateTimeOptions): DateTimeUtcLuxon;
-    static fromMillis(millis: number, options?: DateTimeOptions): DateTimeUtcLuxon;
+    static fromFormat(value: string, format: string, options?: DateTimeOptions): DateTimeUtcLuxon;
+    static fromJSDate(date: Date, options?: {
+        zone?: string | Zone;
+    }): DateTimeUtcLuxon;
+    static fromMillis(millis: number, options?: DateTimeJSOptions): DateTimeUtcLuxon;
     protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): DateTimeUtcLuxon;
     toJSON(): string;
@@ -65,8 +77,11 @@ export declare class DateTimeMillisLuxon extends LuxonDateTime {
     constructor(input: LuxonDateTimeInput);
     static now(options?: DateTimeJSOptions): DateTimeMillisLuxon;
     static fromISO(value: string, options?: DateTimeOptions): DateTimeMillisLuxon;
-    static fromJSDate(date: Date, options?: DateTimeOptions): DateTimeMillisLuxon;
-    static fromMillis(millis: number, options?: DateTimeOptions): DateTimeMillisLuxon;
+    static fromFormat(value: string, format: string, options?: DateTimeOptions): DateTimeMillisLuxon;
+    static fromJSDate(date: Date, options?: {
+        zone?: string | Zone;
+    }): DateTimeMillisLuxon;
+    static fromMillis(millis: number, options?: DateTimeJSOptions): DateTimeMillisLuxon;
     protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): DateTimeMillisLuxon;
     toJSON(): string;
@@ -75,8 +90,11 @@ export declare class DateTimeMillisUtcLuxon extends LuxonDateTime {
     constructor(input: LuxonDateTimeInput);
     static now(): DateTimeMillisUtcLuxon;
     static fromISO(value: string, options?: DateTimeOptions): DateTimeMillisUtcLuxon;
-    static fromJSDate(date: Date, options?: DateTimeOptions): DateTimeMillisUtcLuxon;
-    static fromMillis(millis: number, options?: DateTimeOptions): DateTimeMillisUtcLuxon;
+    static fromFormat(value: string, format: string, options?: DateTimeOptions): DateTimeMillisUtcLuxon;
+    static fromJSDate(date: Date, options?: {
+        zone?: string | Zone;
+    }): DateTimeMillisUtcLuxon;
+    static fromMillis(millis: number, options?: DateTimeJSOptions): DateTimeMillisUtcLuxon;
     protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): DateTimeMillisUtcLuxon;
     toJSON(): string;

package/dist/luxon.js

@@ -46,13 +46,16 @@ class LocalDateLuxon extends LuxonDateTime {
         return new LocalDateLuxon(luxon_1.DateTime.utc());
     }
     static fromISO(value, options) {
-        return new LocalDateLuxon(luxon_1.DateTime.fromISO(value, options));
+        return new LocalDateLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
+    }
+    static fromFormat(value, format, options) {
+        return new LocalDateLuxon(luxon_1.DateTime.fromFormat(value, format, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     static fromJSDate(date, options) {
-        return new LocalDateLuxon(luxon_1.DateTime.fromJSDate(date, options));
+        return new LocalDateLuxon(luxon_1.DateTime.fromJSDate(date, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     static fromMillis(millis, options) {
-        return new LocalDateLuxon(luxon_1.DateTime.fromMillis(millis, options));
+        return new LocalDateLuxon(luxon_1.DateTime.fromMillis(millis, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     normalize(dateTime) {
         return luxon_1.DateTime.utc(dateTime.year, dateTime.month, dateTime.day);
@@ -77,13 +80,16 @@ class LocalTimeLuxon extends LuxonDateTime {
         return new LocalTimeLuxon(luxon_1.DateTime.utc());
     }
     static fromISO(value, options) {
-        return new LocalTimeLuxon(luxon_1.DateTime.fromISO(value, options));
+        return new LocalTimeLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
+    }
+    static fromFormat(value, format, options) {
+        return new LocalTimeLuxon(luxon_1.DateTime.fromFormat(value, format, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     static fromJSDate(date, options) {
-        return new LocalTimeLuxon(luxon_1.DateTime.fromJSDate(date, options));
+        return new LocalTimeLuxon(luxon_1.DateTime.fromJSDate(date, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     static fromMillis(millis, options) {
-        return new LocalTimeLuxon(luxon_1.DateTime.fromMillis(millis, options));
+        return new LocalTimeLuxon(luxon_1.DateTime.fromMillis(millis, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     normalize(dateTime) {
         return luxon_1.DateTime.utc(1970, 1, 1, dateTime.hour, dateTime.minute, dateTime.second);
@@ -107,6 +113,9 @@ class DateTimeLuxon extends LuxonDateTime {
     static fromISO(value, options) {
         return new DateTimeLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ setZone: true }, options)));
     }
+    static fromFormat(value, format, options) {
+        return new DateTimeLuxon(luxon_1.DateTime.fromFormat(value, format, Object.assign({ setZone: true }, options)));
+    }
     static fromJSDate(date, options) {
         return new DateTimeLuxon(luxon_1.DateTime.fromJSDate(date, options));
     }
@@ -140,6 +149,9 @@ class DateTimeUtcLuxon extends LuxonDateTime {
     static fromISO(value, options) {
         return new DateTimeUtcLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
+    static fromFormat(value, format, options) {
+        return new DateTimeUtcLuxon(luxon_1.DateTime.fromFormat(value, format, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
+    }
     static fromJSDate(date, options) {
         return new DateTimeUtcLuxon(luxon_1.DateTime.fromJSDate(date, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
@@ -167,6 +179,9 @@ class DateTimeMillisLuxon extends LuxonDateTime {
     static fromISO(value, options) {
         return new DateTimeMillisLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ setZone: true }, options)));
     }
+    static fromFormat(value, format, options) {
+        return new DateTimeMillisLuxon(luxon_1.DateTime.fromFormat(value, format, Object.assign({ setZone: true }, options)));
+    }
     static fromJSDate(date, options) {
         return new DateTimeMillisLuxon(luxon_1.DateTime.fromJSDate(date, options));
     }
@@ -200,6 +215,9 @@ class DateTimeMillisUtcLuxon extends LuxonDateTime {
     static fromISO(value, options) {
         return new DateTimeMillisUtcLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
+    static fromFormat(value, format, options) {
+        return new DateTimeMillisUtcLuxon(luxon_1.DateTime.fromFormat(value, format, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
+    }
     static fromJSDate(date, options) {
         return new DateTimeMillisUtcLuxon(luxon_1.DateTime.fromJSDate(date, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }

package/dist/test-luxon.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const luxon_1 = require("luxon");
-console.log(luxon_1.DateTime.fromISO('2022-02-27').set({ day: 31 }).day);
+console.log(luxon_1.DateTime.fromSQL('09:24:15').toJSON());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finnair/v-validation-luxon",
-  "version": "1.1.0-alpha.7",
+  "version": "1.1.0",
   "private": false,
   "description": "Luxon validators",
   "main": "dist/index.js",
@@ -25,12 +25,12 @@
     "build": "tsc -b ."
   },
   "dependencies": {
-    "@finnair/path": "^1.1.0-alpha.6",
-    "@finnair/v-validation": "^1.1.0-alpha.6",
+    "@finnair/path": "^1.1.0",
+    "@finnair/v-validation": "^1.1.0",
     "luxon": "3.0.1"
   },
   "devDependencies": {
     "@types/luxon": "3.0.0"
   },
-  "gitHead": "b270437f1a403fbb012297653f05d7d6d732fa76"
+  "gitHead": "860263e814c178790766b48e22d8a8995e33ae40"
 }