@actual-app/core 26.3.0

package/src/server/preferences/app.ts

@@ -0,0 +1,249 @@
+import * as asyncStorage from '../../platform/server/asyncStorage';
+import * as fs from '../../platform/server/fs';
+import { stringToInteger } from '../../shared/util';
+import type {
+  GlobalPrefs,
+  MetadataPrefs,
+  SyncedPrefs,
+} from '../../types/prefs';
+import { createApp } from '../app';
+import * as db from '../db';
+import { PostError } from '../errors';
+import { getDefaultDocumentDir } from '../main';
+import { mutator } from '../mutators';
+import { post } from '../post';
+import {
+  getPrefs as _getMetadataPrefs,
+  savePrefs as _saveMetadataPrefs,
+} from '../prefs';
+import { getServer } from '../server-config';
+import { undoable } from '../undo';
+
+export type PreferencesHandlers = {
+  'preferences/save': typeof saveSyncedPrefs;
+  'preferences/get': typeof getSyncedPrefs;
+  'save-global-prefs': typeof saveGlobalPrefs;
+  'load-global-prefs': typeof loadGlobalPrefs;
+  'save-prefs': typeof saveMetadataPrefs;
+  'load-prefs': typeof loadMetadataPrefs;
+  'save-server-prefs': typeof saveServerPrefs;
+};
+
+export const app = createApp<PreferencesHandlers>();
+
+app.method('preferences/save', mutator(undoable(saveSyncedPrefs)));
+app.method('preferences/get', getSyncedPrefs);
+app.method('save-global-prefs', saveGlobalPrefs);
+app.method('load-global-prefs', loadGlobalPrefs);
+app.method('save-prefs', saveMetadataPrefs);
+app.method('load-prefs', loadMetadataPrefs);
+app.method('save-server-prefs', saveServerPrefs);
+
+async function saveSyncedPrefs({
+  id,
+  value,
+}: {
+  id: keyof SyncedPrefs;
+  value: string | undefined;
+}) {
+  if (!id) {
+    return;
+  }
+
+  await db.update('preferences', {
+    id,
+    value,
+  });
+}
+
+async function getSyncedPrefs(): Promise<SyncedPrefs> {
+  const prefs = await db.all<Pick<db.DbPreference, 'id' | 'value'>>(
+    'SELECT id, value FROM preferences',
+  );
+
+  return prefs.reduce<SyncedPrefs>((carry, { value, id }) => {
+    carry[id as keyof SyncedPrefs] = value;
+    return carry;
+  }, {});
+}
+
+async function saveGlobalPrefs(prefs: GlobalPrefs) {
+  if (!prefs) {
+    return 'ok';
+  }
+
+  if (prefs.maxMonths !== undefined) {
+    await asyncStorage.setItem('max-months', '' + prefs.maxMonths);
+  }
+  if (prefs.categoryExpandedState !== undefined) {
+    await asyncStorage.setItem(
+      'category-expanded-state',
+      '' + prefs.categoryExpandedState,
+    );
+  }
+  if (prefs.documentDir !== undefined && (await fs.exists(prefs.documentDir))) {
+    await asyncStorage.setItem('document-dir', prefs.documentDir);
+  }
+  if (prefs.floatingSidebar !== undefined) {
+    await asyncStorage.setItem('floating-sidebar', '' + prefs.floatingSidebar);
+  }
+  if (prefs.language !== undefined) {
+    await asyncStorage.setItem('language', prefs.language);
+  }
+  if (prefs.theme !== undefined) {
+    await asyncStorage.setItem('theme', prefs.theme);
+  }
+  if (prefs.preferredDarkTheme !== undefined) {
+    await asyncStorage.setItem(
+      'preferred-dark-theme',
+      prefs.preferredDarkTheme,
+    );
+  }
+  if (prefs.installedCustomLightTheme !== undefined) {
+    await asyncStorage.setItem(
+      'installed-custom-theme',
+      prefs.installedCustomLightTheme,
+    );
+  }
+  if (prefs.installedCustomDarkTheme !== undefined) {
+    await asyncStorage.setItem(
+      'installed-custom-dark-theme',
+      prefs.installedCustomDarkTheme,
+    );
+  }
+  if (prefs.serverSelfSignedCert !== undefined) {
+    await asyncStorage.setItem(
+      'server-self-signed-cert',
+      prefs.serverSelfSignedCert,
+    );
+  }
+  if (prefs.syncServerConfig !== undefined) {
+    await asyncStorage.setItem('syncServerConfig', prefs.syncServerConfig);
+  }
+  if (prefs.notifyWhenUpdateIsAvailable !== undefined) {
+    await asyncStorage.setItem(
+      'notifyWhenUpdateIsAvailable',
+      prefs.notifyWhenUpdateIsAvailable,
+    );
+  }
+  return 'ok';
+}
+
+async function loadGlobalPrefs(): Promise<GlobalPrefs> {
+  const {
+    'floating-sidebar': floatingSidebar,
+    'category-expanded-state': categoryExpandedState,
+    'max-months': maxMonths,
+    'document-dir': documentDir,
+    'encrypt-key': encryptKey,
+    language,
+    theme,
+    'preferred-dark-theme': preferredDarkTheme,
+    'installed-custom-theme': installedCustomLightTheme,
+    'installed-custom-dark-theme': installedCustomDarkTheme,
+    'server-self-signed-cert': serverSelfSignedCert,
+    syncServerConfig,
+    notifyWhenUpdateIsAvailable,
+  } = await asyncStorage.multiGet([
+    'floating-sidebar',
+    'category-expanded-state',
+    'max-months',
+    'document-dir',
+    'encrypt-key',
+    'language',
+    'theme',
+    'preferred-dark-theme',
+    'installed-custom-theme',
+    'installed-custom-dark-theme',
+    'server-self-signed-cert',
+    'syncServerConfig',
+    'notifyWhenUpdateIsAvailable',
+  ] as const);
+  return {
+    floatingSidebar: floatingSidebar === 'true',
+    categoryExpandedState: stringToInteger(categoryExpandedState || '') || 0,
+    maxMonths: stringToInteger(maxMonths || '') || 1,
+    documentDir: documentDir || getDefaultDocumentDir(),
+    keyId: encryptKey && JSON.parse(encryptKey).id,
+    language,
+    theme:
+      theme === 'light' ||
+      theme === 'dark' ||
+      theme === 'auto' ||
+      theme === 'development' ||
+      theme === 'midnight'
+        ? theme
+        : 'auto',
+    preferredDarkTheme:
+      preferredDarkTheme === 'dark' || preferredDarkTheme === 'midnight'
+        ? preferredDarkTheme
+        : 'dark',
+    installedCustomLightTheme: installedCustomLightTheme || undefined,
+    installedCustomDarkTheme: installedCustomDarkTheme || undefined,
+    serverSelfSignedCert: serverSelfSignedCert || undefined,
+    syncServerConfig: syncServerConfig || undefined,
+    notifyWhenUpdateIsAvailable:
+      notifyWhenUpdateIsAvailable === undefined
+        ? true
+        : notifyWhenUpdateIsAvailable, // default to true
+  };
+}
+
+async function saveMetadataPrefs(prefsToSet: MetadataPrefs) {
+  if (!prefsToSet) {
+    return 'ok';
+  }
+
+  const { cloudFileId } = _getMetadataPrefs();
+
+  // Need to sync the budget name on the server as well
+  if (prefsToSet.budgetName && cloudFileId) {
+    const userToken = await asyncStorage.getItem('user-token');
+
+    const syncServer = getServer()?.SYNC_SERVER;
+    if (!syncServer) {
+      throw new Error('No sync server set');
+    }
+
+    await post(syncServer + '/update-user-filename', {
+      token: userToken,
+      fileId: cloudFileId,
+      name: prefsToSet.budgetName,
+    });
+  }
+
+  await _saveMetadataPrefs(prefsToSet);
+  return 'ok';
+}
+
+async function loadMetadataPrefs(): Promise<MetadataPrefs> {
+  return _getMetadataPrefs();
+}
+
+async function saveServerPrefs({ prefs }: { prefs: Record<string, string> }) {
+  const userToken = await asyncStorage.getItem('user-token');
+  if (!userToken) {
+    return { error: 'not-logged-in' };
+  }
+
+  try {
+    const serverConfig = getServer();
+    if (!serverConfig) {
+      throw new Error('No sync server configured.');
+    }
+    await post(serverConfig.SIGNUP_SERVER + '/server-prefs', {
+      token: userToken,
+      prefs,
+    });
+  } catch (err) {
+    if (err instanceof PostError) {
+      return {
+        error: err.reason || 'network-failure',
+      };
+    }
+
+    throw err;
+  }
+
+  return {};
+}

package/src/server/prefs.ts

@@ -0,0 +1,91 @@
+// @ts-strict-ignore
+import { Timestamp } from '@actual-app/crdt';
+
+import * as fs from '../platform/server/fs';
+import type { MetadataPrefs } from '../types/prefs';
+
+import { sendMessages } from './sync';
+import type { Message } from './sync';
+
+export const BUDGET_TYPES = ['tracking', 'envelope'] as const;
+export type BudgetType = (typeof BUDGET_TYPES)[number];
+
+export const UPCOMING_SCHEDULED_TRANSACTION_LENGTHS = [
+  '1',
+  '7',
+  '14',
+  '30',
+] as const;
+export type UpcomingScheduledTransactionLength =
+  (typeof UPCOMING_SCHEDULED_TRANSACTION_LENGTHS)[number];
+
+let prefs: MetadataPrefs = null;
+
+export async function loadPrefs(id?: string): Promise<MetadataPrefs> {
+  if (process.env.NODE_ENV === 'test' && !id) {
+    prefs = getDefaultPrefs('test', 'test_LocalPrefs');
+    return prefs;
+  }
+
+  const fullpath = fs.join(fs.getBudgetDir(id), 'metadata.json');
+
+  try {
+    prefs = JSON.parse(await fs.readFile(fullpath));
+  } catch {
+    // If the user messed something up, be flexible and allow them to
+    // still load the budget database. Default the budget name to the
+    // id.
+    prefs = { id, budgetName: id };
+  }
+
+  // No matter what is in `id` field, force it to be the current id.
+  // This makes it resilient to users moving around folders, etc
+  prefs.id = id;
+  return prefs;
+}
+
+export async function savePrefs(
+  prefsToSet: MetadataPrefs,
+  { avoidSync = false } = {},
+): Promise<void> {
+  Object.assign(prefs, prefsToSet);
+
+  if (!avoidSync) {
+    // Sync whitelisted prefs
+    const messages: Message[] = Object.keys(prefsToSet)
+      .map(key => {
+        if (key === 'budgetName') {
+          return {
+            dataset: 'prefs',
+            row: key,
+            column: 'value',
+            value: prefsToSet[key],
+            timestamp: Timestamp.send(),
+          };
+        }
+        return null;
+      })
+      .filter(x => x);
+
+    if (messages.length > 0) {
+      await sendMessages(messages);
+    }
+  }
+
+  if (process.env.NODE_ENV !== 'test') {
+    const prefsPath = fs.join(fs.getBudgetDir(prefs.id), 'metadata.json');
+    await fs.writeFile(prefsPath, JSON.stringify(prefs));
+  }
+}
+
+export function unloadPrefs(): void {
+  prefs = null;
+}
+
+export function getPrefs(): MetadataPrefs {
+  return prefs;
+}
+
+export function getDefaultPrefs(id: string, budgetName: string) {
+  return { id, budgetName };
+}

package/src/server/reports/app.ts

@@ -0,0 +1,187 @@
+import { v4 as uuidv4 } from 'uuid';
+
+import { q } from '#shared/query';
+import type { CustomReportData, CustomReportEntity } from '../../types/models';
+import { createApp } from '../app';
+import { aqlQuery } from '../aql';
+import * as db from '../db';
+import { ValidationError } from '../errors';
+import { requiredFields } from '../models';
+import { mutator } from '../mutators';
+import { undoable } from '../undo';
+
+export const reportModel = {
+  validate(
+    report: Omit<CustomReportEntity, 'tombstone'>,
+    { update }: { update?: boolean } = {},
+  ) {
+    requiredFields('Report', report, ['conditionsOp'], update);
+
+    if (!update || 'conditionsOp' in report) {
+      if (!['and', 'or'].includes(report.conditionsOp)) {
+        throw new ValidationError(
+          'Invalid filter conditionsOp: ' + report.conditionsOp,
+        );
+      }
+    }
+
+    return report;
+  },
+
+  toJS(row: CustomReportData): CustomReportEntity {
+    return {
+      id: row.id,
+      name: row.name,
+      startDate: row.start_date,
+      endDate: row.end_date,
+      isDateStatic: row.date_static === 1,
+      dateRange: row.date_range,
+      mode: row.mode,
+      groupBy: row.group_by,
+      sortBy: row.sort_by,
+      interval: row.interval,
+      balanceType: row.balance_type,
+      showEmpty: row.show_empty === 1,
+      showOffBudget: row.show_offbudget === 1,
+      showHiddenCategories: row.show_hidden === 1,
+      showUncategorized: row.show_uncategorized === 1,
+      trimIntervals: row.trim_intervals === 1,
+      includeCurrentInterval: row.include_current === 1,
+      graphType: row.graph_type,
+      conditions: row.conditions ?? [],
+      conditionsOp: row.conditions_op ?? 'and',
+      metadata: row.metadata,
+    };
+  },
+
+  fromJS(report: CustomReportEntity): CustomReportData {
+    return {
+      id: report.id,
+      name: report.name,
+      start_date: report.startDate,
+      end_date: report.endDate,
+      date_static: report.isDateStatic ? 1 : 0,
+      date_range: report.dateRange,
+      mode: report.mode,
+      group_by: report.groupBy,
+      sort_by: report.sortBy ?? 'desc',
+      interval: report.interval,
+      balance_type: report.balanceType,
+      show_empty: report.showEmpty ? 1 : 0,
+      show_offbudget: report.showOffBudget ? 1 : 0,
+      show_hidden: report.showHiddenCategories ? 1 : 0,
+      show_uncategorized: report.showUncategorized ? 1 : 0,
+      trim_intervals: report.trimIntervals ? 1 : 0,
+      include_current: report.includeCurrentInterval ? 1 : 0,
+      graph_type: report.graphType,
+      conditions: report.conditions,
+      conditions_op: report.conditionsOp,
+    };
+  },
+};
+
+// Sort reports by alphabetical order
+function sort(reports: CustomReportEntity[]) {
+  return reports.sort((a, b) =>
+    a.name && b.name
+      ? a.name.trim().localeCompare(b.name.trim(), undefined, {
+          ignorePunctuation: true,
+        })
+      : 0,
+  );
+}
+
+async function getReports() {
+  // Use aql because it auto deserialized json columns e.g. conditions
+  const { data }: { data: CustomReportData[] } = await aqlQuery(
+    q('custom_reports').select('*'),
+  );
+  return sort(data.map(r => reportModel.toJS(r)));
+}
+
+async function reportNameExists(
+  name: string,
+  reportId: string,
+  newItem: boolean,
+) {
+  const idForName = await db.first<Pick<db.DbCustomReport, 'id'>>(
+    'SELECT id from custom_reports WHERE tombstone = 0 AND name = ?',
+    [name],
+  );
+
+  //no existing name found
+  if (idForName === null) {
+    return false;
+  }
+
+  //for update/rename
+  if (!newItem) {
+    /*
+    -if the found item is the same as the existing item
+    then no name change was made.
+    -if they are not the same then there is another
+    item with that name already.
+    */
+    return idForName.id !== reportId;
+  }
+
+  //default return: item was found but does not match current name
+  return true;
+}
+
+async function createReport(report: CustomReportEntity) {
+  const reportId = uuidv4();
+  const item: CustomReportEntity = {
+    ...report,
+    id: reportId,
+  };
+  if (!item.name) {
+    throw new Error('Report name is required');
+  }
+
+  const nameExists = await reportNameExists(item.name, item.id ?? '', true);
+  if (nameExists) {
+    throw new Error('There is already a report named ' + item.name);
+  }
+
+  // Create the report here based on the info
+  await db.insertWithSchema('custom_reports', reportModel.fromJS(item));
+
+  return reportId;
+}
+
+async function updateReport(item: CustomReportEntity) {
+  if (!item.name) {
+    throw new Error('Report name is required');
+  }
+
+  if (!item.id) {
+    throw new Error('Report recall error');
+  }
+
+  const nameExists = await reportNameExists(item.name, item.id, false);
+  if (nameExists) {
+    throw new Error('There is already a report named ' + item.name);
+  }
+
+  await db.updateWithSchema('custom_reports', reportModel.fromJS(item));
+}
+
+async function deleteReport(id: CustomReportEntity['id']) {
+  await db.delete_('custom_reports', id);
+}
+
+export type ReportsHandlers = {
+  'report/get': typeof getReports;
+  'report/create': typeof createReport;
+  'report/update': typeof updateReport;
+  'report/delete': typeof deleteReport;
+};
+
+// Expose functions to the client
+export const app = createApp<ReportsHandlers>();
+
+app.method('report/get', getReports);
+app.method('report/create', mutator(undoable(createReport)));
+app.method('report/update', mutator(undoable(updateReport)));
+app.method('report/delete', mutator(undoable(deleteReport)));