@finnair/v-validation-luxon 1.1.0-alpha.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+# [1.1.0-alpha.0](https://github.com/finnair/v-validation/compare/v1.0.1...v1.1.0-alpha.0) (2022-08-12)
+
+
+### Features
+
+* Support for Luxon ([6f982df](https://github.com/finnair/v-validation/commit/6f982df9b55395e953069914c93fef677dec171e))

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Finnair Open Source
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+[![npm version](https://badge.fury.io/js/%40finnair%2Fv-validation-luxon.svg)](https://badge.fury.io/js/%40finnair%2Fv-validation-luxon)
+
+# v-validation-luxon
+
+`@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.
+
+[Documentation for `v-validation`](https://github.com/finnair/v-validation).
+
+## Getting Started
+
+Install v-validation using [`yarn`](https://yarnpkg.com/en/package/jest):
+
+```bash
+yarn add @finnair/v-validation-luxon
+```
+
+Or [`npm`](https://www.npmjs.com/):
+
+```bash
+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.              |

package/dist/Vluxon.d.ts

@@ -0,0 +1,27 @@
+import { ValidationContext, Validator, ValidationResult } from '@finnair/v-validation';
+import { Path } from '@finnair/path';
+import { DateTime } from 'luxon';
+import { LuxonDateTime } from './luxon';
+export declare type LuxonInput = string | DateTime | LuxonDateTime;
+export interface ValidateLuxonParams {
+    value: any;
+    path: Path;
+    ctx: ValidationContext;
+    type: string;
+    proto: any;
+    pattern: RegExp;
+}
+export declare function validateLuxon({ value, path, ctx, type, proto, pattern }: ValidateLuxonParams): ValidationResult;
+export declare class DurationValidator extends Validator {
+    validatePath(value: any, path: Path, ctx: ValidationContext): Promise<ValidationResult>;
+}
+export declare const Vluxon: {
+    date: () => import("@finnair/v-validation").ValidatorFnWrapper;
+    dateUtc: () => 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;
+    time: () => import("@finnair/v-validation").ValidatorFnWrapper;
+    duration: () => DurationValidator;
+};

package/dist/Vluxon.js

@@ -0,0 +1,157 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vluxon = exports.DurationValidator = 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 }) {
+    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));
+        }
+    }
+    else if ((0, v_validation_1.isString)(value)) {
+        if (pattern.test(value)) {
+            const dateTime = luxon_1.DateTime.fromISO(value, { setZone: true });
+            if (dateTime.isValid) {
+                return ctx.success(new proto(dateTime));
+            }
+        }
+    }
+    return ctx.failure(v_validation_1.defaultViolations.date(value, path, type), value);
+}
+exports.validateLuxon = validateLuxon;
+const datePattern = /^\d{4}-\d{2}-\d{2}$/;
+function dateValidator(value, path, ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return validateLuxon({
+            value,
+            path,
+            ctx,
+            type: 'Date',
+            proto: luxon_2.DateLuxon,
+            pattern: datePattern
+        });
+    });
+}
+function dateUtcValidator(value, path, ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return validateLuxon({
+            value,
+            path,
+            ctx,
+            type: 'Date',
+            proto: luxon_2.DateUtcLuxon,
+            pattern: datePattern
+        });
+    });
+}
+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
+        });
+    });
+}
+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
+        });
+    });
+}
+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
+        });
+    });
+}
+function dateTimeMillisUtcValidator(value, path, ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return validateLuxon({
+            value,
+            path,
+            ctx,
+            type: 'DateTimeMillis',
+            proto: luxon_2.DateTimeMillisUtcLuxon,
+            pattern: dateTimeMillisPattern
+        });
+    });
+}
+const timePattern = /^\d{2}:\d{2}:\d{2}$/;
+function timeValidator(value, path, ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return validateLuxon({
+            value,
+            path,
+            ctx,
+            type: 'Time',
+            proto: luxon_2.TimeLuxon,
+            pattern: timePattern
+        });
+    });
+}
+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) {
+        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 (luxon_1.Duration.isDuration(value)) {
+                return ctx.success(value);
+            }
+            else if ((0, v_validation_1.isString)(value) && durationPattern.test(value)) {
+                const duration = luxon_1.Duration.fromISO(value);
+                if (duration.isValid) {
+                    return ctx.success(duration);
+                }
+            }
+            return ctx.failure(new v_validation_1.TypeMismatch(path, 'Duration', value), value);
+        });
+    }
+}
+exports.DurationValidator = DurationValidator;
+exports.Vluxon = {
+    date: () => v_validation_1.V.fn(dateValidator),
+    dateUtc: () => v_validation_1.V.fn(dateUtcValidator),
+    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),
+    time: () => v_validation_1.V.fn(timeValidator),
+    duration: () => new DurationValidator(),
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Vluxon';
+export * from 'luxon';

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Vluxon"), exports);
+__exportStar(require("luxon"), exports);

package/dist/luxon.d.ts

@@ -0,0 +1,57 @@
+import { DateTime } from 'luxon';
+export declare type LuxonDateTimeInput = DateTime | LuxonDateTime;
+export declare abstract class LuxonDateTime {
+    readonly dateTime: DateTime;
+    constructor(input: LuxonDateTimeInput);
+    protected normalize(dateTime: DateTime): DateTime;
+    apply<R>(fn: (dateTime: DateTime) => R): R;
+    valueOf(): number;
+    equals(other: any): boolean;
+    abstract wrap(fn: (dateTime: DateTime) => DateTime): LuxonDateTime;
+    abstract toJSON(): string;
+}
+export declare class DateLuxon extends LuxonDateTime {
+    static readonly format = "yyyy-MM-dd";
+    constructor(input: LuxonDateTimeInput);
+    protected normalize(dateTime: DateTime): DateTime;
+    wrap(fn: (dateTime: DateTime) => DateTime): DateLuxon;
+    toJSON(): string;
+}
+export declare class DateUtcLuxon extends LuxonDateTime {
+    constructor(input: LuxonDateTimeInput);
+    protected normalize(dateTime: DateTime): DateTime;
+    wrap(fn: (dateTime: DateTime) => DateTime): DateUtcLuxon;
+    toJSON(): string;
+}
+export declare class DateTimeLuxon extends LuxonDateTime {
+    static readonly format = "yyyy-MM-dd'T'HH:mm:ss";
+    static readonly formatTz: string;
+    constructor(input: LuxonDateTimeInput);
+    wrap(fn: (dateTime: DateTime) => DateTime): DateTimeLuxon;
+    toJSON(): string;
+}
+export declare class DateTimeUtcLuxon extends LuxonDateTime {
+    constructor(input: LuxonDateTimeInput);
+    protected normalize(dateTime: DateTime): DateTime;
+    wrap(fn: (dateTime: DateTime) => DateTime): DateTimeUtcLuxon;
+    toJSON(): string;
+}
+export declare class DateTimeMillisLuxon extends LuxonDateTime {
+    static readonly format = "yyyy-MM-dd'T'HH:mm:ss.SSS";
+    static readonly formatTz: string;
+    constructor(input: LuxonDateTimeInput);
+    wrap(fn: (dateTime: DateTime) => DateTime): DateTimeMillisLuxon;
+    toJSON(): string;
+}
+export declare class DateTimeMillisUtcLuxon extends LuxonDateTime {
+    constructor(input: LuxonDateTimeInput);
+    protected normalize(dateTime: DateTime): DateTime;
+    wrap(fn: (dateTime: DateTime) => DateTime): DateTimeMillisUtcLuxon;
+    toJSON(): string;
+}
+export declare class TimeLuxon extends LuxonDateTime {
+    static readonly format = "HH:mm:ss";
+    constructor(input: LuxonDateTimeInput);
+    wrap(fn: (dateTime: DateTime) => DateTime): TimeLuxon;
+    toJSON(): string;
+}

package/dist/luxon.js

@@ -0,0 +1,144 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeLuxon = exports.DateTimeMillisUtcLuxon = exports.DateTimeMillisLuxon = exports.DateTimeUtcLuxon = exports.DateTimeLuxon = exports.DateUtcLuxon = exports.DateLuxon = exports.LuxonDateTime = void 0;
+const luxon_1 = require("luxon");
+class LuxonDateTime {
+    constructor(input) {
+        if (input instanceof LuxonDateTime) {
+            this.dateTime = this.normalize(input.dateTime);
+        }
+        else {
+            if (!input.isValid) {
+                throw new Error('Invalid DateTime: ' + input.invalidExplanation);
+            }
+            this.dateTime = this.normalize(input);
+        }
+    }
+    normalize(dateTime) {
+        return dateTime;
+    }
+    apply(fn) {
+        return fn(this.dateTime);
+    }
+    valueOf() {
+        return this.dateTime.valueOf();
+    }
+    equals(other) {
+        if (this.constructor === other.constructor) {
+            return this.dateTime.equals(other.dateTime);
+        }
+        return false;
+    }
+}
+exports.LuxonDateTime = LuxonDateTime;
+class DateLuxon extends LuxonDateTime {
+    constructor(input) {
+        super(input);
+    }
+    normalize(dateTime) {
+        return dateTime.startOf('day');
+    }
+    wrap(fn) {
+        return new DateLuxon(fn(this.dateTime));
+    }
+    toJSON() {
+        return this.dateTime.toFormat(DateLuxon.format);
+    }
+}
+exports.DateLuxon = DateLuxon;
+DateLuxon.format = 'yyyy-MM-dd';
+class DateUtcLuxon extends LuxonDateTime {
+    constructor(input) {
+        super(input);
+    }
+    normalize(dateTime) {
+        return luxon_1.DateTime.utc(dateTime.year, dateTime.month, dateTime.day, 0, 0, 0);
+    }
+    wrap(fn) {
+        return new DateUtcLuxon(fn(this.dateTime));
+    }
+    toJSON() {
+        return this.dateTime.toFormat(DateLuxon.format);
+    }
+}
+exports.DateUtcLuxon = DateUtcLuxon;
+class DateTimeLuxon extends LuxonDateTime {
+    constructor(input) {
+        super(input);
+    }
+    wrap(fn) {
+        return new DateTimeLuxon(fn(this.dateTime));
+    }
+    toJSON() {
+        if (this.dateTime.offset === 0) {
+            return this.dateTime.toFormat(DateTimeLuxon.format) + 'Z';
+        }
+        return this.dateTime.toFormat(DateTimeLuxon.formatTz);
+    }
+}
+exports.DateTimeLuxon = DateTimeLuxon;
+_a = DateTimeLuxon;
+DateTimeLuxon.format = "yyyy-MM-dd'T'HH:mm:ss";
+DateTimeLuxon.formatTz = `${_a.format}ZZ`;
+class DateTimeUtcLuxon extends LuxonDateTime {
+    constructor(input) {
+        super(input);
+    }
+    normalize(dateTime) {
+        return dateTime.toUTC();
+    }
+    wrap(fn) {
+        return new DateTimeUtcLuxon(fn(this.dateTime));
+    }
+    toJSON() {
+        return this.dateTime.toFormat(DateTimeLuxon.format) + 'Z';
+    }
+}
+exports.DateTimeUtcLuxon = DateTimeUtcLuxon;
+class DateTimeMillisLuxon extends LuxonDateTime {
+    constructor(input) {
+        super(input);
+    }
+    wrap(fn) {
+        return new DateTimeMillisLuxon(fn(this.dateTime));
+    }
+    toJSON() {
+        if (this.dateTime.offset === 0) {
+            return this.dateTime.toFormat(DateTimeMillisLuxon.format) + 'Z';
+        }
+        return this.dateTime.toFormat(DateTimeMillisLuxon.formatTz);
+    }
+}
+exports.DateTimeMillisLuxon = DateTimeMillisLuxon;
+_b = DateTimeMillisLuxon;
+DateTimeMillisLuxon.format = "yyyy-MM-dd'T'HH:mm:ss.SSS";
+DateTimeMillisLuxon.formatTz = `${_b.format}ZZ`;
+class DateTimeMillisUtcLuxon extends LuxonDateTime {
+    constructor(input) {
+        super(input);
+    }
+    normalize(dateTime) {
+        return dateTime.toUTC();
+    }
+    wrap(fn) {
+        return new DateTimeMillisUtcLuxon(fn(this.dateTime));
+    }
+    toJSON() {
+        return this.dateTime.toFormat(DateTimeMillisLuxon.format) + 'Z';
+    }
+}
+exports.DateTimeMillisUtcLuxon = DateTimeMillisUtcLuxon;
+class TimeLuxon extends LuxonDateTime {
+    constructor(input) {
+        super(input);
+    }
+    wrap(fn) {
+        return new TimeLuxon(fn(this.dateTime));
+    }
+    toJSON() {
+        return this.dateTime.toFormat(TimeLuxon.format);
+    }
+}
+exports.TimeLuxon = TimeLuxon;
+TimeLuxon.format = 'HH:mm:ss';

package/dist/test-luxon.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test-luxon.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const luxon_1 = require("luxon");
+console.log(luxon_1.Duration.fromISO('P3Y6M1W4DT12H30M5S').toJSON());

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@finnair/v-validation-luxon",
+  "version": "1.1.0-alpha.0",
+  "private": false,
+  "description": "Luxon validators",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "homepage": "https://github.com/finnair/v-validation/tree/master/packages/luxon#readme",
+  "bugs": "https://github.com/finnair/v-validation/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/finnair/v-validation.git",
+    "directory": "packages/luxon"
+  },
+  "keywords": [
+    "validation",
+    "validate",
+    "convert",
+    "normalize",
+    "typescript",
+    "luxon"
+  ],
+  "scripts": {
+    "build": "tsc -b ."
+  },
+  "dependencies": {
+    "@finnair/path": "^1.1.0-alpha.0",
+    "@finnair/v-validation": "^1.1.0-alpha.0",
+    "luxon": "3.0.1"
+  },
+  "devDependencies": {
+    "@types/luxon": "3.0.0"
+  },
+  "gitHead": "980da25d0eb031a0ed89691c97459b23efcdc8a5"
+}