feat: Expression extension framework (#4372)

*  Introduce a framework for expression extension

* 💡 Add some inline comments

*  Introduce hash alias for encrypt

*  Introduce a manual granular level approach to shadowing/overrideing extensions

* 🔥 Cleanup comments

*  Introduce a basic method of extension for native functions

*  Add length to StringExtension

*  Add number type to extension return types

*  Temporarily introduce DateTime with extension

*  Cleanup comments

*  Organize imports

* ♻️ Fix up some typings

*  Fix typings

* ♻️ Remove unnecessary resolve of expression

*  Extensions Improvement

* ♻️ Refactor EXPRESSION_EXTENSION_METHODS

* ♻️ Refactor EXPRESSION_EXTENSION_METHODS

* ♻️ Update extraArgs types

* ♻️ Fix tests

* ♻️ Fix bind type issue

* ♻️ Fixing duration type issue

* ♻️ Refactor to allow overrides on native methods

* ♻️ Temporarily remove Date Extensions to pass tests

* feat(dt-functions): introduce date expression extensions (#4045)

* 🎉 Add Date Extensions into the mix

*  Introduce additional date extension methods

*  Add Date Expression Extension tests

* 🔧 Add ability to debug tests

* ♻️ Refactor extension for native types

* 🔥 Move sayHi method to String Extension class

* ♻️ Update scope when binding member methods

*  Add String Extension tests

* feat(dt-functions): introduce array expression extensions (#4044)

*  Introduce Array Extensions

*  Add Array Expression tests

* feat(dt-functions): introduce number expression extensions (#4046)

* 🎉 Introduce Number Extensions

*  Support more shared extensions

*  Improve handling of name collision

*  Update tests

* Fixed up tests

* 🔥 Remove remove markdown

* :recylce: Replace remove-markdown dependencies with implementation

* ♻️ Replace remove-markdown dependencies with implementation

*  Update tests

* ♻️ Fix scoping and cleanup

* ♻️ Update comments and errors

* ♻️ Fix linting errors

*  Remove unused dependencies

* fix: expression extension not working with multiple extensions

* refactor: change extension transform to be more efficient

* test: update most test to work with new extend function

* fix: update and fix type error in config

* refactor: replace babel with recast

* feat: add hashing functions to string extension

* fix: removed export

* test: add extension parser and transform tests

* fix: vite tests breaking

* refactor: remove commented out code

* fix: parse dates passed from $json in extend function

* refactor: review feedback changes for date extensions

* refactor: review feedback changes for number extensions

* fix: date extension beginningOf test

* fix: broken build from merge

* fix: another merge issue

* refactor: address review feedback (remove ignores)

* feat: new extension functions and tests

* feat: non-dot notation functions

* test: most of the other tests

* fix: toSentenceCase for node versions below 16.6

* feat: add $if and $not expression extensions

* Fix test to work on every timezone

* lint: fix remaining lint issues

Co-authored-by: Csaba Tuncsik <csaba@n8n.io>
Co-authored-by: Omar Ajoue <krynble@gmail.com>
This commit is contained in:
Valya
2023-01-10 13:06:12 +00:00
committed by GitHub
parent 871a1d7dad
commit 3d05acf313
25 changed files with 2529 additions and 5 deletions

View File

@@ -0,0 +1,268 @@
/* eslint-disable @typescript-eslint/unbound-method */
/* eslint-disable @typescript-eslint/explicit-member-accessibility */
import {
DateTime,
DateTimeFormatOptions,
DateTimeUnit,
Duration,
DurationObjectUnits,
LocaleOptions,
} from 'luxon';
import type { ExtensionMap } from './Extensions';
type DurationUnit =
| 'milliseconds'
| 'seconds'
| 'minutes'
| 'hours'
| 'days'
| 'weeks'
| 'months'
| 'quarter'
| 'years';
type DatePart =
| 'day'
| 'month'
| 'year'
| 'hour'
| 'minute'
| 'second'
| 'millisecond'
| 'weekNumber'
| 'yearDayNumber'
| 'weekday';
const DURATION_MAP: Record<string, DurationUnit> = {
day: 'days',
month: 'months',
year: 'years',
week: 'weeks',
hour: 'hours',
minute: 'minutes',
second: 'seconds',
millisecond: 'milliseconds',
ms: 'milliseconds',
sec: 'seconds',
secs: 'seconds',
hr: 'hours',
hrs: 'hours',
min: 'minutes',
mins: 'minutes',
};
const DATETIMEUNIT_MAP: Record<string, DateTimeUnit> = {
days: 'day',
months: 'month',
years: 'year',
hours: 'hour',
minutes: 'minute',
seconds: 'second',
milliseconds: 'millisecond',
hrs: 'hour',
hr: 'hour',
mins: 'minute',
min: 'minute',
secs: 'second',
sec: 'second',
ms: 'millisecond',
};
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function isDateTime(date: any): date is DateTime {
if (date) {
// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
return DateTime.isDateTime(date);
}
return false;
}
function generateDurationObject(durationValue: number, unit: DurationUnit) {
const convertedUnit = DURATION_MAP[unit] || unit;
return { [`${convertedUnit}`]: durationValue } as DurationObjectUnits;
}
function beginningOf(date: Date | DateTime, extraArgs: DurationUnit[]): Date {
const [unit = 'week'] = extraArgs;
if (isDateTime(date)) {
return date.startOf(DATETIMEUNIT_MAP[unit] || unit).toJSDate();
}
let datetime = DateTime.fromJSDate(date);
if (date.getTimezoneOffset() === 0) {
datetime = datetime.setZone('UTC');
}
return datetime.startOf(DATETIMEUNIT_MAP[unit] || unit).toJSDate();
}
function endOfMonth(date: Date | DateTime): Date {
if (isDateTime(date)) {
return date.endOf('month').toJSDate();
}
return DateTime.fromJSDate(date).endOf('month').toJSDate();
}
function extract(inputDate: Date | DateTime, extraArgs: DatePart[]): number | Date {
const [part] = extraArgs;
let date = inputDate;
if (isDateTime(date)) {
date = date.toJSDate();
}
if (part === 'yearDayNumber') {
const firstDayOfTheYear = new Date(date.getFullYear(), 0, 0);
const diff =
date.getTime() -
firstDayOfTheYear.getTime() +
(firstDayOfTheYear.getTimezoneOffset() - date.getTimezoneOffset()) * 60 * 1000;
return Math.floor(diff / (1000 * 60 * 60 * 24));
}
return DateTime.fromJSDate(date).get((DATETIMEUNIT_MAP[part] as keyof DateTime) || part);
}
function format(date: Date | DateTime, extraArgs: unknown[]): string {
const [dateFormat, localeOpts = {}] = extraArgs as [string, LocaleOptions];
if (isDateTime(date)) {
return date.toFormat(dateFormat, { ...localeOpts });
}
return DateTime.fromJSDate(date).toFormat(dateFormat, { ...localeOpts });
}
function isBetween(date: Date | DateTime, extraArgs: unknown[]): boolean {
const [first, second] = extraArgs as string[];
const firstDate = new Date(first);
const secondDate = new Date(second);
if (firstDate > secondDate) {
return secondDate < date && date < firstDate;
}
return secondDate > date && date > firstDate;
}
function isDst(date: Date): boolean {
return DateTime.fromJSDate(date).isInDST;
}
function isInLast(date: Date | DateTime, extraArgs: unknown[]): boolean {
const [durationValue = 0, unit = 'minutes'] = extraArgs as [number, DurationUnit];
const dateInThePast = DateTime.now().minus(generateDurationObject(durationValue, unit));
let thisDate = date;
if (!isDateTime(thisDate)) {
thisDate = DateTime.fromJSDate(thisDate);
}
return dateInThePast <= thisDate && thisDate <= DateTime.now();
}
function isWeekend(date: Date): boolean {
enum DAYS {
saturday = 6,
sunday = 7,
}
return [DAYS.saturday, DAYS.sunday].includes(DateTime.fromJSDate(date).weekday);
}
function minus(date: Date | DateTime, extraArgs: unknown[]): Date {
const [durationValue = 0, unit = 'minutes'] = extraArgs as [number, DurationUnit];
if (isDateTime(date)) {
return date.minus(generateDurationObject(durationValue, unit)).toJSDate();
}
return DateTime.fromJSDate(date).minus(generateDurationObject(durationValue, unit)).toJSDate();
}
function plus(date: Date | DateTime, extraArgs: unknown[]): Date {
const [durationValue = 0, unit = 'minutes'] = extraArgs as [number, DurationUnit];
if (isDateTime(date)) {
return date.plus(generateDurationObject(durationValue, unit)).toJSDate();
}
return DateTime.fromJSDate(date).plus(generateDurationObject(durationValue, unit)).toJSDate();
}
function toLocaleString(date: Date | DateTime, extraArgs: unknown[]): string {
const [locale, dateFormat = { timeStyle: 'short', dateStyle: 'short' }] = extraArgs as [
string | undefined,
DateTimeFormatOptions,
];
if (isDateTime(date)) {
return date.toLocaleString(dateFormat, { locale });
}
return DateTime.fromJSDate(date).toLocaleString(dateFormat, { locale });
}
function toTimeFromNow(date: Date): string {
let diffObj: Duration;
if (isDateTime(date)) {
diffObj = date.diffNow();
} else {
diffObj = DateTime.fromJSDate(date).diffNow();
}
const as = (unit: DurationUnit) => {
return Math.round(Math.abs(diffObj.as(unit)));
};
if (as('years')) {
return `${as('years')} years ago`;
}
if (as('months')) {
return `${as('months')} months ago`;
}
if (as('weeks')) {
return `${as('weeks')} weeks ago`;
}
if (as('days')) {
return `${as('days')} days ago`;
}
if (as('hours')) {
return `${as('hours')} hours ago`;
}
if (as('minutes')) {
return `${as('minutes')} minutes ago`;
}
if (as('seconds') && as('seconds') > 10) {
return `${as('seconds')} seconds ago`;
}
return 'just now';
}
function timeTo(date: Date | DateTime, extraArgs: unknown[]): Duration {
const [diff = new Date().toISOString(), unit = 'seconds'] = extraArgs as [string, DurationUnit];
const diffDate = new Date(diff);
if (isDateTime(date)) {
return date.diff(DateTime.fromJSDate(diffDate), DURATION_MAP[unit] || unit);
}
return DateTime.fromJSDate(date).diff(DateTime.fromJSDate(diffDate), DURATION_MAP[unit] || unit);
}
function toDate(date: Date | DateTime) {
if (isDateTime(date)) {
return date.set({ hour: 0, minute: 0, second: 0, millisecond: 0 }).toJSDate();
}
let datetime = DateTime.fromJSDate(date);
if (date.getTimezoneOffset() === 0) {
datetime = datetime.setZone('UTC');
}
return datetime.set({ hour: 0, minute: 0, second: 0, millisecond: 0 }).toJSDate();
}
export const dateExtensions: ExtensionMap = {
typeName: 'Date',
functions: {
beginningOf,
endOfMonth,
extract,
isBetween,
isDst,
isInLast,
isWeekend,
minus,
plus,
toTimeFromNow,
timeTo,
format,
toLocaleString,
toDate,
},
};