Skip to content

A local-first personal finance app

Fix category is/is not (nothing) filters (#3669)

Ryan Bianchi0696c8113d1a
diff --git a/packages/desktop-client/src/components/filters/FiltersMenu.jsx b/packages/desktop-client/src/components/filters/FiltersMenu.jsx
index 2c379293ce..c6ec6b583d 100644
--- a/packages/desktop-client/src/components/filters/FiltersMenu.jsx
+++ b/packages/desktop-client/src/components/filters/FiltersMenu.jsx
@@ -54,6 +54,7 @@ const filterFields = [
'cleared',
'reconciled',
'saved',
+ 'transfer',
].map(field => [field, mapField(field)]);
function ConfigureField({
diff --git a/packages/loot-core/src/server/accounts/rules.ts b/packages/loot-core/src/server/accounts/rules.ts
index dd82192205..20f9ea2d21 100644
--- a/packages/loot-core/src/server/accounts/rules.ts
+++ b/packages/loot-core/src/server/accounts/rules.ts
@@ -200,10 +200,11 @@ const CONDITION_TYPES = {
'isNot',
'doesNotContain',
'notOneOf',
+ 'and',
],
nullable: true,
parse(op, value, fieldName) {
- if (op === 'oneOf' || op === 'notOneOf') {
+ if (op === 'oneOf' || op === 'notOneOf' || op === 'and') {
assert(
Array.isArray(value),
'no-empty-array',
diff --git a/packages/loot-core/src/server/accounts/transaction-rules.test.ts b/packages/loot-core/src/server/accounts/transaction-rules.test.ts
index 4a043e0ef0..37fe3e238f 100644
--- a/packages/loot-core/src/server/accounts/transaction-rules.test.ts
+++ b/packages/loot-core/src/server/accounts/transaction-rules.test.ts
@@ -372,14 +372,14 @@ describe('Transaction rules', () => {
await loadRules();
const account = await db.insertAccount({ name: 'bank' });
const categoryGroupId = await db.insertCategoryGroup({ name: 'general' });
- const categoryId = await db.insertCategory({
+ const foodCategoryId = await db.insertCategory({
name: 'food',
cat_group: categoryGroupId,
});
const krogerId = await db.insertPayee({ name: 'kroger' });
const lowesId = await db.insertPayee({
name: 'lowes',
- category: categoryId,
+ category: foodCategoryId,
});
await db.insertTransaction({
@@ -387,6 +387,7 @@ describe('Transaction rules', () => {
date: '2020-10-01',
account,
payee: krogerId,
+ category: foodCategoryId,
notes: 'barr',
amount: 353,
});
@@ -419,6 +420,7 @@ describe('Transaction rules', () => {
date: '2020-10-16',
account,
payee: lowesId,
+ category: foodCategoryId,
notes: '',
amount: 124,
});
@@ -492,8 +494,35 @@ describe('Transaction rules', () => {
]);
expect(transactions.map(t => t.id)).toEqual(['4', '5', '2', '3']);
+ //Condition special cases
+ //is category null
+ transactions = await getMatchingTransactions([
+ { field: 'category', op: 'is', value: null },
+ ]);
+ expect(transactions.map(t => t.id)).toEqual(['4', '2', '3']);
+
+ //category is not X
+ transactions = await getMatchingTransactions([
+ { field: 'category', op: 'isNot', value: null },
+ ]);
+ expect(transactions.map(t => t.id)).toEqual(['5', '1']);
+
// todo: isapprox
});
+
+ test('and sub expression builds $and condition', async () => {
+ const conds = [{ field: 'category', op: 'is', value: null }];
+ const { filters } = conditionsToAQL(conds);
+ expect(filters).toStrictEqual([
+ {
+ $and: [
+ { category: { $eq: null } },
+ { transfer_id: { $eq: null } },
+ { is_parent: { $eq: false } },
+ ],
+ },
+ ]);
+ });
});
describe('Learning categories', () => {
diff --git a/packages/loot-core/src/server/accounts/transaction-rules.ts b/packages/loot-core/src/server/accounts/transaction-rules.ts
index d32eb9324f..2c2569a5fc 100644
--- a/packages/loot-core/src/server/accounts/transaction-rules.ts
+++ b/packages/loot-core/src/server/accounts/transaction-rules.ts
@@ -291,6 +291,34 @@ export async function runRules(trans) {
return await finalizeTransactionForRules(finalTrans);
}
+function conditionSpecialCases(cond: Condition): Condition {
+ //special cases that require multiple conditions
+ if (cond.op === 'is' && cond.field === 'category' && cond.value === null) {
+ return new Condition(
+ 'and',
+ cond.field,
+ [
+ cond,
+ new Condition('is', 'transfer', false, null),
+ new Condition('is', 'parent', false, null),
+ ],
+ {},
+ );
+ } else if (
+ cond.op === 'isNot' &&
+ cond.field === 'category' &&
+ cond.value === null
+ ) {
+ return new Condition(
+ 'and',
+ cond.field,
+ [cond, new Condition('is', 'parent', false, null)],
+ {},
+ );
+ }
+ return cond;
+}
+
// This does the inverse: finds all the transactions matching a rule
export function conditionsToAQL(conditions, { recurDateBounds = 100 } = {}) {
const errors = [];
@@ -309,11 +337,13 @@ export function conditionsToAQL(conditions, { recurDateBounds = 100 } = {}) {
return null;
}
})
+ .map(conditionSpecialCases)
.filter(Boolean);
// rule -> actualql
- const filters = conditions.map(cond => {
- const { type, field, op, value, options } = cond;
+ const mapConditionToActualQL = cond => {
+ const { type, options } = cond;
+ let { field, op, value } = cond;
const getValue = value => {
if (type === 'number') {
@@ -322,6 +352,23 @@ export function conditionsToAQL(conditions, { recurDateBounds = 100 } = {}) {
return value;
};
+ if (field === 'transfer' && op === 'is') {
+ field = 'transfer_id';
+ if (value) {
+ op = 'isNot';
+ value = null;
+ } else {
+ value = null;
+ }
+ } else if (field === 'parent' && op === 'is') {
+ field = 'is_parent';
+ if (value) {
+ op = 'true';
+ } else {
+ op = 'false';
+ }
+ }
+
const apply = (field, op, value) => {
if (type === 'number') {
if (options) {
@@ -504,11 +551,16 @@ export function conditionsToAQL(conditions, { recurDateBounds = 100 } = {}) {
return apply(field, '$eq', true);
case 'false':
return apply(field, '$eq', false);
+ case 'and':
+ return {
+ $and: getValue(value).map(subExpr => mapConditionToActualQL(subExpr)),
+ };
default:
throw new Error('Unhandled operator: ' + op);
}
- });
+ };
+ const filters = conditions.map(mapConditionToActualQL);
return { filters, errors };
}
diff --git a/packages/loot-core/src/server/aql/compiler.test.ts b/packages/loot-core/src/server/aql/compiler.test.ts
index cc2add5ddb..fe56fb5328 100644
--- a/packages/loot-core/src/server/aql/compiler.test.ts
+++ b/packages/loot-core/src/server/aql/compiler.test.ts
@@ -951,4 +951,16 @@ describe('Type conversions', () => {
);
expect(result.sql).toMatch('WHERE (transactions.payee IS NULL)');
});
+
+ it('allows fields to be not nullable', () => {
+ // With validated refs
+ const result = generateSQLWithState(
+ q('transactions')
+ .filter({ payee: { $ne: null } })
+ .select()
+ .serialize(),
+ schemaWithRefs,
+ );
+ expect(result.sql).toMatch('WHERE (payees1.id IS NOT NULL)');
+ });
});
diff --git a/packages/loot-core/src/server/aql/compiler.ts b/packages/loot-core/src/server/aql/compiler.ts
index de665f9e0b..1d23d8f55f 100644
--- a/packages/loot-core/src/server/aql/compiler.ts
+++ b/packages/loot-core/src/server/aql/compiler.ts
@@ -694,7 +694,7 @@ const compileOp = saveStack('op', (state, fieldRef, opData) => {
}
case '$ne': {
if (castInput(state, rhs, lhs.type).type === 'null') {
- return `${val(state, lhs)} IS NULL`;
+ return `${val(state, lhs)} IS NOT NULL`;
}
const [left, right] = valArray(state, [lhs, rhs], [null, lhs.type]);
diff --git a/packages/loot-core/src/shared/rules.ts b/packages/loot-core/src/shared/rules.ts
index a779e79714..c5de63ce59 100644
--- a/packages/loot-core/src/shared/rules.ts
+++ b/packages/loot-core/src/shared/rules.ts
@@ -54,7 +54,11 @@ const TYPE_INFO = {
type FieldInfoConstraint = Record<
keyof FieldValueTypes,
- { type: keyof typeof TYPE_INFO; disallowedOps?: Set<RuleConditionOp> }
+ {
+ type: keyof typeof TYPE_INFO;
+ disallowedOps?: Set<RuleConditionOp>;
+ internalOps?: Set<RuleConditionOp>;
+ }
>;
const FIELD_INFO = {
@@ -67,11 +71,13 @@ const FIELD_INFO = {
date: { type: 'date' },
notes: { type: 'string' },
amount: { type: 'number' },
- category: { type: 'id' },
+ category: { type: 'id', 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;
@@ -85,11 +91,12 @@ export const FIELD_TYPES = new Map<keyof FieldValueTypes, string>(
export function isValidOp(field: keyof FieldValueTypes, op: RuleConditionOp) {
const type = FIELD_TYPES.get(field);
- if (!type) {
- return false;
- }
+
+ if (!type) return false;
+ if (fieldInfo[field].disallowedOps?.has(op)) return false;
+
return (
- TYPE_INFO[type].ops.includes(op) && !fieldInfo[field].disallowedOps?.has(op)
+ TYPE_INFO[type].ops.includes(op) || fieldInfo[field].internalOps?.has(op)
);
}
diff --git a/packages/loot-core/src/types/models/rule.d.ts b/packages/loot-core/src/types/models/rule.d.ts
index 1bfc9c0a0c..5cbbe7d369 100644
--- a/packages/loot-core/src/types/models/rule.d.ts
+++ b/packages/loot-core/src/types/models/rule.d.ts
@@ -26,6 +26,7 @@ export type RuleConditionOp =
| 'contains'
| 'doesNotContain'
| 'hasTags'
+ | 'and'
| 'matches';
type FieldValueTypes = {
@@ -38,6 +39,8 @@ type FieldValueTypes = {
payee_name: string;
imported_payee: string;
saved: string;
+ transfer: boolean;
+ parent: boolean;
cleared: boolean;
reconciled: boolean;
};
diff --git a/upcoming-release-notes/3669.md b/upcoming-release-notes/3669.md
new file mode 100644
index 0000000000..4e5ba539dc
--- /dev/null
+++ b/upcoming-release-notes/3669.md
@@ -0,0 +1,6 @@
+---
+category: Bugfix
+authors: [qedi-r]
+---
+
+Fix category filters when the value is '(nothing)'