fixes

packages/desktop-client/src/components/filters/AppliedFilters.tsx

@@ -10,7 +10,7 @@ export type Filter = {
   field: string;
   op: string;
   value: string | number;
-  options: { inflow: boolean; outflow: boolean };
+  options: { inflow: boolean; outflow: boolean; month?: string; year?: string };
   customName?: string;
 };
 

packages/desktop-client/src/components/filters/ConfigureField.tsx

@@ -4,6 +4,10 @@ import { FocusScope } from '@react-aria/focus';
 
 import { mapField, FIELD_TYPES, TYPE_INFO } from 'loot-core/src/shared/rules';
 import { titleFirst } from 'loot-core/src/shared/util';
+import {
+  type RuleConditionEntity,
+  type setOp,
+} from 'loot-core/src/types/models';
 
 import { theme } from '../../style';
 import { Button } from '../common/Button';
@@ -19,10 +23,10 @@ import { subfieldToOptions } from './subfieldToOptions';
 type ConfigureFieldProps = {
   field: string;
   initialSubfield?: string;
-  op: string;
+  op?: string;
   value: string | number;
-  dispatch: Dispatch<{ type: string; op?: string; value?: string | number }>;
-  onApply: ({ field, op, value, options }) => void;
+  dispatch: Dispatch<RuleConditionEntity>;
+  onApply: (cond: RuleConditionEntity) => void;
 };
 
 export function ConfigureField({
@@ -44,6 +48,7 @@ export function ConfigureField({
     // prevOp.current = op;
   }, [op]);
 
+  let opTest: setOp;
   const type: string | undefined = FIELD_TYPES.get(field);
   let ops: Array<string> = TYPE_INFO[type].ops.filter(
     (op: string) => op !== 'isbetween',
@@ -150,7 +155,9 @@ export function ConfigureField({
                     key={currOp}
                     op={currOp}
                     selected={currOp === op}
-                    onClick={() => dispatch({ type: 'set-op', op: currOp })}
+                    onClick={() =>
+                      dispatch({ type: 'set-op', op: { ...opTest, currOp } })
+                    }
                   />
                 ))}
               </Stack>

packages/desktop-client/src/components/filters/FilterButton.tsx

@@ -19,6 +19,10 @@ import {
   TYPE_INFO,
 } from 'loot-core/src/shared/rules';
 import { titleFirst } from 'loot-core/src/shared/util';
+import {
+  type TransactionFilterEntity,
+  type RuleConditionEntity,
+} from 'loot-core/src/types/models';
 
 import { theme } from '../../style';
 import { HoverTarget } from '../common/HoverTarget';
@@ -27,6 +31,7 @@ import { Text } from '../common/Text';
 import { View } from '../common/View';
 import { Tooltip } from '../tooltips';
 
+import { type Filter } from './AppliedFilters';
 import { CompactFiltersButton } from './CompactFiltersButton';
 import { ConfigureField } from './ConfigureField';
 import { FiltersButton } from './FiltersButton';
@@ -51,29 +56,29 @@ type FilterButtonProps = {
 };
 
 export function FilterButton({ onApply, compact, hover }: FilterButtonProps) {
-  const filters = useFilters();
+  const filters: Filter[] | TransactionFilterEntity[] = useFilters();
 
-  const { dateFormat } = useSelector((state: any) => {
+  const { dateFormat } = useSelector((state: { prefs: any }) => {
     return {
       dateFormat: state.prefs.local.dateFormat ?? 'MM/dd/yyyy',
     };
   });
 
   const [state, dispatch] = useReducer(
-    (state: any, action: any) => {
+    (state: object, action: RuleConditionEntity) => {
       switch (action.type) {
         case 'select-field':
           return { ...state, fieldsOpen: true, condOpen: false };
         case 'configure': {
           const { field } = deserializeField(action.field);
           const type: string | undefined = FIELD_TYPES.get(field);
-          const info: any = TYPE_INFO.find(f => f.name === type);
+          const info: string = TYPE_INFO.find(f => f.name === type).ops[0];
           return {
             ...state,
             fieldsOpen: false,
             condOpen: true,
             field: action.field,
-            op: info.ops[0],
+            op: info,
             value: type === 'boolean' ? true : null,
           };
         }
@@ -86,13 +91,22 @@ export function FilterButton({ onApply, compact, hover }: FilterButtonProps) {
     { fieldsOpen: false, condOpen: false, field: null, value: null },
   );
 
-  async function onValidateAndApply(cond: any) {
-    cond = unparse({ ...cond, type: FIELD_TYPES.get(cond.field) });
+  async function onValidateAndApply(cond: RuleConditionEntity) {
+    const valueIsString: string = typeof cond.value === 'string' && cond.value;
+    const saveItem: RuleConditionEntity = {
+      ...cond,
+      type: FIELD_TYPES.get(cond.field),
+    };
+    cond = unparse({ item: saveItem });
 
-    if (cond.type === 'date' && cond.options) {
+    if (
+      cond.type === 'date' &&
+      typeof cond.value !== 'number' &&
+      cond.options
+    ) {
       if (cond.options.month) {
         const date = parseDate(
-          cond.value,
+          valueIsString,
           getMonthYearFormat(dateFormat),
           new Date(),
         );
@@ -103,7 +117,7 @@ export function FilterButton({ onApply, compact, hover }: FilterButtonProps) {
           return;
         }
       } else if (cond.options.year) {
-        const date = parseDate(cond.value, 'yyyy', new Date());
+        const date = parseDate(valueIsString, 'yyyy', new Date());
         if (isDateValid(date)) {
           cond.value = formatDate(date, 'yyyy');
         } else {

packages/desktop-client/src/components/filters/FilterEditor.tsx

@@ -1,7 +1,9 @@
 import React, { useReducer } from 'react';
 
 import { unparse, FIELD_TYPES } from 'loot-core/src/shared/rules';
+import { type RuleConditionEntity } from 'loot-core/src/types/models';
 
+import { type Filter } from './AppliedFilters';
 import { ConfigureField } from './ConfigureField';
 import { subfieldFromFilter } from './subfieldFromFilter';
 import { updateFilterReducer } from './updateFilterReducer';
@@ -11,7 +13,7 @@ type FilterEditorProps = {
   op: string;
   value: string | number;
   options: { inflow: boolean; outflow: boolean };
-  onSave: ({field, op, value, options}) => void;
+  onSave: (cond: RuleConditionEntity) => Filter;
   onClose: () => void;
 };
 
@@ -24,7 +26,7 @@ export function FilterEditor({
   onClose,
 }: FilterEditorProps) {
   const [state, dispatch] = useReducer(
-    (state: any, action: any) => {
+    (state: any, action: RuleConditionEntity) => {
       switch (action.type) {
         case 'close':
           onClose();
@@ -43,8 +45,12 @@ export function FilterEditor({
       op={state.op}
       value={state.value}
       dispatch={dispatch}
-      onApply={cond => {
-        cond = unparse({ ...cond, type: FIELD_TYPES.get(cond.field) });
+      onApply={(cond: RuleConditionEntity) => {
+        const saveItem: RuleConditionEntity = {
+          ...cond,
+          type: FIELD_TYPES.get(cond.field),
+        };
+        cond = unparse({ item: saveItem });
         onSave(cond);
         onClose();
       }}

packages/desktop-client/src/components/filters/FilterExpression.tsx

@@ -2,6 +2,7 @@ import React, { useState } from 'react';
 
 import { mapField, friendlyOp } from 'loot-core/src/shared/rules';
 import { integerToCurrency } from 'loot-core/src/shared/util';
+import { type RuleConditionEntity } from 'loot-core/src/types/models';
 
 import { SvgDelete } from '../../icons/v0';
 import { type CSSProperties, theme } from '../../style';
@@ -10,6 +11,7 @@ import { Text } from '../common/Text';
 import { View } from '../common/View';
 import { Value } from '../rules/Value';
 
+import { type Filter } from './AppliedFilters';
 import { FilterEditor } from './FilterEditor';
 import { subfieldFromFilter } from './subfieldFromFilter';
 
@@ -18,9 +20,9 @@ type FilterExpressionProps = {
   customName: string;
   op: string;
   value: string | number;
-  options: { inflow: any; outflow: any };
+  options: RuleConditionEntity['options'];
   style?: CSSProperties;
-  onChange: (newFilter: any) => void;
+  onChange: (cond: RuleConditionEntity) => Filter;
   onDelete: () => void;
 };
 

packages/desktop-client/src/components/filters/subfieldFromFilter.ts

@@ -1,27 +1,25 @@
-type subfieldFromFilterProps = {
-  field: string;
-  value: string | number;
-  options?: { inflow: any; outflow: any };
-};
+import { type RuleConditionEntity } from 'loot-core/src/types/models';
 
 export function subfieldFromFilter({
   field,
   options,
   value,
-}: subfieldFromFilterProps) {
+}: RuleConditionEntity) {
   if (typeof value === 'number') {
     return field;
-  } else if (field === 'date') {
-    if (value.length === 7) {
-      return 'month';
-    } else if (value.length === 4) {
-      return 'year';
-    }
-  } else if (field === 'amount') {
-    if (options && options.inflow) {
-      return 'amount-inflow';
-    } else if (options && options.outflow) {
-      return 'amount-outflow';
+  } else if (value === 'string') {
+    if (field === 'date') {
+      if (value.length === 7) {
+        return 'month';
+      } else if (value.length === 4) {
+        return 'year';
+      }
+    } else if (field === 'amount') {
+      if (options && options.inflow) {
+        return 'amount-inflow';
+      } else if (options && options.outflow) {
+        return 'amount-outflow';
+      }
     }
   }
   return field;

packages/desktop-client/src/components/filters/subfieldToOptions.ts

@@ -1,24 +1,34 @@
+import { type RuleConditionEntity } from 'loot-core/src/types/models';
+
 export function subfieldToOptions(field: string, subfield: string) {
+  let setOptions: RuleConditionEntity['options'];
   switch (field) {
     case 'amount':
       switch (subfield) {
         case 'amount-inflow':
-          return { inflow: true };
+          setOptions = { ...setOptions, inflow: true };
+          break;
         case 'amount-outflow':
-          return { outflow: true };
+          setOptions = { ...setOptions, outflow: true };
+          break;
         default:
-          return null;
+          break;
       }
+      break;
     case 'date':
       switch (subfield) {
         case 'month':
-          return { month: true };
+          setOptions = { ...setOptions, month: true };
+          break;
         case 'year':
-          return { year: true };
+          setOptions = { ...setOptions, year: true };
+          break;
         default:
-          return null;
+          break;
       }
+      break;
     default:
-      return null;
+      break;
   }
+  return setOptions;
 }

packages/desktop-client/src/components/filters/updateFilterReducer.ts

@@ -1,6 +1,7 @@
 import { makeValue, FIELD_TYPES } from 'loot-core/src/shared/rules';
+import { type RuleConditionEntity } from 'loot-core/src/types/models';
 
-export function updateFilterReducer(state: any, action: any) {
+export function updateFilterReducer(state: any, action: RuleConditionEntity) {
   switch (action.type) {
     case 'set-op': {
       const type = FIELD_TYPES.get(state.field);

packages/loot-core/src/shared/rules.ts

@@ -1,4 +1,6 @@
 // @ts-strict-ignore
+import { RuleConditionEntity } from '../types/models';
+
 import { integerToAmount, amountToInteger, currencyToAmount } from './util';
 
 // For now, this info is duplicated from the backend. Figure out how
@@ -195,28 +197,43 @@ export function parse(item) {
   return { ...item, error: null };
 }
 
-export function unparse({ error, inputKey, ...item }) {
+export function unparse({
+  item,
+  error,
+  inputKey,
+}: {
+  item: RuleConditionEntity;
+  error?: string;
+  inputKey?: string;
+}) {
+  let saveItem: RuleConditionEntity = item;
   switch (item.type) {
     case 'number': {
       let unparsed = item.value;
-      if (item.field === 'amount' && item.op !== 'isbetween') {
+      if (
+        item.field === 'amount' &&
+        item.op !== 'isbetween' &&
+        typeof unparsed === 'number'
+      ) {
         unparsed = amountToInteger(unparsed);
       }
-
-      return { ...item, value: unparsed };
+      saveItem = { ...item, value: unparsed };
+      break;
     }
     case 'string': {
       const unparsed = item.value == null ? '' : item.value;
-      return { ...item, value: unparsed };
+      saveItem = { ...item, value: unparsed };
+      break;
     }
     case 'boolean': {
       const unparsed = item.value == null ? false : item.value;
-      return { ...item, value: unparsed };
+      saveItem = { ...item, value: unparsed };
+      break;
     }
     default:
   }
 
-  return item;
+  return saveItem;
 }
 
 export function makeValue(value, cond) {