refactor: fill in basic types in rules.ts

packages/loot-core/src/server/accounts/rules.ts

@@ -19,11 +19,11 @@ import {
   ungroupTransaction,
 } from '../../shared/transactions';
 import { fastSetMerge } from '../../shared/util';
-import { RuleConditionEntity } from '../../types/models';
+import { RuleConditionEntity, RuleEntity } from '../../types/models';
 import { RuleError } from '../errors';
 import { Schedule as RSchedule } from '../util/rschedule';
 
-function assert(test, type, msg) {
+function assert(test: unknown, type: string, msg: string): asserts test {
   if (!test) {
     throw new RuleError(type, msg);
   }
@@ -726,10 +726,10 @@ export function execActions(actions: Action[], transaction) {
 }
 
 export class Rule {
-  actions;
-  conditions;
+  actions: Action[];
+  conditions: Condition[];
   conditionsOp;
-  id;
+  id?: string;
   stage;
 
   constructor({
@@ -758,7 +758,7 @@ export class Rule {
     );
   }
 
-  evalConditions(object) {
+  evalConditions(object): boolean {
     if (this.conditions.length === 0) {
       return false;
     }
@@ -795,11 +795,11 @@ export class Rule {
     return Object.assign({}, object, changes);
   }
 
-  getId() {
+  getId(): string | undefined {
     return this.id;
   }
 
-  serialize() {
+  serialize(): RuleEntity {
     return {
       id: this.id,
       stage: this.stage,
@@ -811,28 +811,28 @@ export class Rule {
 }
 
 export class RuleIndexer {
-  field;
-  method;
-  rules;
+  field: string;
+  method?: string;
+  rules: Map<string, Set<Rule>>;
 
   constructor({ field, method }: { field: string; method?: string }) {
     this.field = field;
     this.method = method;
     this.rules = new Map();
   }
 
-  getIndex(key) {
+  getIndex(key: string): Set<Rule> {
     if (!this.rules.has(key)) {
       this.rules.set(key, new Set());
     }
     return this.rules.get(key);
   }
 
-  getIndexForValue(value) {
+  getIndexForValue(value: unknown): Set<Rule> {
     return this.getIndex(this.getKey(value) || '*');
   }
 
-  getKey(value) {
+  getKey(value: unknown): string | null {
     if (typeof value === 'string' && value !== '') {
       if (this.method === 'firstchar') {
         return value[0].toLowerCase();
@@ -842,7 +842,7 @@ export class RuleIndexer {
     return null;
   }
 
-  getIndexes(rule) {
+  getIndexes(rule: Rule): Set<Rule>[] {
     const cond = rule.conditions.find(cond => cond.field === this.field);
     const indexes = [];
 
@@ -865,21 +865,21 @@ export class RuleIndexer {
     return indexes;
   }
 
-  index(rule) {
+  index(rule: Rule): void {
     const indexes = this.getIndexes(rule);
     indexes.forEach(index => {
       index.add(rule);
     });
   }
 
-  remove(rule) {
+  remove(rule: Rule): void {
     const indexes = this.getIndexes(rule);
     indexes.forEach(index => {
       index.delete(rule);
     });
   }
 
-  getApplicableRules(object) {
+  getApplicableRules(object): Set<Rule> {
     let indexedRules;
     if (this.field in object) {
       const key = this.getKey(object[this.field]);
@@ -912,7 +912,7 @@ const OP_SCORES: Record<RuleConditionEntity['op'], number> = {
   hasTags: 0,
 };
 
-function computeScore(rule) {
+function computeScore(rule: Rule): number {
   const initialScore = rule.conditions.reduce((score, condition) => {
     if (OP_SCORES[condition.op] == null) {
       console.log(`Found invalid operation while ranking: ${condition.op}`);
@@ -937,7 +937,7 @@ function computeScore(rule) {
   return initialScore;
 }
 
-function _rankRules(rules) {
+function _rankRules(rules: Rule[]): Rule[] {
   const scores = new Map();
   rules.forEach(rule => {
     scores.set(rule, computeScore(rule));
@@ -961,7 +961,7 @@ function _rankRules(rules) {
   });
 }
 
-export function rankRules(rules) {
+export function rankRules(rules: Iterable<Rule>): Rule[] {
   let pre = [];
   let normal = [];
   let post = [];
@@ -986,7 +986,7 @@ export function rankRules(rules) {
   return pre.concat(normal).concat(post);
 }
 
-export function migrateIds(rule, mappings) {
+export function migrateIds(rule: Rule, mappings: Map<string, string>): void {
   // Go through the in-memory rules and patch up ids that have been
   // "migrated" to other ids. This is a little tricky, but a lot
   // easier than trying to keep an up-to-date mapping in the db. This
@@ -1038,7 +1038,11 @@ export function migrateIds(rule, mappings) {
 }
 
 // This finds all the rules that reference the `id`
-export function iterateIds(rules, fieldName, func) {
+export function iterateIds(
+  rules: Rule[],
+  fieldName: string,
+  func: (rule: Rule, id: string) => unknown,
+): void {
   let i;
 
   ruleiter: for (i = 0; i < rules.length; i++) {

packages/loot-core/src/server/accounts/transaction-rules.ts

@@ -567,7 +567,7 @@ export async function applyActions(
 }
 
 export function getRulesForPayee(payeeId) {
-  const rules = new Set();
+  const rules = new Set<Rule>();
   iterateIds(getRules(), 'payee', (rule, id) => {
     if (id === payeeId) {
       rules.add(rule);

packages/loot-core/src/types/models/rule.d.ts

@@ -2,7 +2,7 @@ import { type ScheduleEntity } from './schedule';
 
 export interface NewRuleEntity {
   stage: string;
-  conditionsOp: 'any' | 'and';
+  conditionsOp: 'or' | 'and';
   conditions: RuleConditionEntity[];
   actions: RuleActionEntity[];
   tombstone?: boolean;

upcoming-release-notes/3365.md

@@ -0,0 +1,6 @@
+---
+category: Maintenance
+authors: [UnderKoen]
+---
+
+Add more strict types to `account/rules.ts`