@actual-app/core 26.3.0

package/src/shared/rules.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest';
+
+import { getValidOps, isValidOp } from './rules';
+
+describe('rules', () => {
+  describe('isValidOp', () => {
+    it('should return false for oneOf operation on notes field', () => {
+      expect(isValidOp('notes', 'oneOf')).toBe(false);
+    });
+
+    it('should return false for notOneOf operation on notes field', () => {
+      expect(isValidOp('notes', 'notOneOf')).toBe(false);
+    });
+
+    it('should return true for valid string operations on notes field', () => {
+      expect(isValidOp('notes', 'is')).toBe(true);
+      expect(isValidOp('notes', 'isNot')).toBe(true);
+      expect(isValidOp('notes', 'contains')).toBe(true);
+      expect(isValidOp('notes', 'doesNotContain')).toBe(true);
+      expect(isValidOp('notes', 'matches')).toBe(true);
+      expect(isValidOp('notes', 'hasTags')).toBe(true);
+    });
+
+    it('should return true for oneOf operation on payee field', () => {
+      expect(isValidOp('payee', 'oneOf')).toBe(true);
+    });
+
+    it('should return true for notOneOf operation on payee field', () => {
+      expect(isValidOp('payee', 'notOneOf')).toBe(true);
+    });
+  });
+
+  describe('getValidOps', () => {
+    it('should not include oneOf and notOneOf for notes field', () => {
+      const validOps = getValidOps('notes');
+      expect(validOps).not.toContain('oneOf');
+      expect(validOps).not.toContain('notOneOf');
+    });
+
+    it('should include other valid string operations for notes field', () => {
+      const validOps = getValidOps('notes');
+      expect(validOps).toContain('is');
+      expect(validOps).toContain('isNot');
+      expect(validOps).toContain('contains');
+      expect(validOps).toContain('doesNotContain');
+      expect(validOps).toContain('matches');
+      expect(validOps).toContain('hasTags');
+    });
+
+    it('should include oneOf and notOneOf for payee field', () => {
+      const validOps = getValidOps('payee');
+      expect(validOps).toContain('oneOf');
+      expect(validOps).toContain('notOneOf');
+    });
+  });
+});

package/src/shared/rules.ts

@@ -0,0 +1,371 @@
+// @ts-strict-ignore
+import { t } from 'i18next';
+
+import type { FieldValueTypes, RuleConditionOp } from '../types/models';
+
+// For now, this info is duplicated from the backend. Figure out how
+// to share it later.
+const TYPE_INFO = {
+  date: {
+    ops: ['is', 'isapprox', 'gt', 'gte', 'lt', 'lte'],
+    nullable: false,
+  },
+  id: {
+    ops: [
+      'is',
+      'contains',
+      'matches',
+      'oneOf',
+      'isNot',
+      'doesNotContain',
+      'notOneOf',
+      'onBudget',
+      'offBudget',
+    ],
+    nullable: true,
+  },
+  saved: {
+    ops: [],
+    nullable: false,
+  },
+  string: {
+    ops: [
+      'is',
+      'contains',
+      'matches',
+      'oneOf',
+      'isNot',
+      'doesNotContain',
+      'notOneOf',
+      'hasTags',
+    ],
+    nullable: true,
+  },
+  number: {
+    ops: ['is', 'isapprox', 'isbetween', 'gt', 'gte', 'lt', 'lte'],
+    nullable: false,
+  },
+  boolean: {
+    ops: ['is'],
+    nullable: false,
+  },
+} as const;
+
+type FieldInfoConstraint = Record<
+  keyof FieldValueTypes,
+  {
+    type: keyof typeof TYPE_INFO;
+    disallowedOps?: Set<RuleConditionOp>;
+    internalOps?: Set<RuleConditionOp | 'and'>;
+  }
+>;
+
+const FIELD_INFO = {
+  imported_payee: {
+    type: 'string',
+    disallowedOps: new Set(['hasTags']),
+  },
+  payee: { type: 'id', disallowedOps: new Set(['onBudget', 'offBudget']) },
+  payee_name: { type: 'string' },
+  date: { type: 'date' },
+  notes: { type: 'string', disallowedOps: new Set(['oneOf', 'notOneOf']) },
+  amount: { type: 'number' },
+  category: {
+    type: 'id',
+    disallowedOps: new Set(['onBudget', 'offBudget']),
+    internalOps: new Set(['and']),
+  },
+  category_group: {
+    type: 'id',
+    disallowedOps: new Set(['onBudget', 'offBudget']),
+    internalOps: new Set(['and']),
+  },
+  account: { type: 'id' },
+  cleared: { type: 'boolean' },
+  reconciled: { type: 'boolean' },
+  saved: { type: 'saved' },
+  transfer: { type: 'boolean' },
+  parent: { type: 'boolean' },
+} as const satisfies FieldInfoConstraint;
+
+const fieldInfo: FieldInfoConstraint = FIELD_INFO;
+
+export const FIELD_TYPES = new Map<keyof FieldValueTypes, string>(
+  Object.entries(FIELD_INFO).map(([field, info]) => [
+    field as unknown as keyof FieldValueTypes,
+    info.type,
+  ]),
+);
+
+export function isValidOp(field: keyof FieldValueTypes, op: RuleConditionOp) {
+  const type = FIELD_TYPES.get(field);
+
+  if (!type) return false;
+  if (fieldInfo[field].disallowedOps?.has(op)) return false;
+
+  return (
+    TYPE_INFO[type].ops.includes(op) || fieldInfo[field].internalOps?.has(op)
+  );
+}
+
+export function getValidOps(field: keyof FieldValueTypes): RuleConditionOp[] {
+  const type = FIELD_TYPES.get(field);
+  if (!type) {
+    return [];
+  }
+  return TYPE_INFO[type].ops.filter(
+    op => !fieldInfo[field].disallowedOps?.has(op),
+  );
+}
+
+export function getAllocationMethods() {
+  return {
+    'fixed-amount': t('a fixed amount'),
+    'fixed-percent': t('a fixed percent of the remainder'),
+    remainder: t('an equal portion of the remainder'),
+  };
+}
+
+export function mapField(field, opts?) {
+  opts = opts || {};
+
+  switch (field) {
+    case 'imported_payee':
+      return t('imported payee');
+    case 'payee_name':
+      return t('payee (name)');
+    case 'amount':
+      if (opts.inflow) {
+        return t('amount (inflow)');
+      } else if (opts.outflow) {
+        return t('amount (outflow)');
+      }
+      return t('amount');
+    case 'amount-inflow':
+      return t('amount (inflow)');
+    case 'amount-outflow':
+      return t('amount (outflow)');
+    case 'account':
+      return t('account');
+    case 'date':
+      return t('date');
+    case 'category':
+      return t('category');
+    case 'category_group':
+      return t('category group');
+    case 'notes':
+      return t('notes');
+    case 'payee':
+      return t('payee');
+    case 'saved':
+      return t('saved');
+    case 'cleared':
+      return t('cleared');
+    case 'reconciled':
+      return t('reconciled');
+    case 'transfer':
+      return t('transfer');
+    default:
+      return field;
+  }
+}
+
+export function friendlyOp(op, type?) {
+  switch (op) {
+    case 'oneOf':
+      return t('one of');
+    case 'notOneOf':
+      return t('not one of');
+    case 'is':
+      return t('is');
+    case 'isNot':
+      return t('is not');
+    case 'isapprox':
+      return t('is approx');
+    case 'isbetween':
+      return t('is between');
+    case 'contains':
+      return t('contains');
+    case 'hasTags':
+      return t('has tags');
+    case 'matches':
+      return t('matches');
+    case 'doesNotContain':
+      return t('does not contain');
+    case 'gt':
+      if (type === 'date') {
+        return t('is after');
+      }
+      return t('is greater than');
+    case 'gte':
+      if (type === 'date') {
+        return t('is after or equals');
+      }
+      return t('is greater than or equals');
+    case 'lt':
+      if (type === 'date') {
+        return t('is before');
+      }
+      return t('is less than');
+    case 'lte':
+      if (type === 'date') {
+        return t('is before or equals');
+      }
+      return t('is less than or equals');
+    case 'true':
+      return t('is true');
+    case 'false':
+      return t('is false');
+    case 'set':
+      return t('set');
+    case 'set-split-amount':
+      return t('allocate');
+    case 'link-schedule':
+      return t('link schedule');
+    case 'prepend-notes':
+      return t('prepend to notes');
+    case 'append-notes':
+      return t('append to notes');
+    case 'and':
+      return t('and');
+    case 'or':
+      return t('or');
+    case 'onBudget':
+      return t('is on budget');
+    case 'offBudget':
+      return t('is off budget');
+    case 'delete-transaction':
+      return 'delete transaction';
+    default:
+      return '';
+  }
+}
+
+export function translateRuleStage(stage: string): string {
+  switch (stage) {
+    case 'pre':
+      return t('Pre');
+    case 'post':
+      return t('Post');
+    default:
+      return '';
+  }
+}
+
+export function deserializeField(field) {
+  if (field === 'amount-inflow') {
+    return { field: 'amount', options: { inflow: true } };
+  } else if (field === 'amount-outflow') {
+    return { field: 'amount', options: { outflow: true } };
+  } else {
+    return { field };
+  }
+}
+
+export function getFieldError(type) {
+  switch (type) {
+    case 'date-format':
+      return 'Invalid date format';
+    case 'no-null':
+    case 'no-empty-array':
+    case 'no-empty-string':
+      return 'Value cannot be empty';
+    case 'not-string':
+      return 'Value must be a string';
+    case 'not-boolean':
+      return 'Value must be a boolean';
+    case 'not-number':
+      return 'Value must be a number';
+    case 'invalid-field':
+      return 'Please choose a valid field for this type of rule';
+    case 'invalid-template':
+      return 'Invalid handlebars template';
+    default:
+      return 'Internal error, sorry! Please get in touch https://actualbudget.org/contact/ for support';
+  }
+}
+
+export function sortNumbers(num1, num2) {
+  if (num1 < num2) {
+    return [num1, num2];
+  }
+  return [num2, num1];
+}
+
+export function parse(item) {
+  if (item.op === 'set-split-amount') {
+    if (item.options.method === 'fixed-amount') {
+      return { ...item };
+    }
+    return item;
+  }
+
+  switch (item.type) {
+    case 'number': {
+      return { ...item };
+    }
+    case 'string': {
+      const parsed = item.value == null ? '' : item.value;
+      return { ...item, value: parsed };
+    }
+    case 'boolean': {
+      const parsed = item.value;
+      return { ...item, value: parsed };
+    }
+    default:
+  }
+
+  return { ...item, error: null };
+}
+
+export function unparse({ error: _error, inputKey: _inputKey, ...item }) {
+  if (item.op === 'set-split-amount') {
+    if (item.options.method === 'fixed-amount') {
+      return {
+        ...item,
+      };
+    }
+    if (item.options.method === 'fixed-percent') {
+      return {
+        ...item,
+        value: item.value && parseFloat(item.value),
+      };
+    }
+    return item;
+  }
+
+  switch (item.type) {
+    case 'number': {
+      return { ...item };
+    }
+    case 'string': {
+      const unparsed = item.value == null ? '' : item.value;
+      return { ...item, value: unparsed };
+    }
+    case 'boolean': {
+      const unparsed = item.value == null ? false : item.value;
+      return { ...item, value: unparsed };
+    }
+    default:
+  }
+
+  return item;
+}
+
+export function makeValue(value, cond) {
+  const isMulti = ['oneOf', 'notOneOf'].includes(cond.op);
+
+  if (isMulti) {
+    return { ...cond, error: null, value: value || [] };
+  }
+
+  if (cond.type === 'number' && value == null) {
+    return { ...cond, error: null, value: 0 };
+  }
+
+  return { ...cond, error: null, value };
+}
+
+export function getApproxNumberThreshold(number) {
+  return Math.round(Math.abs(number) * 0.075);
+}