@actual-app/core 26.3.0

package/src/shared/schedules.ts

@@ -0,0 +1,560 @@
+// @ts-strict-ignore
+import type { IRuleOptions } from '@rschedule/core';
+import * as d from 'date-fns';
+import type { Locale } from 'date-fns';
+import { t } from 'i18next';
+
+import type { PayeeEntity, RecurConfig, ScheduleEntity } from '#types/models';
+import { Condition } from '../server/rules';
+
+import * as monthUtils from './months';
+import { q } from './query';
+
+export function getStatus(
+  nextDate: string,
+  completed: boolean,
+  hasTrans: boolean,
+  upcomingLength: string = '7',
+) {
+  const upcomingDays = getUpcomingDays(upcomingLength);
+  const today = monthUtils.currentDay();
+  if (completed) {
+    return 'completed';
+  } else if (hasTrans) {
+    return 'paid';
+  } else if (nextDate === today) {
+    return 'due';
+  } else if (
+    nextDate > today &&
+    nextDate <= monthUtils.addDays(today, upcomingDays)
+  ) {
+    return 'upcoming';
+  } else if (nextDate < today) {
+    return 'missed';
+  } else {
+    return 'scheduled';
+  }
+}
+
+export function getStatusLabel(status: string) {
+  switch (status) {
+    case 'completed':
+      return t('completed');
+    case 'paid':
+      return t('paid');
+    case 'due':
+      return t('due');
+    case 'upcoming':
+      return t('upcoming');
+    case 'missed':
+      return t('missed');
+    case 'scheduled':
+      return t('scheduled');
+    default:
+      return t('unknown');
+  }
+}
+
+export function getHasTransactionsQuery(schedules) {
+  const filters = schedules.map(schedule => {
+    const dateCond = schedule._conditions?.find(c => c.field === 'date');
+    return {
+      $and: {
+        schedule: schedule.id,
+        date: {
+          $gte:
+            dateCond && dateCond.op === 'is'
+              ? schedule.next_date
+              : monthUtils.subDays(schedule.next_date, 2),
+        },
+      },
+    };
+  });
+
+  return q('transactions')
+    .options({ splits: 'all' })
+    .filter({ $or: filters })
+    .orderBy({ date: 'desc' })
+    .select(['schedule', 'date']);
+}
+
+function makeNumberSuffix(num: number, locale: Locale) {
+  // Slight abuse of date-fns to turn a number like "1" into the full
+  // form "1st" but formatting a date with that number
+  return monthUtils.format(new Date(2020, 0, num, 12), 'do', locale);
+}
+
+function prettyDayName(day) {
+  const days = {
+    SU: t('Sunday'),
+    MO: t('Monday'),
+    TU: t('Tuesday'),
+    WE: t('Wednesday'),
+    TH: t('Thursday'),
+    FR: t('Friday'),
+    SA: t('Saturday'),
+  };
+  return days[day];
+}
+
+export function getRecurringDescription(
+  config: RecurConfig,
+  dateFormat: string,
+  locale: Locale,
+) {
+  const interval = config.interval || 1;
+
+  let endModeSuffix = '';
+  switch (config.endMode) {
+    case 'after_n_occurrences':
+      if (config.endOccurrences === 1) {
+        endModeSuffix = t('once');
+      } else {
+        endModeSuffix = t('{{endOccurrences}} times', {
+          endOccurrences: config.endOccurrences,
+        });
+      }
+      break;
+    case 'on_date':
+      endModeSuffix = t('until {{dateFormatted}}', {
+        dateFormatted: monthUtils.format(config.endDate, dateFormat),
+      });
+      break;
+    default:
+      break;
+  }
+
+  const weekendSolveModeString = config.weekendSolveMode
+    ? config.weekendSolveMode === 'after'
+      ? t('(after weekend)')
+      : t('(before weekend)')
+    : '';
+
+  const weekendSolveSuffix = config.skipWeekend ? weekendSolveModeString : '';
+  const suffix = endModeSuffix
+    ? `, ${endModeSuffix} ${weekendSolveSuffix}`
+    : `${weekendSolveSuffix}`;
+
+  let desc = null;
+
+  switch (config.frequency) {
+    case 'daily':
+      desc =
+        interval !== 1
+          ? t(`Every {{interval}} days`, { interval })
+          : t('Every day');
+      break;
+    case 'weekly':
+      desc =
+        interval !== 1
+          ? t(`Every {{interval}} weeks on {{dateFormatted}}`, {
+              interval,
+              dateFormatted: monthUtils.format(config.start, 'EEEE', locale),
+            })
+          : t('Every week on {{dateFormatted}}', {
+              dateFormatted: monthUtils.format(config.start, 'EEEE', locale),
+            });
+      break;
+    case 'monthly':
+      if (config.patterns && config.patterns.length > 0) {
+        // Sort the days ascending. We filter out -1 because that
+        // represents "last days" and should always be last, but this
+        // sort would put them first
+        let patterns = [...config.patterns]
+          .sort((p1, p2) => {
+            const typeOrder =
+              (p1.type === 'day' ? 1 : 0) - (p2.type === 'day' ? 1 : 0);
+            const valOrder = p1.value - p2.value;
+
+            if (typeOrder === 0) {
+              return valOrder;
+            }
+            return typeOrder;
+          })
+          .filter(p => p.value !== -1);
+
+        // Add on all -1 values to the end
+        patterns = patterns.concat(config.patterns.filter(p => p.value === -1));
+
+        const strs: string[] = [];
+
+        const uniqueDays = new Set(patterns.map(p => p.type));
+        const isSameDay = uniqueDays.size === 1 && !uniqueDays.has('day');
+        for (const pattern of patterns) {
+          if (pattern.type === 'day') {
+            if (pattern.value === -1) {
+              strs.push(t('last day'));
+            } else {
+              // Example: 15th day
+              strs.push(makeNumberSuffix(pattern.value, locale));
+            }
+          } else {
+            const dayName = isSameDay ? '' : ' ' + prettyDayName(pattern.type);
+
+            if (pattern.value === -1) {
+              // Example: last Monday
+              strs.push(t('last') + dayName);
+            } else {
+              // Example: 3rd Monday
+              strs.push(makeNumberSuffix(pattern.value, locale) + dayName);
+            }
+          }
+        }
+
+        let range = '';
+        if (strs.length > 2) {
+          range += strs.slice(0, strs.length - 1).join(', ');
+          range += `, ${t('and')} `;
+          range += strs[strs.length - 1];
+        } else {
+          range += strs.join(` ${t('and')} `);
+        }
+
+        if (isSameDay) {
+          range += ' ' + prettyDayName(patterns[0].type);
+        }
+
+        desc =
+          interval !== 1
+            ? t(`Every {{interval}} months on the {{range}}`, {
+                interval,
+                range,
+              })
+            : t('Every month on the {{range}}', { range });
+      } else {
+        desc =
+          interval !== 1
+            ? t(`Every {{interval}} months on the {{dateFormatted}}`, {
+                interval,
+                dateFormatted: monthUtils.format(config.start, 'do', locale),
+              })
+            : t('Every month on the {{dateFormatted}}', {
+                dateFormatted: monthUtils.format(config.start, 'do', locale),
+              });
+      }
+      break;
+
+    case 'yearly':
+      desc =
+        interval !== 1
+          ? t(`Every {{interval}} years on {{dateFormatted}}`, {
+              interval,
+              dateFormatted: monthUtils.format(config.start, 'LLL do', locale),
+            })
+          : t('Every year on {{dateFormatted}}', {
+              dateFormatted: monthUtils.format(config.start, 'LLL do', locale),
+            });
+      break;
+
+    default:
+      return t('Recurring error');
+  }
+
+  return `${desc}${suffix}`.trim();
+}
+
+type ScheduleRuleOptions = IRuleOptions & {
+  frequency: string;
+  interval?: number;
+  byHourOfDay?: number[];
+};
+
+export function recurConfigToRSchedule(config) {
+  const base: ScheduleRuleOptions = {
+    start: monthUtils.parseDate(config.start),
+    frequency: config.frequency.toUpperCase(),
+    byHourOfDay: [12],
+  };
+
+  if (config.interval) {
+    base.interval = config.interval;
+  }
+
+  switch (config.endMode) {
+    case 'after_n_occurrences':
+      base.count = config.endOccurrences;
+      break;
+    case 'on_date':
+      base.end = monthUtils.parseDate(config.endDate);
+      break;
+    default:
+      break;
+  }
+
+  const abbrevDay = name => name.slice(0, 2).toUpperCase();
+
+  switch (config.frequency) {
+    case 'daily':
+      // Nothing to do
+      return [base];
+    case 'weekly':
+      // Nothing to do
+      return [base];
+    case 'monthly':
+      if (config.patterns && config.patterns.length > 0) {
+        const days = config.patterns.filter(p => p.type === 'day');
+        const dayNames = config.patterns.filter(p => p.type !== 'day');
+
+        return [
+          days.length > 0 && { ...base, byDayOfMonth: days.map(p => p.value) },
+          dayNames.length > 0 && {
+            ...base,
+            byDayOfWeek: dayNames.map(p => [abbrevDay(p.type), p.value]),
+          },
+        ].filter(Boolean);
+      } else {
+        // Nothing to do
+        return [base];
+      }
+    case 'yearly':
+      return [base];
+    default:
+      throw new Error('Invalid recurring date config');
+  }
+}
+
+export function extractScheduleConds(conditions) {
+  return {
+    payee:
+      conditions.find(cond => cond.op === 'is' && cond.field === 'payee') ||
+      conditions.find(
+        cond => cond.op === 'is' && cond.field === 'description',
+      ) ||
+      null,
+    account:
+      conditions.find(cond => cond.op === 'is' && cond.field === 'account') ||
+      conditions.find(cond => cond.op === 'is' && cond.field === 'acct') ||
+      null,
+    amount:
+      conditions.find(
+        cond =>
+          (cond.op === 'is' ||
+            cond.op === 'isapprox' ||
+            cond.op === 'isbetween') &&
+          cond.field === 'amount',
+      ) || null,
+    date:
+      conditions.find(
+        cond =>
+          (cond.op === 'is' || cond.op === 'isapprox') && cond.field === 'date',
+      ) || null,
+  };
+}
+
+export function getNextDate(
+  dateCond,
+  start = new Date(monthUtils.currentDay()),
+  noSkipWeekend = false,
+) {
+  start = d.startOfDay(start);
+
+  const cond = new Condition(dateCond.op, 'date', dateCond.value, null);
+  const value = cond.getValue();
+
+  if (value.type === 'date') {
+    return value.date;
+  } else if (value.type === 'recur') {
+    let dates = value.schedule.occurrences({ start, take: 1 }).toArray();
+
+    if (dates.length === 0) {
+      // Could be a schedule with limited occurrences, so we try to
+      // find the last occurrence
+      dates = value.schedule.occurrences({ reverse: true, take: 1 }).toArray();
+    }
+
+    if (dates.length > 0) {
+      let date = dates[0].date;
+      if (value.schedule.data.skipWeekend && !noSkipWeekend) {
+        date = getDateWithSkippedWeekend(
+          date,
+          value.schedule.data.weekendSolve,
+        );
+      }
+      return monthUtils.dayFromDate(date);
+    }
+  }
+  return null;
+}
+
+export function getDateWithSkippedWeekend(
+  date: Date,
+  solveMode: 'after' | 'before',
+) {
+  if (d.isWeekend(date)) {
+    if (solveMode === 'after') {
+      return d.nextMonday(date);
+    } else if (solveMode === 'before') {
+      return d.previousFriday(date);
+    } else {
+      throw new Error('Unknown weekend solve mode, this should not happen!');
+    }
+  }
+  return date;
+}
+
+export function getScheduledAmount(
+  amount: number | { num1: number; num2: number },
+  inverse: boolean = false,
+): number {
+  // this check is temporary, and required at the moment as a schedule rule
+  // allows the amount condition to be deleted which causes a crash
+  if (amount == null) return 0;
+
+  if (typeof amount === 'number') {
+    return inverse ? -amount : amount;
+  }
+  const avg = (amount.num1 + amount.num2) / 2;
+  return inverse ? -Math.round(avg) : Math.round(avg);
+}
+
+export function describeSchedule(
+  schedule: ScheduleEntity,
+  payee?: PayeeEntity,
+) {
+  if (payee) {
+    return `${payee.name} (${schedule.next_date})`;
+  } else {
+    return `${t('Next:')} ${schedule.next_date}`;
+  }
+}
+
+export function getUpcomingDays(
+  upcomingLength = '7',
+  today = monthUtils.currentDay(), // for testability
+): number {
+  const month = monthUtils.getMonth(today);
+
+  switch (upcomingLength) {
+    case 'currentMonth': {
+      const day = monthUtils.getDay(today);
+      const end = monthUtils.getDay(monthUtils.getMonthEnd(today));
+      return end - day;
+    }
+    case 'oneMonth': {
+      return monthUtils.differenceInCalendarDays(
+        monthUtils.nextMonth(month),
+        month,
+      );
+    }
+    default:
+      if (upcomingLength.includes('-')) {
+        const [num, unit] = upcomingLength.split('-');
+        const value = Math.max(1, parseInt(num, 10));
+        switch (unit) {
+          case 'day':
+            return value;
+          case 'week':
+            return value * 7;
+          case 'month':
+            const future = monthUtils.addMonths(today, value);
+            return monthUtils.differenceInCalendarDays(future, month) + 1;
+          case 'year':
+            const futureYear = monthUtils.addMonths(today, value * 12);
+            return monthUtils.differenceInCalendarDays(futureYear, month) + 1;
+          default:
+            return 7;
+        }
+      }
+      return parseInt(upcomingLength, 10);
+  }
+}
+
+export function scheduleIsRecurring(dateCond: Condition | null) {
+  if (!dateCond) {
+    return false;
+  }
+  const cond = new Condition(dateCond.op, 'date', dateCond.value, null);
+  const value = cond.getValue();
+
+  return value.type === 'recur';
+}
+
+export type ScheduleStatusType = ReturnType<typeof getStatus>;
+export type ScheduleStatuses = Map<ScheduleEntity['id'], ScheduleStatusType>;
+
+export function isForPreview(
+  schedule: ScheduleEntity,
+  statuses: ScheduleStatuses,
+) {
+  const status = statuses.get(schedule.id);
+  return (
+    !schedule.completed &&
+    ['due', 'upcoming', 'missed', 'paid'].includes(status!)
+  );
+}
+
+export function computeSchedulePreviewTransactions(
+  schedules: readonly ScheduleEntity[],
+  statuses: ScheduleStatuses,
+  upcomingLength?: string,
+  filter?: (schedule: ScheduleEntity) => boolean,
+) {
+  const schedulesForPreview = schedules
+    .filter(s => isForPreview(s, statuses))
+    .filter(filter ? filter : () => true);
+
+  const today = d.startOfDay(monthUtils.parseDate(monthUtils.currentDay()));
+
+  const upcomingPeriodEnd = d.startOfDay(
+    monthUtils.parseDate(
+      monthUtils.addDays(today, getUpcomingDays(upcomingLength)),
+    ),
+  );
+
+  return schedulesForPreview
+    .flatMap(schedule => {
+      const { date: dateConditions } = extractScheduleConds(
+        schedule._conditions,
+      );
+
+      const status = statuses.get(schedule.id);
+      const isRecurring = scheduleIsRecurring(dateConditions);
+
+      const dates = [schedule.next_date];
+      let day = d.startOfDay(monthUtils.parseDate(schedule.next_date));
+      if (isRecurring) {
+        while (day <= upcomingPeriodEnd) {
+          const nextDate = getNextDate(dateConditions, day);
+
+          if (
+            d.startOfDay(monthUtils.parseDate(nextDate)) > upcomingPeriodEnd
+          ) {
+            break;
+          }
+
+          if (dates.includes(nextDate)) {
+            day = d.startOfDay(
+              monthUtils.parseDate(monthUtils.addDays(day, 1)),
+            );
+            continue;
+          }
+
+          dates.push(nextDate);
+          day = d.startOfDay(
+            monthUtils.parseDate(monthUtils.addDays(nextDate, 1)),
+          );
+        }
+      }
+
+      if (status === 'paid') {
+        dates.shift();
+      }
+
+      return dates.map(date => ({
+        id: 'preview/' + schedule.id + `/${date}`,
+        payee: schedule._payee,
+        account: schedule._account,
+        amount: getScheduledAmount(schedule._amount),
+        date,
+        schedule: schedule.id,
+        forceUpcoming:
+          (date !== schedule.next_date || status === 'paid') &&
+          date >= monthUtils.currentDay(),
+      }));
+    })
+    .sort(
+      (a, b) =>
+        monthUtils.parseDate(b.date).getTime() -
+          monthUtils.parseDate(a.date).getTime() || a.amount - b.amount,
+    );
+}

package/src/shared/test-helpers.ts

@@ -0,0 +1,156 @@
+import { logger } from '../platform/server/log';
+
+export let tracer: null | ReturnType<typeof execTracer> = null;
+
+function timeout<T extends Promise<unknown>>(promise: T, n: number) {
+  let resolve: (response: string) => void;
+  const timeoutPromise = new Promise<string>(_ => (resolve = _));
+  const timer = setTimeout(() => resolve(`timeout(${n})`), n);
+
+  return Promise.race([
+    promise.then(res => {
+      clearTimeout(timer);
+      return res;
+    }),
+    timeoutPromise,
+  ]);
+}
+
+export function resetTracer() {
+  tracer = execTracer();
+}
+
+export function execTracer<T>() {
+  const queue: Array<{ name: string; data?: T | undefined }> = [];
+  let hasStarted = false;
+  let waitingFor: null | {
+    name: string;
+    reject: (error: Error) => void;
+    resolve: (data?: T) => void;
+  } = null;
+  let ended = false;
+
+  const log = false;
+
+  return {
+    event(name: string, data?: T) {
+      if (!hasStarted) {
+        return;
+      } else if (log) {
+        logger.log(`--- event(${name}, ${JSON.stringify(data)}) ---`);
+      }
+
+      if (ended) {
+        throw new Error(
+          `Tracer received event but didn't expect it: ${name} with data: ${JSON.stringify(
+            data,
+          )}`,
+        );
+      } else if (waitingFor) {
+        if (waitingFor.name !== name) {
+          waitingFor.reject(
+            new Error(
+              `Event traced "${name}" but expected "${waitingFor.name}"`,
+            ),
+          );
+        } else {
+          waitingFor.resolve(data);
+        }
+        waitingFor = null;
+      } else {
+        queue.push({ name, data });
+      }
+    },
+
+    wait(name: string) {
+      if (waitingFor) {
+        throw new Error(
+          `Already waiting for ${waitingFor.name}, cannot wait for multiple events`,
+        );
+      }
+
+      return new Promise((resolve, reject) => {
+        waitingFor = { resolve, reject, name };
+      });
+    },
+
+    expectWait(name: string, data?: T) {
+      if (!hasStarted) {
+        throw new Error(`Expected "${name}" but tracer hasn't started yet`);
+      } else if (log) {
+        logger.log(`--- expectWait(${name}) ---`);
+      }
+
+      const promise = this.wait(name);
+      if (data === undefined) {
+        // We want to ignore the result
+        return expect(
+          timeout(
+            promise.then(() => true),
+            1000,
+          ),
+        ).resolves.toEqual(true);
+      }
+
+      if (typeof data === 'function') {
+        return expect(timeout(promise, 1000))
+          .resolves.toBeTruthy()
+          .then(() => promise)
+          .then(res => data(res));
+      } else {
+        // We use this form because it tracks the right location in the
+        // test when it fails. It's annoying to always write this in the
+        // test though, so this provides a clean API. The right line
+        // number in the test will show up in the stack.
+        return expect(timeout(promise, 1000)).resolves.toEqual(data);
+      }
+    },
+
+    expectNow(name: string, data?: T) {
+      if (!hasStarted) {
+        throw new Error(`Expected "${name}" but tracer hasn't started yet`);
+      } else if (log) {
+        logger.log(`--- expectNow(${name}) ---`);
+      }
+
+      const entry = queue.shift();
+
+      if (!entry) {
+        throw new Error(
+          `Expected event "${name}" but none found - has it happened yet?`,
+        );
+      } else if (entry.name === name) {
+        if (typeof data === 'function') {
+          data(entry.data);
+        } else {
+          expect(entry.data).toEqual(data);
+        }
+      } else {
+        throw new Error(
+          `Event traced "${queue[0].name}" but expected "${name}"`,
+        );
+      }
+    },
+
+    expect(name: string, data?: T) {
+      if (queue.length === 0) {
+        return this.expectWait(name, data);
+      }
+      return this.expectNow(name, data);
+    },
+
+    start() {
+      hasStarted = true;
+    },
+
+    end() {
+      if (hasStarted && queue.length !== 0) {
+        const str = queue.map(x => JSON.stringify(x));
+        throw new Error(
+          'Event tracer ended with existing events: ' + str.join('\n\n'),
+        );
+      }
+      ended = true;
+    },
+  };
+}