Skip to content

A local-first personal finance app

App secret service (#194)

Henrik Maalandd60bb6a19eb1
diff --git a/src/app-nordigen/services/nordigen-service.js b/src/app-nordigen/services/nordigen-service.js
index f267fcc049..8f483d57be 100644
--- a/src/app-nordigen/services/nordigen-service.js
+++ b/src/app-nordigen/services/nordigen-service.js
@@ -13,13 +13,20 @@ import {
} from '../errors.js';
import * as nordigenNode from 'nordigen-node';
import * as uuid from 'uuid';
-import config from '../../load-config.js';
import jwt from 'jws';
+import { SecretName, secretsService } from '../../services/secrets-service.js';
const NordigenClient = nordigenNode.default;
const nordigenClient = new NordigenClient({
- secretId: config.nordigen?.secretId,
- secretKey: config.nordigen?.secretKey,
+ secretId: secretsService.get(SecretName.nordigen_secretId),
+ secretKey: secretsService.get(SecretName.nordigen_secretKey),
+});
+
+secretsService.onUpdate(SecretName.nordigen_secretId, (newSecret) => {
+ nordigenClient.secretId = newSecret;
+});
+secretsService.onUpdate(SecretName.nordigen_secretKey, (newSecret) => {
+ nordigenClient.secretKey = newSecret;
});
export const handleNordigenError = (response) => {
diff --git a/src/app-secrets.js b/src/app-secrets.js
new file mode 100644
index 0000000000..61935e98f3
--- /dev/null
+++ b/src/app-secrets.js
@@ -0,0 +1,34 @@
+import express from 'express';
+import validateUser from './util/validate-user.js';
+import { secretsService } from './services/secrets-service.js';
+
+const app = express();
+
+export { app as handlers };
+app.use(express.json());
+
+app.use(async (req, res, next) => {
+ let user = await validateUser(req, res);
+ if (!user) {
+ return;
+ }
+ next();
+});
+
+app.post('/', async (req, res) => {
+ const { name, value } = req.body;
+
+ secretsService.set(name, value);
+
+ res.status(200).send('secret set');
+});
+
+app.get('/:name', async (req, res) => {
+ const name = req.params.name;
+ const keyExists = secretsService.exists(name);
+ if (keyExists) {
+ res.sendStatus(204);
+ } else {
+ res.status(404).send('key not found');
+ }
+});
diff --git a/src/app.js b/src/app.js
index ea0927bef9..a6c653323c 100644
--- a/src/app.js
+++ b/src/app.js
@@ -9,6 +9,7 @@ import rateLimit from 'express-rate-limit';
import * as accountApp from './app-account.js';
import * as syncApp from './app-sync.js';
import * as nordigenApp from './app-nordigen/app-nordigen.js';
+import * as secretApp from './app-secrets.js';
const app = express();
@@ -32,6 +33,7 @@ app.use(bodyParser.raw({ type: 'application/encrypted-file', limit: '50mb' }));
app.use('/sync', syncApp.handlers);
app.use('/account', accountApp.handlers);
app.use('/nordigen', nordigenApp.handlers);
+app.use('/secret', secretApp.handlers);
app.get('/mode', (req, res) => {
res.send(config.mode);
diff --git a/src/secrets.test.js b/src/secrets.test.js
new file mode 100644
index 0000000000..fa408319ce
--- /dev/null
+++ b/src/secrets.test.js
@@ -0,0 +1,79 @@
+import { secretsService } from './services/secrets-service.js';
+import request from 'supertest';
+import { handlers as app } from './app-secrets.js';
+describe('secretsService', () => {
+ const testSecretName = 'testSecret';
+ const testSecretValue = 'testValue';
+
+ it('should set a secret', () => {
+ const result = secretsService.set(testSecretName, testSecretValue);
+ expect(result).toBeDefined();
+ expect(result.changes).toBe(1);
+ });
+
+ it('should get a secret', () => {
+ const result = secretsService.get(testSecretName);
+ expect(result).toBeDefined();
+ expect(result).toBe(testSecretValue);
+ });
+
+ it('should check if a secret exists', () => {
+ const exists = secretsService.exists(testSecretName);
+ expect(exists).toBe(true);
+
+ const nonExistent = secretsService.exists('nonExistentSecret');
+ expect(nonExistent).toBe(false);
+ });
+
+ it('should update a secret', () => {
+ const newValue = 'newValue';
+ const setResult = secretsService.set(testSecretName, newValue);
+ expect(setResult).toBeDefined();
+ expect(setResult.changes).toBe(1);
+
+ const getResult = secretsService.get(testSecretName);
+ expect(getResult).toBeDefined();
+ expect(getResult).toBe(newValue);
+ });
+
+ describe('secrets api', () => {
+ it('returns 401 if the user is not authenticated', async () => {
+ secretsService.set(testSecretName, testSecretValue);
+ const res = await request(app).get(`/${testSecretName}`);
+
+ expect(res.statusCode).toEqual(401);
+ expect(res.body).toEqual({
+ details: 'token-not-found',
+ reason: 'unauthorized',
+ status: 'error',
+ });
+ });
+
+ it('returns 404 if secret does not exist', async () => {
+ const res = await request(app)
+ .get(`/thiskeydoesnotexist`)
+ .set('x-actual-token', 'valid-token');
+
+ expect(res.statusCode).toEqual(404);
+ });
+
+ it('returns 204 if secret exists', async () => {
+ secretsService.set(testSecretName, testSecretValue);
+ const res = await request(app)
+ .get(`/${testSecretName}`)
+ .set('x-actual-token', 'valid-token');
+
+ expect(res.statusCode).toEqual(204);
+ });
+
+ it('returns 200 if secret was set', async () => {
+ secretsService.set(testSecretName, testSecretValue);
+ const res = await request(app)
+ .post(`/`)
+ .set('x-actual-token', 'valid-token')
+ .send({ name: testSecretName, value: testSecretValue });
+
+ expect(res.statusCode).toEqual(200);
+ });
+ });
+});
diff --git a/src/services/secrets-service.js b/src/services/secrets-service.js
new file mode 100644
index 0000000000..b5177fad88
--- /dev/null
+++ b/src/services/secrets-service.js
@@ -0,0 +1,140 @@
+import createDebug from 'debug';
+import fs from 'node:fs';
+import config, { sqlDir } from '../load-config.js';
+import { join } from 'node:path';
+import getAccountDb from '../account-db.js';
+
+/**
+ * An enum of valid secret names.
+ * @readonly
+ * @enum {string}
+ */
+export const SecretName = {
+ nordigen_secretId: 'nordigen_secretId',
+ nordigen_secretKey: 'nordigen_secretKey',
+};
+
+class SecretsDb {
+ constructor() {
+ this.debug = createDebug('actual:secrets-db');
+ this.db = null;
+ this.initialize();
+ this.migrateNordigen();
+ }
+
+ /// Migrates nordigen from config.json or process.env to app secret
+ migrateNordigen() {
+ if (
+ config.nordigen &&
+ (!this.get(SecretName.nordigen_secretId) ||
+ !this.get(SecretName.nordigen_secretKey))
+ ) {
+ this.set(SecretName.nordigen_secretId, config.nordigen.secretId);
+ this.set(SecretName.nordigen_secretKey, config.nordigen.secretKey);
+ this.debug(
+ 'Migrated Nordigen keys from config.json/environment to app secrets',
+ );
+ }
+ }
+
+ initialize() {
+ if (!this.db) {
+ this.db = this.open();
+ }
+
+ this.debug(`initializing secrets table'`);
+ //Create secret table if it doesn't exist
+ const initSql = fs.readFileSync(join(sqlDir, 'secrets.sql'), 'utf8');
+ this.db.exec(initSql);
+ }
+
+ open() {
+ return getAccountDb();
+ }
+
+ set(name, value) {
+ if (!this.db) {
+ this.db = this.open();
+ }
+
+ this.debug(`setting secret '${name}' to '${value}'`);
+ const result = this.db.mutate(
+ `INSERT OR REPLACE INTO secrets (name, value) VALUES (?,?)`,
+ [name, value],
+ );
+ return result;
+ }
+
+ get(name) {
+ if (!this.db) {
+ this.db = this.open();
+ }
+
+ this.debug(`getting secret '${name}'`);
+ const result = this.db.first(`SELECT value FROM secrets WHERE name =?`, [
+ name,
+ ]);
+ return result;
+ }
+}
+
+const secretsDb = new SecretsDb();
+const _cachedSecrets = new Map();
+const _observers = new Map();
+/**
+ * A service for managing secrets stored in `secretsDb`.
+ */
+export const secretsService = {
+ /**
+ * Retrieves the value of a secret by name.
+ * @param {SecretName} name - The name of the secret to retrieve.
+ * @returns {string|null} The value of the secret, or null if the secret does not exist.
+ */
+ get: (name) => {
+ return _cachedSecrets.get(name) ?? secretsDb.get(name)?.value ?? null;
+ },
+
+ /**
+ * Callbacks new secret value when a secret changes.
+ * @param {SecretName} name - The name of the secret to retrieve.
+ * @param {function(string): void} callback - The new secret value callback.
+ * @returns {void}
+ */
+ onUpdate: (name, callback) => {
+ const observers = _observers.get(name) ?? [];
+ observers.push(callback);
+ _observers.set(name, observers);
+ },
+
+ _notifyObservers: (name, value) => {
+ const observers = _observers.get(name) ?? [];
+ for (const observer of observers) {
+ observer(value);
+ }
+ },
+
+ /**
+ * Sets the value of a secret by name.
+ * @param {SecretName} name - The name of the secret to set.
+ * @param {string} value - The value to set for the secret.
+ * @returns {Object}
+ */
+ set: (name, value) => {
+ const result = secretsDb.set(name, value);
+
+ if (result.changes === 1) {
+ _cachedSecrets.set(name, value);
+ secretsService._notifyObservers(name, value);
+ }
+ return result;
+ },
+
+ /**
+ * Determines whether a secret with the given name exists.
+ * @param {SecretName} name - The name of the secret to check for existence.
+ * @returns {boolean} True if a secret with the given name exists, false otherwise.
+ */
+ exists: (name) => {
+ return Boolean(secretsService.get(name));
+ },
+};
diff --git a/src/sql/secrets.sql b/src/sql/secrets.sql
new file mode 100644
index 0000000000..0cf078614e
--- /dev/null
+++ b/src/sql/secrets.sql
@@ -0,0 +1,4 @@
+CREATE TABLE IF NOT EXISTS secrets (
+ name TEXT PRIMARY KEY,
+ value BLOB
+);
diff --git a/upcoming-release-notes/194.md b/upcoming-release-notes/194.md
new file mode 100644
index 0000000000..79fbbfe913
--- /dev/null
+++ b/upcoming-release-notes/194.md
@@ -0,0 +1,7 @@
+---
+category: Features
+authors: [Henrikmaa]
+---
+
+
+Adds support for setting and getting secrets in actual-server. Additionally the secrets can be set from client using api.