@thisisagile/easy 18.11.1 → 18.12.0

package/dist/types/ErrorOrigin.d.ts

@@ -3,4 +3,6 @@ import { Exception } from './Exception';
 import { Response } from '../http/Response';
 import { Results } from './Results';
 import { Result } from './Result';
+import { Optional } from './Types';
 export type ErrorOrigin = Text | Error | Exception | Response | Results | Result;
+export declare const errorMessage: (e: unknown) => Optional<string>;

package/dist/types/ErrorOrigin.mjs

@@ -1 +1,32 @@
+import {
+  isResponse
+} from "../chunk-EZ4FZ3HS.mjs";
+import {
+  choose,
+  isException,
+  isResults
+} from "../chunk-I2VWZJ2K.mjs";
+import "../chunk-SSROJBD5.mjs";
+import "../chunk-EBIF6AMC.mjs";
+import "../chunk-KCY4RPFR.mjs";
+import "../chunk-S3NSPQ7M.mjs";
+import {
+  asString
+} from "../chunk-NNA77YYC.mjs";
+import "../chunk-SJGQU3OG.mjs";
+import "../chunk-D5IYAIMK.mjs";
+import "../chunk-PF7HDF6B.mjs";
+import "../chunk-IXK47WKF.mjs";
+import "../chunk-PIRWVOO2.mjs";
+import {
+  isError,
+  isString
+} from "../chunk-AAND4MKF.mjs";
+import "../chunk-4N72FQFX.mjs";
+
+// src/types/ErrorOrigin.ts
+var errorMessage = (e) => choose(e).type(isResponse, (r) => r.body.error?.errors?.[0]?.message ?? r.body.error?.message).type(isException, (ex) => asString(ex.reason) || ex.message).type(isResults, (rs) => rs.results[0]?.message).type(isError, (e2) => e2.message).type(isString, (s) => s).else(() => void 0);
+export {
+  errorMessage
+};
 //# sourceMappingURL=ErrorOrigin.mjs.map

package/dist/types/ErrorOrigin.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../../src/types/ErrorOrigin.ts"],"sourcesContent":["import { asString, Text } from './Text';\nimport { Exception, isException } from './Exception';\nimport { isResponse, Response } from '../http/Response';\nimport { isResults, Results } from './Results';\nimport { Result } from './Result';\nimport { choose } from './Case';\nimport { isError, isString } from './Is';\nimport { Optional } from './Types';\n\nexport type ErrorOrigin = Text | Error | Exception | Response | Results | Result;\n\nexport const errorMessage = (e: unknown): Optional<string> =>\n  choose(e)\n    .type(isResponse, r => r.body.error?.errors?.[0]?.message ?? r.body.error?.message)\n    .type(isException, ex => asString(ex.reason) || ex.message)\n    .type(isResults, rs => rs.results[0]?.message)\n    .type(isError, e => e.message)\n    .type(isString, s => s)\n    .else(() => undefined);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAWO,IAAM,eAAe,CAAC,MAC3B,OAAO,CAAC,EACL,KAAK,YAAY,OAAK,EAAE,KAAK,OAAO,SAAS,CAAC,GAAG,WAAW,EAAE,KAAK,OAAO,OAAO,EACjF,KAAK,aAAa,QAAM,SAAS,GAAG,MAAM,KAAK,GAAG,OAAO,EACzD,KAAK,WAAW,QAAM,GAAG,QAAQ,CAAC,GAAG,OAAO,EAC5C,KAAK,SAAS,CAAAA,OAAKA,GAAE,OAAO,EAC5B,KAAK,UAAU,OAAK,CAAC,EACrB,KAAK,MAAM,MAAS;","names":["e"]}

package/dist/utils/Period.mjs

@@ -3,7 +3,7 @@ import {
 } from "../chunk-O3UNRTSC.mjs";
 import {
   DateTime
-} from "../chunk-GRDUTNMZ.mjs";
+} from "../chunk-EOHHPAAY.mjs";
 import "../chunk-RF23BV6J.mjs";
 import "../chunk-ADJAEGCT.mjs";
 import {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thisisagile/easy",
-  "version": "18.11.1",
+  "version": "18.12.0",
   "description": "Straightforward library for building domain-driven microservice architectures",
   "author": "Sander Hoogendoorn",
   "license": "MIT",
@@ -25,13 +25,7 @@
     "test": "yarn g:jest --coverage",
     "prepack": "yarn g:copy-readme"
   },
-  "sideEffects": [
-    "./src/domain/DateTime.ts",
-    "./src/types/Meta.ts",
-    "./dist/domain/DateTime.*",
-    "./dist/types/Meta.*",
-    "./dist/index.js"
-  ],
+  "sideEffects": false,
   "files": [
     "dist",
     "src"
@@ -42,14 +36,15 @@
   "devDependencies": {
     "@thisisagile/easy-test": "*",
     "@types/form-urlencoded": "^4.4.2",
+    "@types/luxon": "3.4.2",
     "@types/validator": "^13.12.2"
   },
   "dependencies": {
     "@types/uuid": "^9.0.8",
     "axios": "^1.7.9",
-    "dayjs": "^1.11.21",
     "form-urlencoded": "^6.1.5",
     "jwt-decode": "^4.0.0",
+    "luxon": "^3.5.0",
     "reflect-metadata": "^0.2.2",
     "uuid": "^9.0.1",
     "validator": "^13.12.0"

package/src/domain/DateTime.ts

@@ -1,16 +1,7 @@
-import dayjs, { Dayjs, ManipulateType, OpUnitType, QUnitType } from 'dayjs';
-import advancedFormat from 'dayjs/plugin/advancedFormat';
-import customParseFormat from 'dayjs/plugin/customParseFormat';
-import isoWeek from 'dayjs/plugin/isoWeek';
-import localizedFormat from 'dayjs/plugin/localizedFormat';
-import quarterOfYear from 'dayjs/plugin/quarterOfYear';
-import relativeTime from 'dayjs/plugin/relativeTime';
-import timezone from 'dayjs/plugin/timezone';
-import utc from 'dayjs/plugin/utc';
-import 'dayjs/locale/de';
-import 'dayjs/locale/nl';
+import { DateTime as LuxonDateTime, DateTimeUnit as LuxonDateTimeUnit, DurationUnit as LuxonDurationUnit, Settings } from 'luxon';
 import { Value } from '../types/Value';
 import { Optional } from '../types/Types';
+import { choose } from '../types/Case';
 import { isDefined, isNumber, isString } from '../types/Is';
 import { isDate } from '../types/IsDate';
 import { isA } from '../types/IsA';
@@ -19,30 +10,11 @@ import { JsonValue } from '../types/Json';
 import { seconds } from '../utils/Seconds';
 import { tryTo } from '../types/Try';
 import { use } from '../types/Constructor';
-import { choose } from '../types/Case';
 
-dayjs.extend(utc);
-dayjs.extend(timezone);
-dayjs.extend(customParseFormat);
-dayjs.extend(localizedFormat);
-dayjs.extend(relativeTime);
-dayjs.extend(isoWeek);
-dayjs.extend(advancedFormat);
-dayjs.extend(quarterOfYear);
-dayjs.tz.setDefault('UTC');
-
-export type DateTimeUnit = 'year' | 'quarter' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
-export type DurationUnit =
-  | DateTimeUnit
-  | 'years'
-  | 'quarters'
-  | 'months'
-  | 'weeks'
-  | 'days'
-  | 'hours'
-  | 'minutes'
-  | 'seconds'
-  | 'milliseconds';
+Settings.defaultZone = 'utc';
+
+export type DateTimeUnit = LuxonDateTimeUnit;
+export type DurationUnit = LuxonDurationUnit;
 export type Duration = Partial<Record<DurationUnit, number>>;
 
 export type DiffOptions = {
@@ -51,65 +23,30 @@ export type DiffOptions = {
 
 export type DatetimeInput = string | number | Date | DateTime | null;
 
-type DateTimeConstructorInput = DatetimeInput | Dayjs;
-type ZonedDayjs = Dayjs & { $x?: { $timezone?: string } };
-
-const invalidDate = dayjs.utc(Number.NaN);
-const isDayjs = (value: unknown): value is Dayjs => dayjs.isDayjs(value);
-const isoFormats = [
-  'YYYY-MM-DD',
-  'YYYY-MM-DDTHH:mm',
-  'YYYY-MM-DDTHH:mm:ss',
-  'YYYY-MM-DDTHH:mm:ss.SSS',
-  'YYYY-MM-DDTHH:mm[Z]',
-  'YYYY-MM-DDTHH:mm:ss[Z]',
-  'YYYY-MM-DDTHH:mm:ss.SSS[Z]',
-  'YYYY-MM-DDTHH:mmZ',
-  'YYYY-MM-DDTHH:mmZZ',
-  'YYYY-MM-DDTHH:mm:ssZ',
-  'YYYY-MM-DDTHH:mm:ssZZ',
-  'YYYY-MM-DDTHH:mm:ss.SSSZ',
-  'YYYY-MM-DDTHH:mm:ss.SSSZZ',
-];
-const fixedUnitMilliseconds: Partial<Record<DurationUnit, number>> = {
-  day: 86400000,
-  days: 86400000,
-  week: 604800000,
-  weeks: 604800000,
-};
-const calendarUnitMonths: Partial<Record<DurationUnit, number>> = {
-  month: 1,
-  months: 1,
-  quarter: 3,
-  quarters: 3,
-  year: 12,
-  years: 12,
-};
-
 export class DateTime extends Value<Optional<string>> {
-  protected readonly date: Dayjs;
+  protected readonly luxon: LuxonDateTime;
 
   constructor(value?: DatetimeInput);
   constructor(value?: string, format?: string);
-  constructor(value?: DateTimeConstructorInput, format?: string) {
-    const date = choose<DateTimeConstructorInput | undefined>(value)
-      .type(isDayjs, date => date)
-      .type(isDateTime, dateTime => dateTime.date)
-      .type(isNumber, timestamp => dayjs.utc(timestamp))
-      .type(isDate, date => dayjs.utc(date))
-      .type(isString, string => (string === '' ? invalidDate : format ? parseFormatted(string, format) : parseIso(string)))
-      .else(invalidDate);
-
-    super(date.isValid() ? formatDateTime(date) : undefined);
-    this.date = date;
+  constructor(value?: DatetimeInput, format?: string) {
+    const luxon = choose(value)
+      .type(isString, v => (format ? LuxonDateTime.fromFormat(v, format, { setZone: true }) : LuxonDateTime.fromISO(v, { setZone: true })))
+      .type(isNumber, v => LuxonDateTime.fromMillis(v))
+      .type(isDate, v => LuxonDateTime.fromJSDate(v))
+      .type(isDateTime, v => v.luxon)
+      // Allow constructing with LuxonDateTime without exposing types
+      .else(value instanceof LuxonDateTime ? value : LuxonDateTime.fromISO(undefined as any));
+
+    super(luxon.toISO() ?? undefined);
+    this.luxon = luxon;
   }
 
   static get now(): DateTime {
-    return fromDayjs(dayjs.utc(Date.now()));
+    return new DateTime(LuxonDateTime.utc() as any);
   }
 
   get isValid(): boolean {
-    return isDefined(this.value) && this.date.isValid();
+    return isDefined(this.value) && this.utc.isValid;
   }
 
   /**
@@ -135,8 +72,8 @@ export class DateTime extends Value<Optional<string>> {
     return this.withZone('Europe/Warsaw');
   }
 
-  protected get utc(): Dayjs {
-    return this.date.utc();
+  protected get utc(): LuxonDateTime {
+    return this.luxon.setZone('utc');
   }
 
   from(locale?: string): string;
@@ -148,23 +85,23 @@ export class DateTime extends Value<Optional<string>> {
       use((isString(dateOrLocale) ? dateOrLocale : maybeLocale) ?? 'en', locale =>
         ifDefined(
           isA<DateTime>(dateOrLocale) ? dateOrLocale : undefined,
-          d => this.utc.locale(toDayjsLocale(locale)).from(d.utc),
-          () => this.utc.locale(toDayjsLocale(locale)).from(dayjs.utc(Date.now()))
+          d => this.utc.setLocale(locale).toRelative({ base: d.utc }),
+          () => this.utc.setLocale(locale).toRelative()
         )
       ) ?? ''
     );
   }
 
   isAfter(dt: DateTime): boolean {
-    return this.utc.valueOf() > dt.utc.valueOf();
+    return this.utc > dt.utc;
   }
 
   isBefore(dt: DateTime): boolean {
-    return this.utc.valueOf() < dt.utc.valueOf();
+    return this.utc < dt.utc;
   }
 
   equals(dt: DateTime): boolean {
-    return this.utc.valueOf() === dt.utc.valueOf();
+    return this.utc.hasSame(dt.utc, 'millisecond');
   }
 
   add(n: number, unit?: DurationUnit): DateTime;
@@ -172,7 +109,7 @@ export class DateTime extends Value<Optional<string>> {
   add(duration: Duration): DateTime;
 
   add(n: number | Duration, unit: DurationUnit = 'day'): DateTime {
-    return fromDayjs(change(this.date, n, unit, 'add'));
+    return new DateTime(this.luxon.plus(isNumber(n) ? { [unit]: n } : n) as any);
   }
 
   subtract(n: number, unit?: DurationUnit): DateTime;
@@ -180,28 +117,27 @@ export class DateTime extends Value<Optional<string>> {
   subtract(duration: Duration): DateTime;
 
   subtract(n: number | Duration, unit: DurationUnit = 'day'): DateTime {
-    return fromDayjs(change(this.date, n, unit, 'subtract'));
+    return new DateTime(this.luxon.minus(isNumber(n) ? { [unit]: n } : n) as any);
   }
 
   diff(other: DateTime, unit: DateTimeUnit = 'day', opts?: DiffOptions): number {
-    return Math[opts?.rounding ?? 'floor'](this.utc.diff(other.utc, toDayjsUnit(unit) as QUnitType | OpUnitType, true));
+    return Math[opts?.rounding ?? 'floor'](this.utc.diff(other.utc).as(unit));
   }
 
   startOf(unit: DateTimeUnit = 'day'): DateTime {
-    return fromDayjs(this.date.startOf(toDayjsBoundaryUnit(unit)));
+    return new DateTime(this.luxon.startOf(unit) as any);
   }
 
   endOf(unit: DateTimeUnit = 'day'): DateTime {
-    return fromDayjs(this.date.endOf(toDayjsBoundaryUnit(unit)));
+    return new DateTime(this.luxon.endOf(unit) as any);
   }
 
   isWeekend(): boolean {
-    const day = this.date.day();
-    return day === 0 || day === 6;
+    return this.luxon.isWeekend;
   }
 
   withZone(zone: string): DateTime {
-    return fromDayjs(this.date.tz(zone));
+    return new DateTime(this.luxon.setZone(zone) as any);
   }
 
   toString(): string {
@@ -209,30 +145,15 @@ export class DateTime extends Value<Optional<string>> {
   }
 
   toJSON(): JsonValue {
-    return this.isValid ? this.utc.format('YYYY-MM-DDTHH:mm:ss.SSS[Z]') : null;
+    return this.utc.toISO();
   }
 
   toFormat(format: string): string {
-    return this.isValid ? this.date.format(toDayjsFormat(format)) : '';
+    return this.luxon.toFormat(format);
   }
 
   toLocale(locale = 'nl-NL', format = 'D'): string {
-    if (!this.isValid) return '';
-
-    if (format === 'D') return formatWithIntl(this.date, locale, { year: 'numeric', month: 'numeric', day: 'numeric' });
-    if (format === 'DDD') return formatWithIntl(this.date, locale, { dateStyle: 'long' });
-    if (format === 'ffff') {
-      return formatWithIntl(this.date, locale, {
-        weekday: 'long',
-        year: 'numeric',
-        month: 'long',
-        day: 'numeric',
-        hour: 'numeric',
-        minute: '2-digit',
-        timeZoneName: timezoneOf(this.date) ? 'long' : 'short',
-      });
-    }
-    return this.date.locale(toDayjsLocale(locale)).format(toDayjsFormat(format));
+    return this.luxon.setLocale(locale).toFormat(format);
   }
 
   toFull(locale?: string): string {
@@ -240,11 +161,11 @@ export class DateTime extends Value<Optional<string>> {
   }
 
   toDate(): Optional<Date> {
-    return this.isValid ? this.utc.toDate() : undefined;
+    return this.isValid ? this.utc.toJSDate() : undefined;
   }
 
   toEpoch(): number {
-    return this.date.valueOf();
+    return this.luxon.toMillis();
   }
 
   ago(end: DateTime = DateTime.now): string {
@@ -253,7 +174,7 @@ export class DateTime extends Value<Optional<string>> {
 
   withClock(clock: DateTime): DateTime {
     return tryTo(() => [this.toDate() as Date, clock.toDate() as Date])
-      .map(([td, cd]) => new Date(Date.UTC(td.getUTCFullYear(), td.getUTCMonth(), td.getUTCDate(), cd.getUTCHours(), cd.getUTCMinutes(), cd.getUTCSeconds())))
+      .map(([td, cd]) => new Date(td.getFullYear(), td.getMonth(), td.getDate(), cd.getHours(), cd.getMinutes(), cd.getSeconds()))
       .map(d => new DateTime(d)).value;
   }
 }
@@ -261,90 +182,3 @@ export class DateTime extends Value<Optional<string>> {
 export const isDateTime = (dt?: unknown): dt is DateTime => isDefined(dt) && dt instanceof DateTime;
 
 export const dt = (dt?: DatetimeInput): DateTime => new DateTime(dt);
-
-const parseIso = (value: string): Dayjs => {
-  const offset = offsetOf(value);
-  if (offset) {
-    const date = dayjs.utc(value);
-    return date.isValid() ? inOffsetZone(date, offset) : invalidDate;
-  }
-  return dayjs(value, isoFormats, true).isValid() ? dayjs.utc(value) : invalidDate;
-};
-
-const parseFormatted = (value: string, format: string): Dayjs => {
-  const dayjsFormat = toDayjsFormat(format);
-  const offset = offsetOf(value);
-  if (format.includes('ZZZ') && offset) {
-    const iso = dayjs.utc(value);
-    return iso.isValid() ? inOffsetZone(iso, offset) : invalidDate;
-  }
-  return dayjs.utc(value, dayjsFormat, true);
-};
-
-const offsetOf = (value: string): string | undefined => value.match(/([+-]\d{2}:?\d{2})$/)?.[1];
-
-const fromDayjs = (date: Dayjs): DateTime => new DateTime(date as unknown as DatetimeInput);
-
-const formatDateTime = (date: Dayjs): string => {
-  const formatted = date.format('YYYY-MM-DDTHH:mm:ss.SSSZ');
-  return timezoneOf(date) ? formatted : formatted.replace('+00:00', 'Z');
-};
-
-const change = (date: Dayjs, value: number | Duration, unit: DurationUnit, direction: 'add' | 'subtract'): Dayjs => {
-  if (isNumber(value)) return changeUnit(date, value, unit, direction);
-  return Object.entries(value).reduce((result, [durationUnit, durationValue]) => changeUnit(result, durationValue ?? 0, durationUnit as DurationUnit, direction), date);
-};
-
-const changeUnit = (date: Dayjs, value: number, unit: DurationUnit, direction: 'add' | 'subtract'): Dayjs => {
-  const amount = direction === 'add' ? value : -value;
-  const milliseconds = fixedUnitMilliseconds[unit];
-  const months = calendarUnitMonths[unit];
-
-  if (months && !Number.isInteger(value)) return addMonths(date, amount * months);
-  if (milliseconds && !Number.isInteger(value)) return date.add(amount * milliseconds, 'millisecond');
-  return date.add(amount, toDayjsUnit(unit));
-};
-
-const addMonths = (date: Dayjs, months: number): Dayjs => {
-  const wholeMonths = Math.trunc(months);
-  const fraction = months - wholeMonths;
-  const shifted = date.add(wholeMonths, 'month');
-  if (fraction === 0) return shifted;
-
-  const next = shifted.add(months > 0 ? 1 : -1, 'month');
-  return shifted.add((next.valueOf() - shifted.valueOf()) * Math.abs(fraction), 'millisecond');
-};
-
-const inOffsetZone = (date: Dayjs, offset: string): Dayjs => offsetToTimeZone(offset).map(zone => date.tz(zone)).or(date.utcOffset(offset));
-
-const offsetToTimeZone = (offset: string) =>
-  tryTo(() => {
-    const [, sign, hours, minutes] = offset.match(/^([+-])(\d{2}):?(\d{2})$/) ?? [];
-    if (minutes !== '00') throw new Error();
-    if (hours === '00') return 'UTC';
-    return `Etc/GMT${sign === '+' ? '-' : '+'}${Number(hours)}`;
-  });
-
-const toDayjsUnit = (unit: DurationUnit): ManipulateType => unit.replace(/s$/, '') as ManipulateType;
-
-const toDayjsBoundaryUnit = (unit: DateTimeUnit): OpUnitType => {
-  const dayjsUnit = toDayjsUnit(unit);
-  return (dayjsUnit === 'week' ? 'isoWeek' : dayjsUnit) as OpUnitType;
-};
-
-const toDayjsFormat = (format: string): string =>
-  format
-    .replace(/'([^']+)'/g, '[$1]')
-    .replace(/EEE/g, 'ddd')
-    .replace(/yyyy/g, 'YYYY')
-    .replace(/dd/g, 'DD')
-    .replace(/LLL/g, 'MMM')
-    .replace(/ZZZ/g, 'ZZ')
-    .replace(/hh/g, 'HH');
-
-const toDayjsLocale = (locale: string): string => locale.toLowerCase().split('-')[0];
-
-const formatWithIntl = (date: Dayjs, locale: string, options: Intl.DateTimeFormatOptions): string =>
-  new Intl.DateTimeFormat(locale, { ...options, timeZone: timezoneOf(date) ?? 'UTC' }).format(date.toDate());
-
-const timezoneOf = (date: Dayjs): string | undefined => (date as ZonedDayjs).$x?.$timezone;

package/src/types/ErrorOrigin.ts

@@ -1,7 +1,19 @@
-import { Text } from './Text';
-import { Exception } from './Exception';
-import { Response } from '../http/Response';
-import { Results } from './Results';
+import { asString, Text } from './Text';
+import { Exception, isException } from './Exception';
+import { isResponse, Response } from '../http/Response';
+import { isResults, Results } from './Results';
 import { Result } from './Result';
+import { choose } from './Case';
+import { isError, isString } from './Is';
+import { Optional } from './Types';
 
 export type ErrorOrigin = Text | Error | Exception | Response | Results | Result;
+
+export const errorMessage = (e: unknown): Optional<string> =>
+  choose(e)
+    .type(isResponse, r => r.body.error?.errors?.[0]?.message ?? r.body.error?.message)
+    .type(isException, ex => asString(ex.reason) || ex.message)
+    .type(isResults, rs => rs.results[0]?.message)
+    .type(isError, e => e.message)
+    .type(isString, s => s)
+    .else(() => undefined);