@actual-app/api 6.2.1 → 6.4.0

package/dist/app/query.js

@@ -23,7 +23,7 @@ class Query {
         });
     }
     unfilter(exprs) {
-        let exprSet = new Set(exprs);
+        const exprSet = new Set(exprs);
         return new Query({
             ...this.state,
             filterExpressions: this.state.filterExpressions.filter(expr => !exprSet.has(Object.keys(expr)[0])),
@@ -33,12 +33,12 @@ class Query {
         if (!Array.isArray(exprs)) {
             exprs = [exprs];
         }
-        let query = new Query({ ...this.state, selectExpressions: exprs });
+        const query = new Query({ ...this.state, selectExpressions: exprs });
         query.state.calculation = false;
         return query;
     }
     calculate(expr) {
-        let query = this.select({ result: expr });
+        const query = this.select({ result: expr });
         query.state.calculation = true;
         return query;
     }

package/dist/index.js

@@ -1,5 +1,4 @@
 "use strict";
-/* eslint-disable import/no-unused-modules */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -31,6 +30,7 @@ exports.shutdown = exports.init = exports.utils = exports.methods = exports.inte
 // eslint-disable-next-line import/extensions
 const bundle = __importStar(require("./app/bundle.api.js"));
 const injected = __importStar(require("./injected"));
+const validateNodeVersion_1 = require("./validateNodeVersion");
 let actualApp;
 exports.internal = bundle.lib;
 // DEPRECATED: remove the next line in @actual-app/api v7
@@ -41,6 +41,7 @@ async function init(config = {}) {
     if (actualApp) {
         return;
     }
+    (0, validateNodeVersion_1.validateNodeVersion)();
     global.fetch = (...args) => import('node-fetch').then(({ default: fetch }) => fetch(...args));
     await bundle.init(config);
     actualApp = bundle.lib;

package/dist/jest.config.d.ts

@@ -0,0 +1,9 @@
+export const moduleFileExtensions: string[];
+export const testEnvironment: string;
+export const testPathIgnorePatterns: string[];
+export const watchPathIgnorePatterns: string[];
+export const setupFilesAfterEnv: string[];
+export const transformIgnorePatterns: string[];
+export const transform: {
+    '^.+\\.(t|j)sx?$': string;
+};

package/dist/jest.config.js

@@ -0,0 +1,24 @@
+module.exports = {
+    moduleFileExtensions: [
+        'testing.js',
+        'testing.ts',
+        'api.js',
+        'api.ts',
+        'api.tsx',
+        'electron.js',
+        'electron.ts',
+        'mjs',
+        'js',
+        'ts',
+        'tsx',
+        'json',
+    ],
+    testEnvironment: 'node',
+    testPathIgnorePatterns: ['/node_modules/'],
+    watchPathIgnorePatterns: ['<rootDir>/mocks/budgets/'],
+    setupFilesAfterEnv: ['<rootDir>/../loot-core/src/mocks/setup.ts'],
+    transformIgnorePatterns: ['/node_modules/'],
+    transform: {
+        '^.+\\.(t|j)sx?$': '@swc/jest',
+    },
+};

package/dist/methods.d.ts

@@ -10,7 +10,10 @@ export function getBudgetMonths(): any;
 export function getBudgetMonth(month: any): any;
 export function setBudgetAmount(month: any, categoryId: any, value: any): any;
 export function setBudgetCarryover(month: any, categoryId: any, flag: any): any;
-export function addTransactions(accountId: any, transactions: any): any;
+export function addTransactions(accountId: any, transactions: any, { learnCategories, runTransfers }?: {
+    learnCategories?: boolean;
+    runTransfers?: boolean;
+}): any;
 export function importTransactions(accountId: any, transactions: any): any;
 export function getTransactions(accountId: any, startDate: any, endDate: any): any;
 export function filterTransactions(accountId: any, text: any): any;

package/dist/methods.js

@@ -87,8 +87,13 @@ function setBudgetCarryover(month, categoryId, flag) {
     return send('api/budget-set-carryover', { month, categoryId, flag });
 }
 exports.setBudgetCarryover = setBudgetCarryover;
-function addTransactions(accountId, transactions) {
-    return send('api/transactions-add', { accountId, transactions });
+function addTransactions(accountId, transactions, { learnCategories = false, runTransfers = false } = {}) {
+    return send('api/transactions-add', {
+        accountId,
+        transactions,
+        learnCategories,
+        runTransfers,
+    });
 }
 exports.addTransactions = addTransactions;
 function importTransactions(accountId, transactions) {

package/dist/methods.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/methods.test.js

@@ -0,0 +1,231 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const api = __importStar(require("./index"));
+const budgetName = 'test-budget';
+beforeEach(async () => {
+    // we need real datetime if we are going to mix new timestamps with our mock data
+    global.restoreDateNow();
+    const budgetPath = path.join(__dirname, '/mocks/budgets/', budgetName);
+    await fs.rm(budgetPath, { force: true, recursive: true });
+    await createTestBudget('default-budget-template', budgetName);
+    await api.init({
+        dataDir: path.join(__dirname, '/mocks/budgets/'),
+    });
+});
+afterEach(async () => {
+    global.currentMonth = null;
+    await api.shutdown();
+});
+async function createTestBudget(templateName, name) {
+    const templatePath = path.join(__dirname, '/../loot-core/src/mocks/files', templateName);
+    const budgetPath = path.join(__dirname, '/mocks/budgets/', name);
+    await fs.mkdir(budgetPath);
+    await fs.copyFile(path.join(templatePath, 'metadata.json'), path.join(budgetPath, 'metadata.json'));
+    await fs.copyFile(path.join(templatePath, 'db.sqlite'), path.join(budgetPath, 'db.sqlite'));
+}
+describe('API setup and teardown', () => {
+    // apis: loadBudget, getBudgetMonths
+    test('successfully loads budget', async () => {
+        await expect(api.loadBudget(budgetName)).resolves.toBeUndefined();
+        await expect(api.getBudgetMonths()).resolves.toMatchSnapshot();
+    });
+});
+describe('API CRUD operations', () => {
+    beforeEach(async () => {
+        // load test budget
+        await api.loadBudget(budgetName);
+    });
+    // apis: createCategoryGroup, updateCategoryGroup, deleteCategoryGroup
+    test('CategoryGroups: successfully update category groups', async () => {
+        const month = '2023-10';
+        global.currentMonth = month;
+        // create our test category group
+        const mainGroupId = await api.createCategoryGroup({
+            name: 'test-group',
+        });
+        let budgetMonth = await api.getBudgetMonth(month);
+        expect(budgetMonth.categoryGroups).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                id: mainGroupId,
+            }),
+        ]));
+        // update group
+        await api.updateCategoryGroup(mainGroupId, {
+            name: 'update-tests',
+        });
+        budgetMonth = await api.getBudgetMonth(month);
+        expect(budgetMonth.categoryGroups).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                id: mainGroupId,
+            }),
+        ]));
+        // delete group
+        await api.deleteCategoryGroup(mainGroupId);
+        budgetMonth = await api.getBudgetMonth(month);
+        expect(budgetMonth.categoryGroups).toEqual(expect.arrayContaining([
+            expect.not.objectContaining({
+                id: mainGroupId,
+            }),
+        ]));
+    });
+    // apis: createCategory, getCategories, updateCategory, deleteCategory
+    test('Categories: successfully update categories', async () => {
+        const month = '2023-10';
+        global.currentMonth = month;
+        // create our test category group
+        const mainGroupId = await api.createCategoryGroup({
+            name: 'test-group',
+        });
+        const secondaryGroupId = await api.createCategoryGroup({
+            name: 'test-secondary-group',
+        });
+        const categoryId = await api.createCategory({
+            name: 'test-budget',
+            group_id: mainGroupId,
+        });
+        const categoryIdHidden = await api.createCategory({
+            name: 'test-budget-hidden',
+            group_id: mainGroupId,
+            hidden: true,
+        });
+        let categories = await api.getCategories();
+        expect(categories).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                id: categoryId,
+                name: 'test-budget',
+                hidden: false,
+                group_id: mainGroupId,
+            }),
+            expect.objectContaining({
+                id: categoryIdHidden,
+                name: 'test-budget-hidden',
+                hidden: true,
+                group_id: mainGroupId,
+            }),
+        ]));
+        // update/move category
+        await api.updateCategory(categoryId, {
+            name: 'updated-budget',
+            group_id: secondaryGroupId,
+        });
+        await api.updateCategory(categoryIdHidden, {
+            name: 'updated-budget-hidden',
+            group_id: secondaryGroupId,
+            hidden: false,
+        });
+        categories = await api.getCategories();
+        expect(categories).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                id: categoryId,
+                name: 'updated-budget',
+                hidden: false,
+                group_id: secondaryGroupId,
+            }),
+            expect.objectContaining({
+                id: categoryIdHidden,
+                name: 'updated-budget-hidden',
+                hidden: false,
+                group_id: secondaryGroupId,
+            }),
+        ]));
+        // delete categories
+        await api.deleteCategory(categoryId);
+        expect(categories).toEqual(expect.arrayContaining([
+            expect.not.objectContaining({
+                id: categoryId,
+            }),
+        ]));
+    });
+    // apis: setBudgetAmount, setBudgetCarryover, getBudgetMonth
+    test('Budgets: successfully update budgets', async () => {
+        const month = '2023-10';
+        global.currentMonth = month;
+        // create some new categories to test with
+        const groupId = await api.createCategoryGroup({
+            name: 'tests',
+        });
+        const categoryId = await api.createCategory({
+            name: 'test-budget',
+            group_id: groupId,
+        });
+        await api.setBudgetAmount(month, categoryId, 100);
+        await api.setBudgetCarryover(month, categoryId, true);
+        const budgetMonth = await api.getBudgetMonth(month);
+        expect(budgetMonth.categoryGroups).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                id: groupId,
+                categories: expect.arrayContaining([
+                    expect.objectContaining({
+                        id: categoryId,
+                        budgeted: 100,
+                        carryover: true,
+                    }),
+                ]),
+            }),
+        ]));
+    });
+    //apis: createAccount, getAccounts, updateAccount, closeAccount, deleteAccount, reopenAccount
+    test('Accounts: successfully complete account operators', async () => {
+        const accountId1 = await api.createAccount({ name: 'test-account1', offbudget: true }, 1000);
+        const accountId2 = await api.createAccount({ name: 'test-account2' }, 0);
+        let accounts = await api.getAccounts();
+        // accounts successfully created
+        expect(accounts).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                id: accountId1,
+                name: 'test-account1',
+                offbudget: true,
+            }),
+            expect.objectContaining({ id: accountId2, name: 'test-account2' }),
+        ]));
+        await api.updateAccount(accountId1, { offbudget: false });
+        await api.closeAccount(accountId1, accountId2, null);
+        await api.deleteAccount(accountId2);
+        // accounts successfully updated, and one of them deleted
+        accounts = await api.getAccounts();
+        expect(accounts).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                id: accountId1,
+                name: 'test-account1',
+                closed: true,
+                offbudget: false,
+            }),
+            expect.not.objectContaining({ id: accountId2 }),
+        ]));
+        await api.reopenAccount(accountId1);
+        // the non-deleted account is reopened
+        accounts = await api.getAccounts();
+        expect(accounts).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                id: accountId1,
+                name: 'test-account1',
+                closed: false,
+            }),
+        ]));
+    });
+});

package/dist/migrations/1632571489012_remove_cache.js

@@ -31,25 +31,25 @@ CREATE TABLE kvcache (key TEXT PRIMARY KEY, value TEXT);
 CREATE TABLE kvcache_key (id INTEGER PRIMARY KEY, key REAL);
 `);
     // Migrate budget amounts and carryover
-    let budget = db.runQuery(`SELECT * FROM spreadsheet_cells WHERE name LIKE 'budget%!budget-%'`, [], true);
+    const budget = db.runQuery(`SELECT * FROM spreadsheet_cells WHERE name LIKE 'budget%!budget-%'`, [], true);
     db.transaction(() => {
         budget.forEach(monthBudget => {
-            let match = monthBudget.name.match(/^(budget-report|budget)(\d+)!budget-(.+)$/);
+            const match = monthBudget.name.match(/^(budget-report|budget)(\d+)!budget-(.+)$/);
             if (match == null) {
                 console.log('Warning: invalid budget month name', monthBudget.name);
                 return;
             }
-            let type = match[1];
-            let month = match[2].slice(0, 4) + '-' + match[2].slice(4);
-            let dbmonth = parseInt(match[2]);
-            let cat = match[3];
+            const type = match[1];
+            const month = match[2].slice(0, 4) + '-' + match[2].slice(4);
+            const dbmonth = parseInt(match[2]);
+            const cat = match[3];
             let amount = parseInt(getValue(monthBudget));
             if (isNaN(amount)) {
                 amount = 0;
             }
-            let sheetName = monthBudget.name.split('!')[0];
-            let carryover = db.runQuery('SELECT * FROM spreadsheet_cells WHERE name = ?', [`${sheetName}!carryover-${cat}`], true);
-            let table = type === 'budget-report' ? 'reflect_budgets' : 'zero_budgets';
+            const sheetName = monthBudget.name.split('!')[0];
+            const carryover = db.runQuery('SELECT * FROM spreadsheet_cells WHERE name = ?', [`${sheetName}!carryover-${cat}`], true);
+            const table = type === 'budget-report' ? 'reflect_budgets' : 'zero_budgets';
             db.runQuery(`INSERT INTO ${table} (id, month, category, amount, carryover) VALUES (?, ?, ?, ?, ?)`, [
                 `${month}-${cat}`,
                 dbmonth,
@@ -60,12 +60,12 @@ CREATE TABLE kvcache_key (id INTEGER PRIMARY KEY, key REAL);
         });
     });
     // Migrate buffers
-    let buffers = db.runQuery(`SELECT * FROM spreadsheet_cells WHERE name LIKE 'budget%!buffered'`, [], true);
+    const buffers = db.runQuery(`SELECT * FROM spreadsheet_cells WHERE name LIKE 'budget%!buffered'`, [], true);
     db.transaction(() => {
         buffers.forEach(buffer => {
-            let match = buffer.name.match(/^budget(\d+)!buffered$/);
+            const match = buffer.name.match(/^budget(\d+)!buffered$/);
             if (match) {
-                let month = match[1].slice(0, 4) + '-' + match[1].slice(4);
+                const month = match[1].slice(0, 4) + '-' + match[1].slice(4);
                 let amount = parseInt(getValue(buffer));
                 if (isNaN(amount)) {
                     amount = 0;
@@ -75,10 +75,10 @@ CREATE TABLE kvcache_key (id INTEGER PRIMARY KEY, key REAL);
         });
     });
     // Migrate notes
-    let notes = db.runQuery(`SELECT * FROM spreadsheet_cells WHERE name LIKE 'notes!%'`, [], true);
-    let parseNote = str => {
+    const notes = db.runQuery(`SELECT * FROM spreadsheet_cells WHERE name LIKE 'notes!%'`, [], true);
+    const parseNote = str => {
         try {
-            let value = JSON.parse(str);
+            const value = JSON.parse(str);
             return value && value !== '' ? value : null;
         }
         catch (e) {
@@ -87,9 +87,9 @@ CREATE TABLE kvcache_key (id INTEGER PRIMARY KEY, key REAL);
     };
     db.transaction(() => {
         notes.forEach(note => {
-            let parsed = parseNote(getValue(note));
+            const parsed = parseNote(getValue(note));
             if (parsed) {
-                let [, id] = note.name.split('!');
+                const [, id] = note.name.split('!');
                 db.runQuery(`INSERT INTO notes (id, note) VALUES (?, ?)`, [id, parsed]);
             }
         });

package/dist/migrations/1694438752000_add_goal_targets.sql

@@ -0,0 +1,7 @@
+BEGIN TRANSACTION;
+
+ALTER TABLE zero_budgets ADD column goal INTEGER DEFAULT null;
+ALTER TABLE reflect_budgets ADD column goal INTEGER DEFAULT null;
+ALTER TABLE categories ADD column goal_def TEXT DEFAULT null;
+
+COMMIT;

package/dist/migrations/1697046240000_add_reconciled.sql

@@ -0,0 +1,5 @@
+BEGIN TRANSACTION;
+
+ALTER TABLE transactions ADD COLUMN reconciled INTEGER DEFAULT 0;
+
+COMMIT;

package/dist/package.json

@@ -0,0 +1,36 @@
+{
+    "name": "@actual-app/api",
+    "version": "6.4.0",
+    "license": "MIT",
+    "description": "An API for Actual",
+    "engines": {
+        "node": ">=18.12.0"
+    },
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build:app": "yarn workspace loot-core build:api",
+        "build:node": "tsc --p tsconfig.dist.json",
+        "build:migrations": "cp migrations/*.sql dist/migrations",
+        "build:default-db": "cp default-db.sqlite dist/",
+        "build": "rm -rf dist && yarn run build:app && yarn run build:node && yarn run build:migrations && yarn run build:default-db",
+        "test": "yarn run build:app && jest -c jest.config.js"
+    },
+    "dependencies": {
+        "better-sqlite3": "^9.1.1",
+        "compare-versions": "^6.1.0",
+        "node-fetch": "^3.3.2",
+        "uuid": "^9.0.0"
+    },
+    "devDependencies": {
+        "@swc/core": "^1.3.82",
+        "@swc/jest": "^0.2.29",
+        "@types/jest": "^27.5.0",
+        "@types/uuid": "^9.0.2",
+        "jest": "^27.0.0",
+        "typescript": "^5.0.2"
+    }
+}

package/dist/validateNodeVersion.d.ts

@@ -0,0 +1 @@
+export function validateNodeVersion(): void;

package/dist/validateNodeVersion.js

@@ -0,0 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateNodeVersion = void 0;
+const compare_versions_1 = require("compare-versions");
+const packageJson = __importStar(require("./package.json"));
+function validateNodeVersion() {
+    if (process?.versions?.node) {
+        const nodeVersion = process?.versions?.node;
+        const minimumNodeVersion = packageJson.engines.node;
+        if (!(0, compare_versions_1.satisfies)(nodeVersion, minimumNodeVersion)) {
+            throw new Error(`@actual-app/api requires a node version ${minimumNodeVersion}. Found that you are using: ${nodeVersion}. Please upgrade to a higher version`);
+        }
+    }
+}
+exports.validateNodeVersion = validateNodeVersion;

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@actual-app/api",
-  "version": "6.2.1",
+  "version": "6.4.0",
   "license": "MIT",
   "description": "An API for Actual",
+  "engines": {
+    "node": ">=18.12.0"
+  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -13,15 +16,21 @@
     "build:node": "tsc --p tsconfig.dist.json",
     "build:migrations": "cp migrations/*.sql dist/migrations",
     "build:default-db": "cp default-db.sqlite dist/",
-    "build": "rm -rf dist && yarn run build:app && yarn run build:node && yarn run build:migrations && yarn run build:default-db"
+    "build": "rm -rf dist && yarn run build:app && yarn run build:node && yarn run build:migrations && yarn run build:default-db",
+    "test": "yarn run build:app && jest -c jest.config.js"
   },
   "dependencies": {
-    "better-sqlite3": "^8.2.0",
+    "better-sqlite3": "^9.1.1",
+    "compare-versions": "^6.1.0",
     "node-fetch": "^3.3.2",
     "uuid": "^9.0.0"
   },
   "devDependencies": {
+    "@swc/core": "^1.3.82",
+    "@swc/jest": "^0.2.29",
+    "@types/jest": "^27.5.0",
     "@types/uuid": "^9.0.2",
+    "jest": "^27.0.0",
     "typescript": "^5.0.2"
   }
 }