A local-first personal finance app
import * as asyncStorage from '#platform/server/asyncStorage';
import * as fs from '#platform/server/fs';
import { createApp } from '#server/app';
import * as db from '#server/db';
import { PostError } from '#server/errors';
import { resetFormulaPreferencesCache } from '#server/formulas/bootstrap';
import { getDefaultDocumentDir } from '#server/main';
import { mutator } from '#server/mutators';
import { post } from '#server/post';
import {
getPrefs as _getMetadataPrefs,
savePrefs as _saveMetadataPrefs,
} from '#server/prefs';
import { getServer } from '#server/server-config';
import { undoable } from '#server/undo';
import { stringToInteger } from '#shared/util';
import type { GlobalPrefs, MetadataPrefs, SyncedPrefs } from '#types/prefs';
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>();
const FORMULA_FORMAT_SYNCED_PREFS = new Set<keyof SyncedPrefs>([
'numberFormat',
'hideFraction',
'defaultCurrencyCode',
'currencySymbolPosition',
'currencySpaceBetweenAmountAndSymbol',
]);
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,
});
if (FORMULA_FORMAT_SYNCED_PREFS.has(id)) {
resetFormulaPreferencesCache();
}
}
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);
resetFormulaPreferencesCache();
}
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.customCssOverride !== undefined) {
await asyncStorage.setItem('custom-css-override', prefs.customCssOverride);
}
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,
);
}
if (prefs.lastSeenNewsDate !== undefined) {
await asyncStorage.setItem('lastSeenNewsDate', prefs.lastSeenNewsDate);
}
if (prefs.showNewsFeed !== undefined) {
await asyncStorage.setItem('showNewsFeed', prefs.showNewsFeed);
}
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,
'custom-css-override': customCssOverride,
'server-self-signed-cert': serverSelfSignedCert,
syncServerConfig,
notifyWhenUpdateIsAvailable,
lastSeenNewsDate,
showNewsFeed,
} = 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',
'custom-css-override',
'server-self-signed-cert',
'syncServerConfig',
'notifyWhenUpdateIsAvailable',
'lastSeenNewsDate',
'showNewsFeed',
] 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 === 'midnight'
? theme
: 'auto',
preferredDarkTheme:
preferredDarkTheme === 'dark' || preferredDarkTheme === 'midnight'
? preferredDarkTheme
: 'dark',
installedCustomLightTheme: installedCustomLightTheme || undefined,
installedCustomDarkTheme: installedCustomDarkTheme || undefined,
customCssOverride: customCssOverride || undefined,
serverSelfSignedCert: serverSelfSignedCert || undefined,
syncServerConfig: syncServerConfig || undefined,
notifyWhenUpdateIsAvailable:
notifyWhenUpdateIsAvailable === undefined
? true
: notifyWhenUpdateIsAvailable, // default to true
lastSeenNewsDate: lastSeenNewsDate || undefined,
showNewsFeed: showNewsFeed === undefined ? true : showNewsFeed, // 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 {};
}