@actual-app/core 26.3.0

package/src/server/transactions/app.ts

@@ -0,0 +1,136 @@
+import { q, Query } from '../../shared/query';
+import type { QueryState } from '../../shared/query';
+import type {
+  AccountEntity,
+  CategoryGroupEntity,
+  PayeeEntity,
+  TransactionEntity,
+} from '../../types/models';
+import { createApp } from '../app';
+import { aqlQuery } from '../aql';
+import { mutator } from '../mutators';
+import { undoable } from '../undo';
+
+import { exportQueryToCSV, exportToCSV } from './export/export-to-csv';
+import { parseFile } from './import/parse-file';
+import type { ParseFileOptions } from './import/parse-file';
+import { mergeTransactions } from './merge';
+
+import { batchUpdateTransactions } from '.';
+
+export type TransactionHandlers = {
+  'transactions-batch-update': typeof handleBatchUpdateTransactions;
+  'transaction-add': typeof addTransaction;
+  'transaction-update': typeof updateTransaction;
+  'transaction-delete': typeof deleteTransaction;
+  'transactions-parse-file': typeof parseTransactionsFile;
+  'transactions-export': typeof exportTransactions;
+  'transactions-export-query': typeof exportTransactionsQuery;
+  'transactions-merge': typeof mergeTransactions;
+  'get-earliest-transaction': typeof getEarliestTransaction;
+  'get-latest-transaction': typeof getLatestTransaction;
+};
+
+async function handleBatchUpdateTransactions({
+  added,
+  deleted,
+  updated,
+  learnCategories,
+  runTransfers = true,
+}: Parameters<typeof batchUpdateTransactions>[0]) {
+  const result = await batchUpdateTransactions({
+    added,
+    updated,
+    deleted,
+    learnCategories,
+    runTransfers,
+  });
+
+  return result;
+}
+
+async function addTransaction(transaction: TransactionEntity) {
+  await handleBatchUpdateTransactions({ added: [transaction] });
+  return {};
+}
+
+async function updateTransaction(transaction: TransactionEntity) {
+  await handleBatchUpdateTransactions({ updated: [transaction] });
+  return {};
+}
+
+async function deleteTransaction(transaction: Pick<TransactionEntity, 'id'>) {
+  await handleBatchUpdateTransactions({ deleted: [transaction] });
+  return {};
+}
+
+async function parseTransactionsFile({
+  filepath,
+  options,
+}: {
+  filepath: string;
+  options: ParseFileOptions;
+}) {
+  return parseFile(filepath, options);
+}
+
+async function exportTransactions({
+  transactions,
+  accounts,
+  categoryGroups,
+  payees,
+}: {
+  transactions: TransactionEntity[];
+  accounts: AccountEntity[];
+  categoryGroups: CategoryGroupEntity[];
+  payees: PayeeEntity[];
+}) {
+  return exportToCSV(transactions, accounts, categoryGroups, payees);
+}
+
+async function exportTransactionsQuery({
+  query: queryState,
+}: {
+  query: QueryState;
+}) {
+  return exportQueryToCSV(new Query(queryState));
+}
+
+async function getEarliestTransaction() {
+  const { data } = await aqlQuery(
+    q('transactions')
+      .options({ splits: 'none' })
+      .orderBy({ date: 'asc' })
+      .select('*')
+      .limit(1),
+  );
+  return data[0] || null;
+}
+
+async function getLatestTransaction() {
+  const { data } = await aqlQuery(
+    q('transactions')
+      .options({ splits: 'none' })
+      .orderBy({ date: 'desc' })
+      .select('*')
+      .limit(1),
+  );
+  return data[0] || null;
+}
+
+export const app = createApp<TransactionHandlers>();
+
+app.method(
+  'transactions-batch-update',
+  mutator(undoable(handleBatchUpdateTransactions)),
+);
+app.method('transactions-merge', mutator(undoable(mergeTransactions)));
+
+app.method('transaction-add', mutator(addTransaction));
+app.method('transaction-update', mutator(updateTransaction));
+app.method('transaction-delete', mutator(deleteTransaction));
+app.method('transactions-parse-file', mutator(parseTransactionsFile));
+app.method('transactions-export', mutator(exportTransactions));
+app.method('transactions-export-query', mutator(exportTransactionsQuery));
+app.method('get-earliest-transaction', getEarliestTransaction);
+app.method('get-latest-transaction', getLatestTransaction);

package/src/server/transactions/export/export-to-csv.ts

@@ -0,0 +1,132 @@
+// @ts-strict-ignore
+import { stringify as csvStringify } from 'csv-stringify/sync';
+
+import { integerToAmount } from '../../../shared/util';
+import { aqlQuery } from '../../aql';
+
+export async function exportToCSV(
+  transactions,
+  accounts,
+  categoryGroups,
+  payees,
+) {
+  const accountNamesById = accounts.reduce((reduced, { id, name }) => {
+    reduced[id] = name;
+    return reduced;
+  }, {});
+
+  const categoryNamesById = categoryGroups.reduce(
+    (reduced, { name, categories: subCategories }) => {
+      subCategories.forEach(
+        subCategory =>
+          (reduced[subCategory.id] = `${name}: ${subCategory.name}`),
+      );
+      return reduced;
+    },
+    {},
+  );
+
+  const payeeNamesById = payees.reduce((reduced, { id, name }) => {
+    reduced[id] = name;
+    return reduced;
+  }, {});
+
+  const transactionsForExport = transactions.map(
+    ({
+      account,
+      date,
+      payee,
+      notes,
+      category,
+      amount,
+      cleared,
+      reconciled,
+    }) => ({
+      Account: accountNamesById[account],
+      Date: date,
+      Payee: payeeNamesById[payee],
+      Notes: notes,
+      Category: categoryNamesById[category],
+      Amount: amount == null ? 0 : integerToAmount(amount),
+      Cleared: cleared,
+      Reconciled: reconciled,
+    }),
+  );
+
+  return csvStringify(transactionsForExport, { header: true });
+}
+
+export async function exportQueryToCSV(query) {
+  const { data: transactions } = await aqlQuery(
+    query
+      .select([
+        { Id: 'id' },
+        { Account: 'account.name' },
+        { Date: 'date' },
+        { Payee: 'payee.name' },
+        { ParentId: 'parent_id' },
+        { IsParent: 'is_parent' },
+        { IsChild: 'is_child' },
+        { SortOrder: 'sort_order' },
+        { Notes: 'notes' },
+        { CategoryGroup: 'category.group.name' },
+        { Category: 'category.name' },
+        { Amount: 'amount' },
+        { Cleared: 'cleared' },
+        { Reconciled: 'reconciled' },
+      ])
+      .options({ splits: 'all' }),
+  );
+
+  // initialize a map to allow splits to have correct number of split from
+  const parentsChildCount: Map<number, number> = new Map();
+  const childSplitOrder: Map<number, number> = new Map();
+
+  // find children, their order, and total # siblings
+  for (const trans of transactions) {
+    if (trans.IsChild) {
+      let childNumber = parentsChildCount.get(trans.ParentId) || 0;
+      childNumber++;
+      childSplitOrder.set(trans.Id, childNumber);
+      parentsChildCount.set(trans.ParentId, childNumber);
+    }
+  }
+
+  // map final properties for export and grab the child count for splits from their parent transaction
+  const transactionsForExport = transactions.map(trans => {
+    return {
+      Account: trans.Account,
+      Date: trans.Date,
+      Payee: trans.Payee,
+      Notes: trans.IsParent
+        ? '(SPLIT INTO ' +
+          parentsChildCount.get(trans.Id) +
+          ') ' +
+          (trans.Notes || '')
+        : trans.IsChild
+          ? '(SPLIT ' +
+            childSplitOrder.get(trans.Id) +
+            ' OF ' +
+            parentsChildCount.get(trans.ParentId) +
+            ') ' +
+            (trans.Notes || '')
+          : trans.Notes,
+      Category_Group: trans.CategoryGroup,
+      Category: trans.Category,
+      Amount: trans.IsParent
+        ? 0
+        : trans.Amount == null
+          ? 0
+          : integerToAmount(trans.Amount),
+      Split_Amount: trans.IsParent ? integerToAmount(trans.Amount) : 0,
+      Cleared:
+        trans.Reconciled === true
+          ? 'Reconciled'
+          : trans.Cleared === true
+            ? 'Cleared'
+            : 'Not cleared',
+    };
+  });
+
+  return csvStringify(transactionsForExport, { header: true });
+}