Add types to QueryState

* add copy template

* note, lint

* note

.devcontainer/devcontainer.json

@@ -0,0 +1,14 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/docker-existing-docker-compose
+{
+	"name": "Actual development",
+	"dockerComposeFile": [
+		"../docker-compose.yml",
+		"docker-compose.yml"
+	],
+	// Alternatively:
+	// "image": "mcr.microsoft.com/devcontainers/typescript-node:0-16",
+	"service": "actual-development",
+	"workspaceFolder": "/workspaces/${localWorkspaceFolderBasename}",
+	"postCreateCommand": "yarn install"
+}

.devcontainer/docker-compose.yml

@@ -0,0 +1,6 @@
+version: '3.8'
+services:
+  actual-development:
+    volumes:
+      - ..:/workspaces:cached
+    command: /bin/sh -c "while sleep 1000; do :; done"

.eslintignore

@@ -0,0 +1,28 @@
+packages/api/app/bundle.api.js
+packages/api/dist
+packages/api/@types
+packages/api/migrations
+
+packages/crdt/dist
+
+packages/desktop-client/bundle.browser.js
+packages/desktop-client/build/
+packages/desktop-client/build-stats/
+packages/desktop-client/public/kcab/
+packages/desktop-client/public/data/
+packages/desktop-client/**/node_modules/*
+packages/desktop-client/node_modules/
+packages/desktop-client/src/icons/**/*
+packages/desktop-client/test-results/
+packages/desktop-client/playwright-report/
+
+packages/desktop-electron/client-build/
+packages/desktop-electron/dist/
+
+packages/import-ynab4/**/node_modules/*
+
+packages/import-ynab5/**/node_modules/*
+
+packages/loot-core/**/node_modules/*
+packages/loot-core/**/lib-dist/*
+packages/loot-core/**/proto/*

.eslintrc.js

@@ -1,25 +1,317 @@
-module.exports = {
-  plugins: ['prettier', 'import'],
-  extends: ['react-app'],
-  rules: {
-    'prettier/prettier': 'error',
-    'no-unused-vars': 'off',
-    'no-loop-func': 'off',
-    'no-restricted-globals': 'off',
+const path = require('path');
 
-    'import/no-useless-path-segments': 'error',
-    'import/order': [
+const rulesDirPlugin = require('eslint-plugin-rulesdir');
+rulesDirPlugin.RULES_DIR = path.join(
+  __dirname,
+  'packages',
+  'eslint-plugin-actual',
+  'lib',
+  'rules',
+);
+
+const ruleFCMsg =
+  'Type the props argument and let TS infer or use ComponentType for a component prop';
+
+const restrictedImportPatterns = [
+  {
+    group: ['*.api', '*.web', '*.electron'],
+    message: 'Don’t directly reference imports from other platforms',
+  },
+  {
+    group: ['uuid'],
+    importNames: ['*'],
+    message: "Use `import { v4 as uuidv4 } from 'uuid'` instead",
+  },
+];
+
+const restrictedImportColors = [
+  {
+    group: ['**/style', '**/colors'],
+    importNames: ['colors'],
+    message: 'Please use themes instead of colors',
+  },
+];
+
+module.exports = {
+  root: true,
+  env: {
+    browser: true,
+    commonjs: true,
+    es6: true,
+    jest: true,
+    node: true,
+  },
+  plugins: [
+    'prettier',
+    'import',
+    'rulesdir',
+    '@typescript-eslint',
+    'jsx-a11y',
+    'react-hooks',
+  ],
+  extends: [
+    'plugin:react/recommended',
+    'plugin:react/jsx-runtime',
+    'plugin:prettier/recommended',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:import/typescript',
+  ],
+  parser: '@typescript-eslint/parser',
+  parserOptions: { project: [path.join(__dirname, './tsconfig.json')] },
+  reportUnusedDisableDirectives: true,
+  globals: {
+    globalThis: false,
+    vi: true,
+  },
+  rules: {
+    // http://eslint.org/docs/rules/
+    'array-callback-return': 'warn',
+    'default-case': ['warn', { commentPattern: '^no default$' }],
+    'dot-location': ['warn', 'property'],
+    eqeqeq: ['warn', 'smart'],
+    'new-parens': 'warn',
+    'no-array-constructor': 'warn',
+    'no-caller': 'warn',
+    'no-cond-assign': ['warn', 'except-parens'],
+    'no-const-assign': 'warn',
+    'no-control-regex': 'warn',
+    'no-delete-var': 'warn',
+    'no-dupe-args': 'warn',
+    'no-dupe-class-members': 'warn',
+    'no-dupe-keys': 'warn',
+    'no-duplicate-case': 'warn',
+    'no-empty-character-class': 'warn',
+    'no-empty-pattern': 'warn',
+    'no-eval': 'warn',
+    'no-ex-assign': 'warn',
+    'no-extend-native': 'warn',
+    'no-extra-bind': 'warn',
+    'no-extra-label': 'warn',
+    'no-fallthrough': 'warn',
+    'no-func-assign': 'warn',
+    'no-implied-eval': 'warn',
+    'no-invalid-regexp': 'warn',
+    'no-iterator': 'warn',
+    'no-label-var': 'warn',
+    'no-labels': ['warn', { allowLoop: true, allowSwitch: false }],
+    'no-lone-blocks': 'warn',
+    'no-mixed-operators': [
+      'warn',
+      {
+        groups: [
+          ['&', '|', '^', '~', '<<', '>>', '>>>'],
+          ['==', '!=', '===', '!==', '>', '>=', '<', '<='],
+          ['&&', '||'],
+          ['in', 'instanceof'],
+        ],
+        allowSamePrecedence: false,
+      },
+    ],
+    'no-multi-str': 'warn',
+    'no-global-assign': 'warn',
+    'no-unsafe-negation': 'warn',
+    'no-new-func': 'warn',
+    'no-new-object': 'warn',
+    'no-new-symbol': 'warn',
+    'no-new-wrappers': 'warn',
+    'no-obj-calls': 'warn',
+    'no-octal': 'warn',
+    'no-octal-escape': 'warn',
+    'no-redeclare': 'warn',
+    'no-regex-spaces': 'warn',
+    'no-script-url': 'warn',
+    'no-self-assign': 'warn',
+    'no-self-compare': 'warn',
+    'no-sequences': 'warn',
+    'no-shadow-restricted-names': 'warn',
+    'no-sparse-arrays': 'warn',
+    'no-template-curly-in-string': 'warn',
+    'no-this-before-super': 'warn',
+    'no-throw-literal': 'warn',
+    'no-undef': 'error',
+    'no-unreachable': 'warn',
+    'no-unused-expressions': [
       'error',
+      {
+        allowShortCircuit: true,
+        allowTernary: true,
+        allowTaggedTemplates: true,
+      },
+    ],
+    'no-unused-labels': 'warn',
+    'no-use-before-define': [
+      'warn',
+      {
+        functions: false,
+        classes: false,
+        variables: false,
+      },
+    ],
+    'no-useless-computed-key': 'warn',
+    'no-useless-concat': 'warn',
+    'no-useless-constructor': 'warn',
+    'no-useless-escape': 'warn',
+    'no-useless-rename': [
+      'warn',
+      {
+        ignoreDestructuring: false,
+        ignoreImport: false,
+        ignoreExport: false,
+      },
+    ],
+    'no-with': 'warn',
+    'no-whitespace-before-property': 'warn',
+    'react-hooks/exhaustive-deps': 'warn',
+    'require-yield': 'warn',
+    'rest-spread-spacing': ['warn', 'never'],
+    strict: ['warn', 'never'],
+    'unicode-bom': ['warn', 'never'],
+    'use-isnan': 'warn',
+    'valid-typeof': 'warn',
+    'no-restricted-properties': [
+      'error',
+      {
+        object: 'require',
+        property: 'ensure',
+        message:
+          'Please use import() instead. More info: https://facebook.github.io/create-react-app/docs/code-splitting',
+      },
+      {
+        object: 'System',
+        property: 'import',
+        message:
+          'Please use import() instead. More info: https://facebook.github.io/create-react-app/docs/code-splitting',
+      },
+    ],
+    'getter-return': 'warn',
+
+    // https://github.com/benmosher/eslint-plugin-import/tree/master/docs/rules
+    'import/first': 'error',
+    'import/no-amd': 'error',
+    'import/no-anonymous-default-export': 'warn',
+    'import/no-webpack-loader-syntax': 'error',
+
+    // https://github.com/yannickcr/eslint-plugin-react/tree/master/docs/rules
+    'react/forbid-foreign-prop-types': ['warn', { allowInPropTypes: true }],
+    'react/jsx-no-comment-textnodes': 'warn',
+    'react/jsx-no-duplicate-props': 'warn',
+    'react/jsx-no-target-blank': 'warn',
+    'react/jsx-no-undef': 'error',
+    'react/jsx-pascal-case': [
+      'warn',
+      {
+        allowAllCaps: true,
+        ignore: [],
+      },
+    ],
+    'react/no-danger-with-children': 'warn',
+    // Disabled because of undesirable warnings
+    // See https://github.com/facebook/create-react-app/issues/5204 for
+    // blockers until its re-enabled
+    // 'react/no-deprecated': 'warn',
+    'react/no-direct-mutation-state': 'warn',
+    'react/no-is-mounted': 'warn',
+    'react/no-typos': 'error',
+    'react/require-render-return': 'error',
+    'react/style-prop-object': 'warn',
+
+    // https://github.com/evcohen/eslint-plugin-jsx-a11y/tree/master/docs/rules
+    'jsx-a11y/alt-text': 'warn',
+    'jsx-a11y/anchor-has-content': 'warn',
+    'jsx-a11y/anchor-is-valid': [
+      'warn',
+      {
+        aspects: ['noHref', 'invalidHref'],
+      },
+    ],
+    'jsx-a11y/aria-activedescendant-has-tabindex': 'warn',
+    'jsx-a11y/aria-props': 'warn',
+    'jsx-a11y/aria-proptypes': 'warn',
+    'jsx-a11y/aria-role': ['warn', { ignoreNonDOM: true }],
+    'jsx-a11y/aria-unsupported-elements': 'warn',
+    'jsx-a11y/heading-has-content': 'warn',
+    'jsx-a11y/iframe-has-title': 'warn',
+    'jsx-a11y/img-redundant-alt': 'warn',
+    'jsx-a11y/no-access-key': 'warn',
+    'jsx-a11y/no-distracting-elements': 'warn',
+    'jsx-a11y/no-redundant-roles': 'warn',
+    'jsx-a11y/role-has-required-aria-props': 'warn',
+    'jsx-a11y/role-supports-aria-props': 'warn',
+    'jsx-a11y/scope': 'warn',
+
+    // https://github.com/facebook/react/tree/main/packages/eslint-plugin-react-hooks
+    'react-hooks/rules-of-hooks': 'error',
+
+    'prettier/prettier': 'warn',
+
+    // Note: base rule explicitly disabled in favor of the TS one
+    'no-unused-vars': 'off',
+    '@typescript-eslint/no-unused-vars': [
+      'warn',
+      {
+        varsIgnorePattern: '^(_|React)',
+        ignoreRestSiblings: true,
+        caughtErrors: 'none',
+      },
+    ],
+
+    curly: ['warn', 'multi-line', 'consistent'],
+
+    'no-restricted-globals': ['warn'].concat(
+      require('confusing-browser-globals').filter(g => g !== 'self'),
+    ),
+
+    'react/jsx-filename-extension': [
+      'warn',
+      { extensions: ['.jsx', '.tsx'], allow: 'as-needed' },
+    ],
+    'react/jsx-no-useless-fragment': 'warn',
+    'react/self-closing-comp': 'warn',
+    'react/no-unstable-nested-components': [
+      'warn',
+      { allowAsProps: true, customValidators: ['formatter'] },
+    ],
+
+    'rulesdir/typography': 'warn',
+    'rulesdir/prefer-if-statement': 'warn',
+
+    // https://github.com/eslint/eslint/issues/16954
+    // https://github.com/eslint/eslint/issues/16953
+    'no-loop-func': 'off',
+
+    // Do don't need this as we're using TypeScript
+    'react/prop-types': 'off',
+
+    // TODO: re-enable these rules
+    'react/react-in-jsx-scope': 'off',
+
+    'no-var': 'warn',
+    'react/jsx-curly-brace-presence': 'warn',
+    'object-shorthand': ['warn', 'properties'],
+
+    'import/extensions': [
+      'warn',
+      'never',
+      {
+        json: 'always',
+      },
+    ],
+    'import/no-useless-path-segments': 'warn',
+    'import/no-duplicates': ['warn', { 'prefer-inline': true }],
+    'import/no-unused-modules': ['warn', { unusedExports: true }],
+    'import/order': [
+      'warn',
       {
         alphabetize: {
           caseInsensitive: true,
-          order: 'asc'
+          order: 'asc',
         },
         groups: [
           'builtin', // Built-in types are first
           'external',
-          ['sibling', 'parent'], // Then sibling and parent types. They can be mingled together
-          'index' // Then the index file
+          'parent',
+          'sibling',
+          'index', // Then the index file
         ],
         'newlines-between': 'always',
         pathGroups: [
@@ -29,11 +321,283 @@ module.exports = {
           {
             group: 'external',
             pattern: 'loot-{core,design}/**/*',
-            position: 'after'
-          }
+            position: 'after',
+          },
         ],
-        pathGroupsExcludedImportTypes: ['react']
-      }
-    ]
-  }
+        pathGroupsExcludedImportTypes: ['react'],
+      },
+    ],
+
+    'no-restricted-syntax': [
+      'warn',
+      {
+        // forbid React.* as they are legacy https://twitter.com/dan_abramov/status/1308739731551858689
+        selector:
+          ":matches(MemberExpression[object.name='React'], TSQualifiedName[left.name='React'])",
+        message:
+          'Using default React import is discouraged, please use named exports directly instead.',
+      },
+      {
+        // forbid <a> in favor of <Link>
+        selector: 'JSXOpeningElement[name.name="a"]',
+        message: 'Using <a> is discouraged, please use <Link> instead.',
+      },
+    ],
+    'no-restricted-imports': [
+      'warn',
+      { patterns: [...restrictedImportPatterns, ...restrictedImportColors] },
+    ],
+
+    '@typescript-eslint/ban-ts-comment': [
+      'error',
+      { 'ts-ignore': 'allow-with-description' },
+    ],
+
+    // Rules disable during TS migration
+    '@typescript-eslint/no-var-requires': 'off',
+    'prefer-const': 'warn',
+    'prefer-spread': 'off',
+    '@typescript-eslint/no-empty-function': 'off',
+    '@typescript-eslint/no-require-imports': 'off',
+    'import/no-default-export': 'warn',
+  },
+  overrides: [
+    {
+      files: ['**/*.ts?(x)'],
+      parser: '@typescript-eslint/parser',
+      parserOptions: {
+        ecmaVersion: 2018,
+        sourceType: 'module',
+        ecmaFeatures: {
+          jsx: true,
+        },
+
+        // typescript-eslint specific options
+        warnOnUnsupportedTypeScriptVersion: true,
+      },
+      plugins: ['@typescript-eslint'],
+      // If adding a typescript-eslint version of an existing ESLint rule,
+      // make sure to disable the ESLint rule here.
+      rules: {
+        // TypeScript's `noFallthroughCasesInSwitch` option is more robust (#6906)
+        'default-case': 'off',
+        // 'tsc' already handles this (https://github.com/typescript-eslint/typescript-eslint/issues/291)
+        'no-dupe-class-members': 'off',
+        // 'tsc' already handles this (https://github.com/typescript-eslint/typescript-eslint/issues/477)
+        'no-undef': 'off',
+
+        // Add TypeScript specific rules (and turn off ESLint equivalents)
+        '@typescript-eslint/consistent-type-assertions': 'warn',
+        'no-array-constructor': 'off',
+        '@typescript-eslint/no-array-constructor': 'warn',
+        'no-redeclare': 'off',
+        '@typescript-eslint/no-redeclare': 'warn',
+        'no-use-before-define': 'off',
+        '@typescript-eslint/no-use-before-define': [
+          'warn',
+          {
+            functions: false,
+            classes: false,
+            variables: false,
+            typedefs: false,
+          },
+        ],
+        'no-unused-expressions': 'off',
+        '@typescript-eslint/no-unused-expressions': [
+          'error',
+          {
+            allowShortCircuit: true,
+            allowTernary: true,
+            allowTaggedTemplates: true,
+          },
+        ],
+        'no-useless-constructor': 'off',
+        '@typescript-eslint/no-useless-constructor': 'warn',
+      },
+    },
+    {
+      files: ['.eslintrc.js', './**/.eslintrc.js'],
+      parserOptions: { project: null },
+      rules: {
+        '@typescript-eslint/consistent-type-exports': 'off',
+      },
+    },
+    {
+      files: [
+        './packages/desktop-client/**/*.{ts,tsx}',
+        './packages/loot-core/src/client/**/*.{ts,tsx}',
+      ],
+      rules: {
+        // enforce type over interface
+        '@typescript-eslint/consistent-type-definitions': ['warn', 'type'],
+        // enforce import type
+        '@typescript-eslint/consistent-type-imports': [
+          'warn',
+          { prefer: 'type-imports', fixStyle: 'inline-type-imports' },
+        ],
+        '@typescript-eslint/no-restricted-types': [
+          'warn',
+          {
+            types: {
+              // forbid FC as superflous
+              FunctionComponent: { message: ruleFCMsg },
+              FC: { message: ruleFCMsg },
+            },
+          },
+        ],
+      },
+    },
+    {
+      files: ['./packages/desktop-client/**/*'],
+      excludedFiles: [
+        './packages/desktop-client/src/hooks/useNavigate.{ts,tsx}',
+      ],
+      rules: {
+        'no-restricted-imports': [
+          'warn',
+          {
+            patterns: [
+              {
+                group: ['react-router-dom'],
+                importNames: ['useNavigate'],
+                message: 'Please use Actual’s useNavigate() hook instead.',
+              },
+            ],
+          },
+        ],
+      },
+    },
+    {
+      files: ['./packages/loot-core/src/**/*'],
+      rules: {
+        'no-restricted-imports': [
+          'warn',
+          {
+            patterns: [
+              ...restrictedImportPatterns,
+              {
+                group: ['loot-core/**'],
+                message:
+                  'Please use relative imports in loot-core instead of importing from `loot-core/*`',
+              },
+            ],
+          },
+        ],
+      },
+    },
+    {
+      files: [
+        'packages/loot-core/src/types/**/*',
+        'packages/loot-core/src/client/state-types/**/*',
+        '**/icons/**/*',
+        '**/{mocks,__mocks__}/**/*',
+        // can't correctly resolve usages
+        '**/*.{testing,electron,browser,web,api}.ts',
+      ],
+      rules: { 'import/no-unused-modules': 'off' },
+    },
+    {
+      files: [
+        './packages/desktop-client/src/style/index.*',
+        './packages/desktop-client/src/style/palette.*',
+      ],
+      rules: {
+        'no-restricted-imports': ['off', { patterns: restrictedImportColors }],
+      },
+    },
+    {
+      files: [
+        './packages/api/migrations/*',
+        './packages/loot-core/migrations/*',
+      ],
+      rules: {
+        'import/no-default-export': 'off',
+      },
+    },
+    {
+      // TODO: fix the issues in these files
+      files: [
+        './packages/desktop-client/src/components/accounts/Account.jsx',
+        './packages/desktop-client/src/components/accounts/MobileAccount.jsx',
+        './packages/desktop-client/src/components/accounts/MobileAccounts.jsx',
+        './packages/desktop-client/src/components/App.tsx',
+        './packages/desktop-client/src/components/budget/BudgetCategories.jsx',
+        './packages/desktop-client/src/components/budget/BudgetSummaries.tsx',
+        './packages/desktop-client/src/components/budget/DynamicBudgetTable.tsx',
+        './packages/desktop-client/src/components/budget/index.tsx',
+        './packages/desktop-client/src/components/budget/MobileBudget.tsx',
+        './packages/desktop-client/src/components/budget/envelope/HoldMenu.tsx',
+        './packages/desktop-client/src/components/budget/envelope/TransferMenu.tsx',
+        './packages/desktop-client/src/components/common/Menu.tsx',
+        './packages/desktop-client/src/components/FinancesApp.tsx',
+        './packages/desktop-client/src/components/GlobalKeys.ts',
+        './packages/desktop-client/src/components/LoggedInUser.tsx',
+        './packages/desktop-client/src/components/manager/ManagementApp.jsx',
+        './packages/desktop-client/src/components/manager/subscribe/common.tsx',
+        './packages/desktop-client/src/components/ManageRules.tsx',
+        './packages/desktop-client/src/components/mobile/MobileAmountInput.jsx',
+        './packages/desktop-client/src/components/mobile/MobileNavTabs.tsx',
+        './packages/desktop-client/src/components/Modals.tsx',
+        './packages/desktop-client/src/components/modals/EditRule.jsx',
+        './packages/desktop-client/src/components/modals/ImportTransactions.jsx',
+        './packages/desktop-client/src/components/modals/MergeUnusedPayees.jsx',
+        './packages/desktop-client/src/components/Notifications.tsx',
+        './packages/desktop-client/src/components/payees/ManagePayees.jsx',
+        './packages/desktop-client/src/components/payees/ManagePayeesWithData.jsx',
+        './packages/desktop-client/src/components/payees/PayeeTable.tsx',
+        './packages/desktop-client/src/components/reports/graphs/tableGraph/ReportTable.tsx',
+        './packages/desktop-client/src/components/reports/graphs/tableGraph/ReportTableTotals.tsx',
+        './packages/desktop-client/src/components/reports/reports/CashFlowCard.jsx',
+        './packages/desktop-client/src/components/reports/reports/CustomReport.jsx',
+        './packages/desktop-client/src/components/reports/reports/NetWorthCard.jsx',
+        './packages/desktop-client/src/components/reports/SaveReportName.tsx',
+        './packages/desktop-client/src/components/reports/useReport.ts',
+        './packages/desktop-client/src/components/schedules/ScheduleDetails.jsx',
+        './packages/desktop-client/src/components/schedules/SchedulesTable.tsx',
+        './packages/desktop-client/src/components/select/DateSelect.tsx',
+        './packages/desktop-client/src/components/sidebar/Tools.tsx',
+        './packages/desktop-client/src/components/sort.tsx',
+        './packages/desktop-client/src/components/spreadsheet/useSheetValue.ts',
+        './packages/desktop-client/src/components/table.tsx',
+        './packages/desktop-client/src/components/Titlebar.tsx',
+        './packages/desktop-client/src/components/transactions/MobileTransaction.jsx',
+        './packages/desktop-client/src/components/transactions/SelectedTransactions.jsx',
+        './packages/desktop-client/src/components/transactions/SimpleTransactionsTable.jsx',
+        './packages/desktop-client/src/components/transactions/TransactionList.jsx',
+        './packages/desktop-client/src/components/transactions/TransactionsTable.jsx',
+        './packages/desktop-client/src/components/transactions/TransactionsTable.test.jsx',
+        './packages/desktop-client/src/hooks/useAccounts.ts',
+        './packages/desktop-client/src/hooks/useCategories.ts',
+        './packages/desktop-client/src/hooks/usePayees.ts',
+        './packages/desktop-client/src/hooks/useProperFocus.tsx',
+        './packages/desktop-client/src/hooks/useSelected.tsx',
+        './packages/loot-core/src/client/query-hooks.tsx',
+      ],
+      rules: {
+        'react-hooks/exhaustive-deps': 'off',
+      },
+    },
+    {
+      files: [
+        '.eslintrc.js',
+        '*.test.js',
+        '*.test.ts',
+        '*.test.jsx',
+        '*.test.tsx',
+      ],
+      rules: {
+        'rulesdir/typography': 'off',
+      },
+    },
+  ],
+  settings: {
+    react: {
+      version: 'detect',
+    },
+    'import/resolver': {
+      typescript: {
+        alwaysTryTypes: true,
+      },
+    },
+  },
 };

.gitattributes

@@ -1 +1,19 @@
-yarn.lock text eol=lf
+# Set the default behavior, in case people don't have core.autocrlf set.
+* text=auto
+
+# Explicitly declare text files you want to always be normalized and converted
+# to native line endings on checkout.
+# *.c text
+# *.h text
+
+# Declare files that will always have LF line endings on checkout.
+*.js text eol=lf
+*.ts text eol=lf
+*.sh text eol=lf
+*.tsx text eol=lf
+
+yarn.lock text eol=lf
+
+# Denote all files that are truly binary and should not be modified.
+*.png binary
+*.jpg binary

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# Funding policies: https://actualbudget.org/docs/contributing/leadership/funding
+open_collective: actual
+github: actualbudget

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -1,38 +1,41 @@
 name: Bug Report
 description: File a bug report also known as an issue or problem.
 title: '[Bug]: '
-labels: ['bug', 'needs triage']
+labels: ['bug']
 body:
   - type: markdown
     id: intro-md
     attributes:
       value: |
-        Thanks for taking the time to fill out this bug report! Please ensure you provide as much information as asked to better assist in confirming and identifying a fix for the bug report.
-  - type: dropdown
+        Thanks for taking the time to fill out this bug report! Please ensure you provide as much information as possible to better assist in confirming and identifying a fix for the bug.
+  - type: markdown
+    id: intro-md
+    attributes:
+      value: |
+        **IMPORTANT:** we use Github Issues only for BUG REPORTS and FEATURE REQUESTS. If you are looking for help/support - please reach out to the [community on Discord](https://discord.gg/pRYNYr4W5A). All non-bug and non-feature-request issues will be closed.
+
+        **Bank-sync problems (SimpleFin / GoCardless)?** Reach out via the [community Discord](https://discord.gg/pRYNYr4W5A) first and open an issue only if the community deems the issue to be a legitimate bug in Actual.
+  - type: checkboxes
     id: existing-issue
     attributes:
       label: 'Verified issue does not already exist?'
       description: 'Please search to see if an issue already exists for the issue you encountered.'
       options:
-        - 'I have searched and found no existing issue'
+        - label: 'I have searched and found no existing issue'
+          required: true
+        - label: 'I will be providing steps how to reproduce the bug (in most cases this will also mean uploading a demo budget file)'
+          required: true
     validations:
       required: true
   - type: textarea
     id: what-happened
     attributes:
       label: What happened?
-      description: Also tell us, what did you expect to happen?
+      description: Also tell us, what did you expect to happen? If you’re reporting an issue with imports, please attach a (redacted) version of the file you’re having trouble importing. You may need to zip it before uploading.
       placeholder: Tell us what you see!
       value: 'A bug happened!'
     validations:
       required: true
-  - type: textarea
-    id: errors-received
-    attributes:
-      label: 'What error did you receive?'
-      description: 'If you received an error or a message on the screen, please provide that here.'
-    validations:
-      required: false
   - type: markdown
     id: env-info
     attributes:
@@ -46,7 +49,9 @@ body:
         - Locally via Yarn
         - Docker
         - Fly.io
+        - Pikapods
         - NAS
+        - Desktop App (Electron)
         - Other
     validations:
       required: false
@@ -60,6 +65,7 @@ body:
         - Chrome
         - Safari
         - Microsoft Edge
+        - Desktop App (Electron)
         - Other
   - type: dropdown
     id: operating-system

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,8 @@
 blank_issues_enabled: false
 contact_links:
-  - name: Feature Request?
-    url: https://github.com/actualbudget/actual/discussions/new?category=ideas
-    about: Website is hosted via GitHub Discussions under actualbudget/actual
+  - name: Bank-sync issues
+    url: https://discord.gg/pRYNYr4W5A
+    about: Is bank-sync not working? Returning too much or too few information? Reach out to the community on Discord.
+  - name: Support
+    url: https://discord.gg/pRYNYr4W5A
+    about: Need help with something? Having troubles setting up? Or perhaps issues using the API? Reach out to the community on Discord.

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -0,0 +1,47 @@
+name: Feature request
+description: Request a missing feature
+title: '[Feature] '
+labels: ['feature']
+body:
+  - type: markdown
+    id: intro-md
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this feature request! Please ensure you provide as much information as possible so we can better understand what you’re proposing so we can come up with the best solution for everyone.
+  - type: checkboxes
+    id: existing-issue
+    attributes:
+      label: 'Verified feature request does not already exist?'
+      description: 'Please search to see if an issue or PR already exists for the feature you’re requesting.'
+      options:
+        - label: 'I have searched and found no existing issue'
+          required: true
+    validations:
+      required: true
+  - type: checkboxes
+    attributes:
+      label: '💻'
+      description: (Optional) Please check this box if you’re willing to open a PR to implement this feature. We’ll help you get started and answer any questions you have along the way :)
+      options:
+        - label: Would you like to implement this feature?
+  - type: textarea
+    id: pitch
+    attributes:
+      label: 'Pitch: what problem are you trying to solve?'
+      description: Please describe, in as much detail as you can, the problem that motivated you to submit this feature request.
+    validations:
+      required: true
+  - type: textarea
+    id: solution
+    attributes:
+      label: Describe your ideal solution to this problem
+      description: Feel free to give multiple different ideas for how the problem could be solved — we’d love to have a discussion to find the best way to solve your problem and related problems others may face! (Or leave this blank if you don’t have a solution in mind yet.)
+    validations:
+      required: false
+  - type: textarea
+    id: learning
+    attributes:
+      label: Teaching and learning
+      description: How can we make sure future users find and enjoy this feature? (i.e. how do we make it discoverable? what kind of documentation should we write? are there aspects of the feature that could trip up users?)
+    validations:
+      required: false

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1 @@
+<!-- Thank you for submitting a pull request! Make sure to follow the instructions to write release notes for your PR — it should only take a minute or two: https://github.com/actualbudget/docs#writing-good-release-notes -->

.github/actions/check-migrations.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+// overview:
+// 1. Identify the migrations in packages/loot-core/migrations/* on `master` and HEAD
+// 2. Make sure that any new migrations on HEAD are dated after the latest migration on `master`.
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const migrationsDir = path.join(
+  __dirname,
+  '..',
+  '..',
+  'packages',
+  'loot-core',
+  'migrations',
+);
+
+function readMigrations(ref) {
+  const { stdout } = spawnSync('git', [
+    'ls-tree',
+    '--name-only',
+    ref,
+    migrationsDir + '/',
+  ]);
+  const files = stdout.toString().split('\n').filter(Boolean);
+  console.log(`Found ${files.length} migrations on ${ref}.`);
+  return files
+    .map(file => path.basename(file))
+    .filter(file => !file.startsWith('.'))
+    .map(name => ({
+      date: parseInt(name.split('_')[0]),
+      name: name.match(/^\d+_(.+?)(\.sql)?$/)?.[1] ?? '***' + name,
+    }));
+}
+
+spawnSync('git', ['fetch', 'origin', 'master']);
+let masterMigrations = readMigrations('origin/master');
+let headMigrations = readMigrations('HEAD');
+
+let latestMasterMigration = masterMigrations[masterMigrations.length - 1].date;
+let newMigrations = headMigrations.filter(
+  migration => !masterMigrations.find(m => m.name === migration.name),
+);
+let badMigrations = newMigrations.filter(
+  migration => migration.date <= latestMasterMigration,
+);
+
+if (badMigrations.length) {
+  console.error(
+    `The following migrations are dated before the latest migration on master:`,
+  );
+  badMigrations.forEach(migration => {
+    console.error(`  ${migration.name}`);
+  });
+  process.exit(1);
+} else {
+  console.log(`All migrations are dated after the latest migration on master.`);
+}

.github/actions/handle-feature-requests.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+
+// overview:
+// 1. Fetch the issues that are linked to the PR
+// 2. Filter out the issues that are not feature requests
+// 3. For each feature request:
+//   1. Remove the 'help wanted' & 'needs votes' labels
+//   3. Find the automated comment, hide the comment as 'outdated'
+//   5. Post a new comment saying that the feature request has been implemented, and will be released in the next version. Link to the PR.
+
+async function makeAPIRequest(query, variables) {
+  const res = await fetch('https://api.github.com/graphql', {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${process.env.GITHUB_TOKEN}`,
+      'Content-Type': 'application/json',
+      Accept: 'application/json',
+    },
+    body: JSON.stringify({ query, variables }),
+  });
+  return res.json();
+}
+
+function group(name, body) {
+  console.log(`::group::${name}`);
+  const result = body();
+  if (result instanceof Promise) {
+    return result.finally(() => console.log(`::endgroup::`));
+  }
+  console.log(`::endgroup::`);
+  return result;
+}
+
+async function main() {
+  const featureRequests = await group('Pull Request API Response', async () => {
+    const res = await makeAPIRequest(
+      /* GraphQL */ `
+        query FetchLinkedIssues($pr: Int!) {
+          repository(owner: "actualbudget", name: "actual") {
+            pullRequest(number: $pr) {
+              closingIssuesReferences(first: 10) {
+                nodes {
+                  id
+                  number
+                  labels(first: 10) {
+                    nodes {
+                      id
+                      name
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      `,
+      { pr: parseInt(process.env.PR_NUMBER) },
+    );
+
+    console.log(JSON.stringify(res, null, 2));
+
+    return res.data.repository.pullRequest.closingIssuesReferences.nodes.filter(
+      issue => issue.labels.nodes.some(label => label.name === 'feature'),
+    );
+  });
+
+  if (featureRequests.length === 0) {
+    console.log('No linked feature requests found');
+    return;
+  }
+
+  for (const { id, number, labels } of featureRequests) {
+    await group(`Issue #${number}: Remove labels`, async () => {
+      const toRemove = labels.nodes
+        .filter(
+          label =>
+            label.name === 'help wanted' ||
+            label.name === 'needs votes' ||
+            label.name === 'good first issue',
+        )
+        .map(label => label.id);
+      const res = await makeAPIRequest(
+        /* GraphQL */ `
+          mutation RemoveLabels($issue: ID!, $labels: [ID!]!) {
+            removeLabelsFromLabelable(
+              input: {
+                clientMutationId: "1"
+                labelIds: $labels
+                labelableId: $issue
+              }
+            ) {
+              clientMutationId
+            }
+          }
+        `,
+        {
+          issue: id,
+          labels: toRemove,
+        },
+      );
+      console.log(JSON.stringify(res, null, 2));
+    });
+
+    await group(`Issue #${number}: Collapse automatic comment`, async () => {
+      const commentRes = await makeAPIRequest(
+        /* GraphQL */ `
+          query FetchComments($issue: Int!) {
+            repository(owner: "actualbudget", name: "actual") {
+              issue(number: $issue) {
+                comments(first: 100) {
+                  nodes {
+                    id
+                    body
+                    author {
+                      login
+                    }
+                  }
+                }
+              }
+            }
+          }
+        `,
+        { issue: number },
+      );
+      console.log(JSON.stringify(commentRes, null, 2));
+
+      const comments = commentRes.data.repository.issue.comments.nodes.filter(
+        comment => comment.author.login === 'github-actions',
+      );
+      const commentToCollapse =
+        comments.find(comment =>
+          comment.body.includes('<!-- feature-auto-close-comment -->'),
+        ) ||
+        comments.find(comment =>
+          comment.body.includes(
+            ':sparkles: Thanks for sharing your idea! :sparkles:',
+          ),
+        );
+
+      if (!commentToCollapse) {
+        console.log('No comment to collapse found');
+        process.exit(1);
+      }
+
+      const res = await makeAPIRequest(
+        /* GraphQL */ `
+          mutation CollapseComment($comment: ID!) {
+            minimizeComment(
+              input: { classifier: OUTDATED, subjectId: $comment }
+            ) {
+              clientMutationId
+            }
+          }
+        `,
+        { comment: commentToCollapse.id },
+      );
+      console.log(JSON.stringify(res, null, 2));
+    });
+
+    await group(`Issue #${number}: Post comment`, async () => {
+      const res = await makeAPIRequest(
+        /* GraphQL */ `
+          mutation PostComment($issue: ID!, $body: String!) {
+            addComment(
+              input: { subjectId: $issue, body: $body, clientMutationId: "1" }
+            ) {
+              clientMutationId
+            }
+          }
+        `,
+        {
+          issue: id,
+          body: `:tada: This feature has been implemented in #${process.env.PR_NUMBER} and will be released in the next version. Thanks for sharing your idea! :tada:\n\n<!-- feature-implemented-comment -->`,
+        },
+      );
+      console.log(JSON.stringify(res, null, 2));
+    });
+  }
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

.github/actions/netlify-wait-for-build

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+current_commit=$(git rev-parse HEAD)
+
+echo "Running on commit $COMMIT_SHA"
+
+function get_status() {
+  echo "::group::API Response"
+  curl --header "Authorization: Bearer $GITHUB_TOKEN" "https://api.github.com/repos/actualbudget/actual/commits/$COMMIT_SHA/statuses" > /tmp/status.json
+  cat /tmp/status.json
+  echo "::endgroup::"
+  netlify=$(yarn jq '[.[] | select(.context == "netlify/actualbudget/deploy-preview")][0]' /tmp/status.json)
+  state=$(yarn jq -r '.state' <<< "$netlify")
+  echo "::group::Netlify Status"
+  echo "$netlify"
+  echo "::endgroup::"
+}
+
+get_status
+
+while [ "$netlify" == "null" ]; do
+  echo "Waiting for Netlify to start building..."
+  sleep 10
+  get_status
+done
+
+while [ "$state" == "pending" ]; do
+  echo "Waiting for Netlify to finish building..."
+  sleep 10
+  get_status
+done
+
+if [ "$state" == "success" ]; then
+  echo -e "\033[0;32mNetlify build succeeded!\033[0m"
+  yarn jq -r '"url=" + .target_url' <<< "$netlify" > $GITHUB_OUTPUT
+  exit 0
+else
+  echo -e "\033[0;31mNetlify build failed. Cancelling end-to-end tests.\033[0m"
+  exit 1
+fi

.github/actions/setup/action.yml

@@ -4,15 +4,15 @@ runs:
   using: composite
   steps:
     - name: Install node
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v4
       with:
-        node-version: 16.15.0
+        node-version: 18.16.0
     - name: Cache
-      uses: actions/cache@v2
+      uses: actions/cache@v4
       id: cache
       with:
         path: '**/node_modules'
-        key: yarn-v1-${{ runner.os }}-${{ hashFiles('**/yarn.lock') }}
+        key: yarn-v1-${{ runner.os }}-${{ hashFiles('.nvmrc') }}-${{ hashFiles('**/yarn.lock') }}
     - name: Install
       run: yarn --immutable
       shell: bash

.github/workflows/build.yml

@@ -12,40 +12,59 @@ on:
     branches:
       - master
   pull_request:
-    branches: '*'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
 
 jobs:
   api:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: Set up environment
         uses: ./.github/actions/setup
       - name: Build API
-        run: cd packages/loot-core && yarn build:api
+        run: cd packages/api && yarn build
+      - name: Create package tgz
+        run: cd packages/api && yarn pack && mv package.tgz actual-api.tgz
+      - name: Upload Build
+        uses: actions/upload-artifact@v4
+        with:
+          name: actual-api
+          path: packages/api/actual-api.tgz
+
+  crdt:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up environment
+        uses: ./.github/actions/setup
+      - name: Build CRDT
+        run: cd packages/crdt && yarn build
+      - name: Create package tgz
+        run: cd packages/crdt && yarn pack && mv package.tgz actual-crdt.tgz
+      - name: Upload Build
+        uses: actions/upload-artifact@v4
+        with:
+          name: actual-crdt
+          path: packages/crdt/actual-crdt.tgz
 
   web:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: Set up environment
         uses: ./.github/actions/setup
       - name: Build Web
         run: ./bin/package-browser
-
-  electron:
-    # As electron builds take longer, we only run them in master.
-    if: github.event_name != 'pull_request'
-    strategy:
-      matrix:
-        os:
-          - ubuntu-latest
-          - windows-latest
-          - macos-latest
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up environment
-        uses: ./.github/actions/setup
-      - name: Build Electron
-        run: ./bin/package
+      - name: Upload Build
+        uses: actions/upload-artifact@v4
+        with:
+          name: actual-web
+          path: packages/desktop-client/build
+      - name: Upload Build Stats
+        uses: actions/upload-artifact@v4
+        with:
+          name: build-stats
+          path: packages/desktop-client/build-stats

.github/workflows/check.yml

@@ -0,0 +1,48 @@
+name: Test
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up environment
+        uses: ./.github/actions/setup
+      - name: Lint
+        run: yarn lint
+  typecheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up environment
+        uses: ./.github/actions/setup
+      - name: Typecheck
+        run: yarn typecheck
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up environment
+        uses: ./.github/actions/setup
+      - name: Test
+        run: yarn test
+
+  migrations:
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '19'
+      - name: Check migrations
+        run: node ./.github/actions/check-migrations.js

.github/workflows/codeql.yml

@@ -0,0 +1,35 @@
+name: CodeQL
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+  schedule:
+    - cron: '23 11 * * 6'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v3
+        with:
+          languages: javascript
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v3
+        with:
+          category: '/language:javascript'

.github/workflows/e2e-test.yml

@@ -0,0 +1,70 @@
+name: E2E Tests
+
+on: [pull_request]
+
+env:
+  GITHUB_PR_NUMBER: ${{github.event.pull_request.number}}
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  netlify:
+    name: Wait for Netlify build to finish
+    runs-on: ubuntu-latest
+    outputs:
+      netlify_url: ${{ steps.netlify.outputs.url }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up environment
+        uses: ./.github/actions/setup
+      - name: Wait for Netlify build to finish
+        id: netlify
+        env:
+          COMMIT_SHA: ${{ github.event.pull_request.head.sha }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: ./.github/actions/netlify-wait-for-build
+
+  functional:
+    name: Functional
+    needs: netlify
+    runs-on: ubuntu-latest
+    container:
+      image: mcr.microsoft.com/playwright:v1.41.1-jammy
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up environment
+        uses: ./.github/actions/setup
+      - name: Run E2E Tests on Netlify URL
+        run: yarn e2e
+        env:
+          E2E_START_URL: ${{ needs.netlify.outputs.netlify_url }}
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: desktop-client-test-results
+          path: packages/desktop-client/test-results/
+          retention-days: 30
+          overwrite: true
+  vrt:
+    name: Visual regression
+    needs: netlify
+    runs-on: ubuntu-latest
+    container:
+      image: mcr.microsoft.com/playwright:v1.41.1-jammy
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up environment
+        uses: ./.github/actions/setup
+      - name: Run VRT Tests on Netlify URL
+        run: yarn vrt
+        env:
+          E2E_START_URL: ${{ needs.netlify.outputs.netlify_url }}
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: desktop-client-test-results
+          path: packages/desktop-client/test-results/
+          retention-days: 30
+          overwrite: true

.github/workflows/electron-master.yml

@@ -0,0 +1,88 @@
+name: Electron Master
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  CI: true
+
+on:
+  push:
+    tags:
+      - v**
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  build:
+    # this is so the assets can be added to the release
+    permissions:
+      contents: write
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+          - windows-latest
+          - macos-latest
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - if: ${{ startsWith(matrix.os, 'windows') }}
+        run: pip.exe install setuptools
+      - if: ${{ ! startsWith(matrix.os, 'windows') }}
+        run: |
+          mkdir .venv
+          python3 -m venv .venv
+          source .venv/bin/activate
+          python3 -m pip install setuptools
+      - if: ${{ startsWith(matrix.os, 'ubuntu') }}
+        run: |
+          sudo apt-get update
+          sudo apt-get install flatpak -y
+          sudo apt-get install flatpak-builder -y
+          sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
+          sudo flatpak install org.freedesktop.Sdk/x86_64/23.08 -y
+          sudo flatpak install org.freedesktop.Platform/x86_64/23.08 -y
+          sudo flatpak install org.electronjs.Electron2.BaseApp/x86_64/23.08 -y
+      - name: Set up environment
+        uses: ./.github/actions/setup
+      - name: Build Electron for Mac
+        if: ${{ startsWith(matrix.os, 'macos') }}
+        run: ./bin/package-electron
+        env:
+          CSC_KEY_PASSWORD: ${{ secrets.CSC_KEY_PASSWORD }}
+          CSC_LINK: ${{ secrets.CSC_LINK }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
+      - name: Build Electron
+        if: ${{ ! startsWith(matrix.os, 'macos') }}
+        run: ./bin/package-electron
+      - name: Upload Build
+        uses: actions/upload-artifact@v4
+        with:
+          name: actual-electron-${{ matrix.os }}
+          path: |
+            packages/desktop-electron/dist/*.dmg
+            packages/desktop-electron/dist/*.exe
+            !packages/desktop-electron/dist/Actual-windows.exe
+            packages/desktop-electron/dist/*.AppImage
+            packages/desktop-electron/dist/*.flatpak
+      - name: Upload Windows Store Build
+        if: ${{ startsWith(matrix.os, 'windows') }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: actual-electron-${{ matrix.os }}-appx
+          path: |
+            packages/desktop-electron/dist/*.appx
+      - name: Add to Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: |
+            packages/desktop-electron/dist/*.dmg
+            packages/desktop-electron/dist/*.exe
+            !packages/desktop-electron/dist/Actual-windows.exe
+            packages/desktop-electron/dist/*.AppImage
+            packages/desktop-electron/dist/*.flatpak

.github/workflows/electron-pr.yml

@@ -0,0 +1,65 @@
+name: Electron
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  CI: true
+
+on:
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+          - windows-latest
+          - macos-latest
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - if: ${{ startsWith(matrix.os, 'windows') }}
+        run: pip.exe install setuptools
+      - if: ${{ ! startsWith(matrix.os, 'windows') }}
+        run: |
+          mkdir .venv
+          python3 -m venv .venv
+          source .venv/bin/activate
+          python3 -m pip install setuptools
+      - if: ${{ startsWith(matrix.os, 'ubuntu') }}
+        run: |
+          sudo apt-get update
+          sudo apt-get install flatpak -y
+          sudo apt-get install flatpak-builder -y
+          sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
+          sudo flatpak install org.freedesktop.Sdk/x86_64/23.08 -y
+          sudo flatpak install org.freedesktop.Platform/x86_64/23.08 -y
+          sudo flatpak install org.electronjs.Electron2.BaseApp/x86_64/23.08 -y
+      - name: Set up environment
+        uses: ./.github/actions/setup
+      - name: Build Electron
+        run: ./bin/package-electron
+      - name: Upload Build
+        uses: actions/upload-artifact@v4
+        with:
+          name: actual-electron-${{ matrix.os }}
+          path: |
+            packages/desktop-electron/dist/*.dmg
+            packages/desktop-electron/dist/*.exe
+            !packages/desktop-electron/dist/Actual-windows.exe
+            packages/desktop-electron/dist/*.AppImage
+            packages/desktop-electron/dist/*.flatpak
+      - name: Upload Windows Store Build
+        if: ${{ startsWith(matrix.os, 'windows') }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: actual-electron-${{ matrix.os }}-appx
+          path: |
+            packages/desktop-electron/dist/*.appx

.github/workflows/issues-close-feature-requests.yml

@@ -0,0 +1,37 @@
+name: Close feature requests with automated message
+
+on:
+  issues:
+    types: [labeled]
+
+jobs:
+  needs-votes:
+    if: ${{ github.event.label.name == 'feature' }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions-ecosystem/action-add-labels@v1
+        with:
+          labels: needs votes
+      - name: Add reactions
+        uses: aidan-mundy/react-to-issue@v1.1.1
+        with:
+          issue-number: ${{ github.event.issue.number }}
+          reactions: '+1'
+      - name: Create comment
+        uses: peter-evans/create-or-update-comment@v3
+        with:
+          issue-number: ${{ github.event.issue.number }}
+          body: |
+            :sparkles: Thanks for sharing your idea! :sparkles:
+
+            This repository uses lodash style issue management for enhancements. That means enhancement issues are automatically closed. This doesn’t mean we don’t accept feature requests, though! We will consider implementing ones that receive many upvotes, and we welcome contributions for any feature requests marked as needing votes (just post a comment first so we can help you make a successful contribution).
+
+            The enhancement backlog can be found here: https://github.com/actualbudget/actual/issues?q=label%3A%22needs+votes%22+sort%3Areactions-%2B1-desc+
+
+            Don’t forget to upvote the top comment with 👍!
+
+            <!-- feature-auto-close-comment -->
+      - name: Close Issue
+        run: gh issue close "https://github.com/actualbudget/actual/issues/${{ github.event.issue.number }}"
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/issues-feature-implemented.yml

@@ -0,0 +1,35 @@
+name: Handle completed feature requests
+
+##########################################################################################
+# WARNING! This workflow uses the 'pull_request_target' event. That mans that it will    #
+# always run in the context of the main actualbudget/actual repo, even if the PR is from #
+# a fork. This is necessary to get access to a GitHub token that can post a comment on   #
+# the PR. Be VERY CAREFUL about adding things to this workflow, since forks can inject   #
+# arbitrary code into their branch, and can pollute the artifacts we download. Arbitrary #
+# code execution in this workflow could lead to a compromise of the main repo.           #
+##########################################################################################
+# See: https://securitylab.github.com/research/github-actions-preventing-pwn-requests    #
+##########################################################################################
+
+on:
+  pull_request_target:
+    types: [closed]
+
+permissions:
+  issues: write
+
+jobs:
+  handle-feature-requests:
+    if: github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+    steps:
+      # This is not a security concern because we have approved & merged the PR
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '19'
+      - name: Handle feature requests
+        run: node .github/actions/handle-feature-requests.js
+        env:
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/issues-remove-help-wanted.yml

@@ -0,0 +1,14 @@
+name: Remove 'help wanted' label from closed issues
+
+on:
+  issues:
+    types: [closed]
+
+jobs:
+  remove-help-wanted:
+    if: ${{ !contains(github.event.issue.labels.*.name, 'feature') && contains(github.event.issue.labels.*.name, 'help wanted') }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions-ecosystem/action-remove-labels@v1
+        with:
+          labels: help wanted

.github/workflows/lint.yml

@@ -1,18 +0,0 @@
-name: Linter
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches: '*'
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up environment
-        uses: ./.github/actions/setup
-      - name: Lint
-        run: yarn lint

.github/workflows/netlify-release.yml

@@ -0,0 +1,43 @@
+name: Deploy Netlify Release
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  CI: true
+
+on:
+  push:
+    tags:
+      - v**
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Repository Checkout
+        uses: actions/checkout@v4
+    
+      - name: Set up environment
+        uses: ./.github/actions/setup
+    
+      - name: Install Netlify
+        run: npm install netlify-cli@17.10.1 -g
+    
+      - name: Build Actual
+        run: ./bin/package-browser
+
+      - name: Deploy to Netlify
+        id: netlify_deploy
+        run: |
+          netlify deploy \
+            --dir packages/desktop-client/build \
+            --site ${{ secrets.NETLIFY_SITE_ID }} \
+            --auth ${{ secrets.NETLIFY_API_TOKEN }} \
+            --filter @actual-app/web \
+            --prod

.github/workflows/opened-issues-triage.yml

@@ -1,14 +0,0 @@
-name: Mark new issue for triage
-
-on:
-  issues:
-    types: [opened]
-
-jobs:
-  needs-triage:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-ecosystem/action-add-labels@v1
-        with:
-          labels: needs triage

.github/workflows/release-notes.yml

@@ -0,0 +1,21 @@
+name: Release notes
+
+on:
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  release-notes:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Check release notes
+        if: startsWith(github.head_ref, 'release/') == false
+        uses: actualbudget/actions/release-notes/check@main
+      - name: Generate release notes
+        if: startsWith(github.head_ref, 'release/') == true
+        uses: actualbudget/actions/release-notes/generate@main

.github/workflows/size-compare.yml

@@ -0,0 +1,86 @@
+name: Compare Sizes
+
+##########################################################################################
+# WARNING! This workflow uses the 'pull_request_target' event. That mans that it will    #
+# always run in the context of the main actualbudget/actual repo, even if the PR is from #
+# a fork. This is necessary to get access to a GitHub token that can post a comment on   #
+# the PR. Be VERY CAREFUL about adding things to this workflow, since forks can inject   #
+# arbitrary code into their branch, and can pollute the artifacts we download. Arbitrary #
+# code execution in this workflow could lead to a compromise of the main repo.           #
+##########################################################################################
+# See: https://securitylab.github.com/research/github-actions-preventing-pwn-requests    #
+##########################################################################################
+
+on:
+  pull_request_target:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  compare:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - name: Wait for ${{github.base_ref}} build to succeed
+        uses: fountainhead/action-wait-for-check@v1.2.0
+        id: master-build
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          checkName: web
+          ref: ${{github.base_ref}}
+
+      - name: Wait for PR build to succeed
+        uses: fountainhead/action-wait-for-check@v1.2.0
+        id: wait-for-build
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          checkName: web
+          ref: ${{github.event.pull_request.head.sha}}
+
+      - name: Report build failure
+        if: steps.wait-for-build.outputs.conclusion == 'failure'
+        run: |
+          echo "Build failed on PR branch or ${{github.base_ref}}"
+          exit 1
+      - name: Download build artifact from ${{github.base_ref}}
+        uses: dawidd6/action-download-artifact@v6
+        id: pr-build
+        with:
+          branch: ${{github.base_ref}}
+          workflow: build.yml
+          name: build-stats
+          path: base
+
+      - name: Download build artifact from PR
+        uses: dawidd6/action-download-artifact@v6
+        with:
+          pr: ${{github.event.pull_request.number}}
+          workflow: build.yml
+          name: build-stats
+          path: head
+          allow_forks: true
+
+      - name: Strip content hashes from stats files
+        run: |
+          sed -i -E 's/index\.[0-9a-zA-Z_-]{8,}\./index./g' ./head/web-stats.json
+          sed -i -E 's/\.[0-9a-zA-Z_-]{8,}\.chunk\././g' ./head/web-stats.json
+          sed -i -E 's/\.[0-9a-f]{8,}\././g' ./head/*.json
+          sed -i -E 's/index\.[0-9a-zA-Z_-]{8,}\./index./g' ./base/web-stats.json
+          sed -i -E 's/\.[0-9a-zA-Z_-]{8,}\.chunk\././g' ./base/web-stats.json
+          sed -i -E 's/\.[0-9a-f]{8,}\././g' ./base/*.json
+      - uses: twk3/rollup-size-compare-action@v1.1.1
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          current-stats-json-path: ./head/web-stats.json
+          base-stats-json-path: ./base/web-stats.json
+          title: desktop-client
+
+      - uses: github/webpack-bundlesize-compare-action@v2.1.0
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          current-stats-json-path: ./head/loot-core-stats.json
+          base-stats-json-path: ./base/loot-core-stats.json
+          title: loot-core

.github/workflows/stale.yml

@@ -1,22 +1,26 @@
-name: Close inactive issues
+name: 'Close stale PRs'
 on:
   schedule:
-    - cron: "30 1 * * *"
+    - cron: '30 1 * * *'
 
 jobs:
-  close-issues:
+  stale:
     runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
     steps:
-      - uses: actions/stale@v5
+      - uses: actions/stale@v9
         with:
-          days-before-issue-stale: 90
-          days-before-issue-close: -1
-          stale-issue-label: "stale"
-          stale-issue-message: "🚧🚨 This issue is being marked as stale due to 90 days of inactivity. 🚧🚨"
-          days-before-pr-stale: -1
-          days-before-pr-close: -1
-          only-labels: 'needs triage'
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          stale-pr-message: 'This PR is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 5 days.'
+          close-pr-message: 'This PR was closed because it has been stalled for 5 days with no activity.'
+          days-before-stale: 30
+          days-before-close: 5
+          days-before-issue-stale: -1
+  stale-wip:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v9
+        with:
+          stale-pr-message: ':wave: Hi! It looks like this PR has not had any changes for a week now. Would you like someone to review this PR? If so - please remove the "[WIP]" prefix from the PR title. That will let the community know that this PR is open for a review.'
+          days-before-stale: 7
+          any-of-labels: ':construction: WIP'
+          days-before-close: -1
+          days-before-issue-stale: -1

.github/workflows/test.yml

@@ -1,18 +0,0 @@
-name: Test
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches: '*'
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up environment
-        uses: ./.github/actions/setup
-      - name: Test
-        run: yarn test

.gitignore

@@ -1,25 +1,34 @@
+# Sample Data
 /data/*
 !data/.gitkeep
 /data2
+Actual-*
+**/xcuserdata/*
+export-2020-01-10.csv
+
+# Secrets
+.secret-tokens
+
+# MacOS
+.DS_Store
+
+# Logs
+**/*.log
+
+# JavaScript
+node_modules
+packages/api/dist
+packages/api/@types
+packages/crdt/dist
 packages/desktop-electron/client-build
+packages/desktop-electron/build
 packages/desktop-electron/.electron-symbols
 packages/desktop-electron/dist
 packages/desktop-electron/loot-core
-node_modules
-.DS_Store
-lerna-debug.log
-Actual-*
-.#*
-**/xcuserdata/*
-.secret-tokens
 bundle.desktop.js
 bundle.desktop.js.map
 bundle.mobile.js
 bundle.mobile.js.map
-.sentryclirc
-export-2020-01-10.csv
-
-**/*.log
 
 # Yarn
 .pnp.*
@@ -29,3 +38,18 @@ export-2020-01-10.csv
 !.yarn/releases
 !.yarn/sdks
 !.yarn/versions
+
+# VSCode
+.vscode
+
+# IntelliJ IDEA
+.idea
+
+# Misc
+.#*
+
+# Local Netlify folder
+.netlify
+
+# build output
+package.tgz

.husky/pre-commit

@@ -0,0 +1 @@
+yarn lint-staged

.nvmrc

@@ -1 +1 @@
-v16.15.0
+v18.16.0

.prettierignore

@@ -0,0 +1 @@
+sync_pb.*

.prettierrc.json

@@ -1,4 +1,5 @@
 {
-    "singleQuote": true,
-    "trailingComma": "none"
+  "singleQuote": true,
+  "trailingComma": "all",
+  "arrowParens": "avoid"
 }

.secret-tokens.example

@@ -0,0 +1,2 @@
+export APPLE_ID=example@email.com
+export APPLE_APP_SPECIFIC_PASSWORD=password

.yarnrc.yml

@@ -1,7 +1,7 @@
+compressionLevel: mixed
+
+enableGlobalCache: false
+
 nodeLinker: node-modules
 
-plugins:
-  - path: .yarn/plugins/@yarnpkg/plugin-workspace-tools.cjs
-    spec: "@yarnpkg/plugin-workspace-tools"
-
-yarnPath: .yarn/releases/yarn-3.2.0.cjs
+yarnPath: .yarn/releases/yarn-4.3.1.cjs

CONTRIBUTING.md

@@ -1,78 +1 @@
-Actual was _just_ open-sourced so the contributing model isn't fully fleshed out yet.
-
-## Expectations
-
-Personally, I would like to see an ecosystem of minor forks that make small changes to Actual and continually rebase on the latest version. Unlike what some people think, forks are a healthy sign of a community in my opinion.
-
-We aren't going to take every single little change. Don't be offended if we close your PR. In order for the project to stay healthy, we need to guard our bandwidth and also only take changes that align with Actual.
-
-Please ask first before making a large change; you might waste a lot of work if it doesn't align with how Actual should work.
-
-Here are some initial guidelines for how contributions will be treated:
-
-* The mental health of the maintainers will be prioritized above all else. If this means some things get lost and PRs are unreviewed because maintainers are spending time with family or on themselves, we celebrate that.
-
-* Multiple maintainers are key to this being a healthy project. Currently, only I (@jlongster) have maintainer rights. I am actively looking for more people to come on as maintainers. If nobody steps up, expect less activity on this project.
-
-* An open PR does not automatically deserve time for a full review and acceptance. It's up to the PR author to convince the maintainers that the change is good and worth reviewing. This involves a clear description for why the the change is being made, detailing the tradeoffs, and ideally a link to a live demo where Actual is running with the changes. (Ideally, we would automatically generate a live demo)
-
-* We especially welcome improvements in automation: creating github actions to automatically generate builds, making the release process easier, etc.
-
-
-## Main contributors
-
-* @jlongster
-
-## Project ideas
-
-The code needs a lot of improvements. When it was just me (@jlongster) I would often find myself halfway through an improvement overall, but always had to put it aside to work on something else. This shows in the code; there's a lot of things that I wanted to improve but was never able to complete. These are list of projects on the top of my mind that I would love to see progress on.
-
-### A mobile web app
-
-One of the most pressing needs is a mobile app based on the web app. This could mean making the web app responsive, or a separate app that does a few basic things.
-
-We are deprecating the native iOS/Android apps because we don't have bandwidth to support development and distribution of them (it's complicating submitting them to the app stores, etc).
-
-Ideally you'd be able to enter transactions on mobile.
-
-### Transitioning to TypeScript
-
-This is something I should have done a long time ago. I'd love any help setting up infrastructure for TypeScript and starting to transitioning code to it, particularly the backend.
-
-### Rewriting the transaction table
-
-The transaction table is a very complex component because of all the interactions. The original goal was to embrace inline editing fully and never pull the user out into something like a modal or a drawer. I like how this worked out for some workflows, but it made other workflows plain awkward.
-
-For example, splitting a transaction. Currently, it all happens inline which means the user could be in the middle of splitting a transaction and navigate somewhere else. The transaction needs to support that middle state where the subtractions don't equal the parent transaction amount. Currently, we show a little "error" popup near the transacton when it's in this state.
-
-This is a very awkward flow, and it would actually be better to pop the user into a modal state to split a transaction. I would still want to _display_ the split transaction inline, and even edit the categories of them, but for editing the amount the user should work on them in a modal/drawer/etc.
-
-The code for the transaction table originates from a time when React hooks were very new. If I had to do it all over, I'd avoid hooks entirely and look into better ways to manage state. **The performance of the table is crucial** and React hooks with complicated interaction actively make it difficult for this to work. The code is convoluted for a single purpose: only a single row should ever render when something changes.
-
-I'm proud of the fact that you can scroll down the transactions list incredibly fast. You can even hold down "enter" to move the editing cell downward and it'll scroll down the list to keep the edited cell in view. But this came at a cost: the code needs to be more maintainble.
-
-I'm not sure what the solution is yet. Maybe it's using a 3rd party library like [react-table](https://react-table.tanstack.com). To be honest, I'm quite skeptical of 3rd party library performance-wise, but it's worth looking into. That would also make it easy to support hiding/showing columns and other advanced features.
-
-### Ditching babel
-
-A huge pain point in development is using babel. The way it interacts with other tooling and requires a billion dependencies make it fucking annoying to work with (sorry, I'm drinking bourbon at this point). Updating Jest requires fiddling with versions of babel in the `yarn.lock` file until it works. I'm freaking over it.
-
-We should switch to [swc](https://swc.rs). That would also have another benefit: it's **blazingly** fast. Like 100x faster. So it's also make development way way faster.
-
-### Adopt an existing component library
-
-One of my mistakes with Actual was rebuilding everything from scratch, even the design system. While I was able to make it look good for the current version of Actual, it makes it a lot of work to build new designs. We should choose a 3rd party library and start using it in Actual. It would make it way faster to build new designs.
-
-There aren't many good 3rd party library unfortunately. API, accessibility, and general thoughtful-ness are important. The two that come to my mind are [Radix](https://www.radix-ui.com) and [react-aria](https://react-spectrum.adobe.com/react-aria/). I'm leaning towards react-aria.
-
-I'm open to other things, but we really need something to take the weight off of building UI.
-
-### Enriching the budget page
-
-This is more of a feature, but if someone (preferrably with design experience) wants to dig into the budget page and figure out how to make it more extensible, that'd be great. I always wanted to show more data on that page but never had time to design something good. The multi-month view makes it hard, but maybe if there's only a single month showing we could show additional data beside it.
-
-This also might require the ability to "select" a category so we can show data specific to that category.
-
-### Custom reports
-
-This is a big one. I'm very sad I never had time to see this through. I would love to see experiments to how better reports should work, particularly custom reports. Actually letting the user write some SQL or AQL code and visualizing it somehow. This is something I'll probably still play with.
+Please review the contributing documentation on our website: https://actualbudget.org/docs/contributing/

Dockerfile

@@ -0,0 +1,11 @@
+###################################################
+# This Dockerfile is used by the docker-compose.yml
+# file to build the development container.
+# Do not make any changes here unless you know what
+# you are doing.
+###################################################
+
+FROM node:18-bullseye as dev
+RUN apt-get update -y && apt-get upgrade -y && apt-get install -y openssl
+WORKDIR /app
+CMD ["sh", "./bin/docker-start"]

LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright 2022 James Long
+Copyright James Long
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

README.md

@@ -1,39 +1,79 @@
+<p align="center">
+  <img src="/demo.png" alt="Actualbudget" />
+</p>
+
 ## Getting Started
 
 Actual is a local-first personal finance tool. It is 100% free and open-source, written in NodeJS, it has a synchronization element so that all your changes can move between devices without any heavy lifting.
 
-If you are interested in contributing, or want to know how development works, see [CONTRIBUTING.md](https://github.com/actualbudget/actual/blob/master/CONTRIBUTING.md) we would love to have you.
+If you are interested in contributing, or want to know how development works, see our [contributing](https://actualbudget.org/docs/contributing/) document we would love to have you.
 
 Want to say thanks? Click the ⭐ at the top of the page.
 
 ## Key Links
 
-* Actual [discord](https://discord.gg/pRYNYr4W5A) community.
-* Actual [Community Documentation](https://actualbudget.github.io/docs)
+- Actual [discord](https://discord.gg/pRYNYr4W5A) community.
+- Actual [Community Documentation](https://actualbudget.org/docs)
+- [Frequently asked questions](https://actualbudget.org/docs/faq)
 
 ## Installation
 
-If you are only interested in running the latest version and not contributing to the source code, you don't need to clone this repo. You can get the latest version through npm.
+There are four ways to deploy Actual:
 
-**Please Note:** While the Actual repository holds source code for the mobile applications that were supported when Actual was closed source, these are no longer supported on the Open Source version of Actual.
+1. One-click deployment [via PikaPods](https://www.pikapods.com/pods?run=actual) (~1.40 $/month) - recommended for non-technical users
+1. Managed hosting [via Fly.io](https://actualbudget.org/docs/install/fly) (~1.50 $/month)
+1. Self-hosted by using [a Docker image](https://actualbudget.org/docs/install/docker)
+1. Local-only apps - [downloadable Windows, Mac and Linux apps](https://actualbudget.org/download/) you can run on your device
 
-### The easy way: using a server (recommended)
+Learn more in the [installation instructions docs](https://actualbudget.org/docs/install/).
 
-The easiest way to get Actual running is to use the [actual-server](https://github.com/actualbudget/actual-server) project. That is the server for syncing changes across devices, and it comes with the latest version of Actual. The server will provide both the web project and a server for syncing.
+## Ready to Start Budgeting?
 
-You can get up and running quickly and easily by following our [Running Actual Locally Guide](https://actualbudget.github.io/docs/Installing/Local/your-own-machine)
+Read about [Envelope budgeting](https://actualbudget.org/docs/getting-started/envelope-budgeting) to know more about the idea behind Actual Budget.
+
+### Are you new to budgeting or want to start fresh?
+
+Check out the community's [Starting Fresh](https://actualbudget.org/docs/getting-started/starting-fresh) guide so you can quickly get up and running!
+
+### Are you migrating from other budgeting apps?
+
+Check out the community's [Migration](https://actualbudget.org/docs/migration/) guide to start jumping on the Actual Budget train!
 
 ## Documentation
 
-We have a wide range of documentation on how to use Actual, this is all available in our [Community Documentation](https://actualbudget.github.io/docs), this includes topics on Budgeting, Account Management, Tips & Tricks and some documentation for developers.
+We have a wide range of documentation on how to use Actual, this is all available in our [Community Documentation](https://actualbudget.org/docs), this includes topics on Budgeting, Account Management, Tips & Tricks and some documentation for developers.
 
-## Code structure
+## Contributing
+
+Actual is a community driven product. Learn more about [contributing to Actual](https://actualbudget.org/docs/contributing/).
+
+### Code structure
 
 The Actual app is split up into a few packages:
 
-* loot-core - The core application that runs on any platform
-* loot-design - The generic design components that make up the UI
-* desktop-client - The desktop UI
-* desktop-electron - The desktop app
+- loot-core - The core application that runs on any platform
+- desktop-client - The desktop UI
+- desktop-electron - The desktop app
 
-More information on the project structure is available in our [community documentation](https://actualbudget.github.io/docs/Developers/project-layout).
+More information on the project structure is available in our [community documentation](https://actualbudget.org/docs/contributing/project-details).
+
+### Feature Requests
+
+Current feature requests can be seen [here](https://github.com/actualbudget/actual/issues?q=is%3Aissue+label%3A%22needs+votes%22+sort%3Areactions-%2B1-desc).
+Vote for your favorite requests by reacting :+1: to the top comment of the request.
+
+To add new feature requests, open a new Issue of the "Feature Request" type.
+
+### Translation
+
+Make Actual Budget accessible to more people by helping with the [Internationalization](https://actualbudget.org/docs/contributing/i18n/) of Actual. We are using a crowd sourcing tool to manage the translations, see our [Weblate Project](https://hosted.weblate.org/projects/actualbudget/). Weblate proudly supports open-source software projects through their [Libre plan](https://weblate.org/en/hosting/#libre). 
+
+## Repo Activity
+
+![Alt](https://repobeats.axiom.co/api/embed/e20537dd8b74956f86736726ccfbc6f0565bec22.svg 'Repobeats analytics image')
+
+## Sponsors
+
+Thanks to our wonderful sponsors who make Actual Budget possible!
+
+<a href="https://www.netlify.com"> <img src="https://www.netlify.com/v3/img/components/netlify-color-accent.svg" alt="Deploys by Netlify" /> </a>

bin/docker-start

@@ -0,0 +1,13 @@
+#!/bin/sh
+
+#####################################################
+# This startup script is used by the docker container
+# to check if the node_modules folder is empty and
+# if so, run yarn to install the dependencies.
+#####################################################
+
+if [ ! -d "node_modules" ] || [ "$(ls -A node_modules)" = "" ]; then
+    yarn
+fi
+
+BROWSER=0 yarn start:browser

bin/format-staged

@@ -1,11 +0,0 @@
-#!/bin/sh
-FILES=$(git diff --cached --name-only --diff-filter=ACMR "*.js" "*.jsx" | sed 's| |\\ |g')
-[ -z "$FILES" ] && exit 0
-
-# Prettify all selected files
-echo "$FILES" | xargs ./node_modules/.bin/prettier --write
-
-# Add back the modified/prettified files to staging
-echo "$FILES" | xargs git add
-
-exit 0

bin/import-open-source-package

@@ -1,27 +0,0 @@
-#!/bin/sh -e
-
-ROOT=$(cd "`dirname $0`"; pwd)
-NPM_NAME="$1"
-NAME="$2"
-PACKAGE_DIR="`dirname "$ROOT"`/packages/$NAME"
-
-if [ -z "$NAME" ] || [ -z "$NPM_NAME" ]; then
-    echo "Usage: `basename $0` <npm-name> <local-name>"
-    exit 1
-fi
-
-if [ -d "$PACKAGE_DIR" ]; then
-    read -p "Package exists, remove $PACKAGE_DIR? [y/N] " -r
-    if [ -z "$REPLY" ] || [ "$REPLY" != "y" ]; then
-        exit 2
-    fi
-fi
-
-rm -rf "$PACKAGE_DIR"
-URL="`npm view "$NPM_NAME" dist.tarball`"
-TMPDIR="`mktemp -d`"
-
-cd "$TMPDIR"
-wget -O tar.tgz "$URL"
-tar xvzf tar.tgz
-mv package "$PACKAGE_DIR"

bin/make-release

@@ -1,50 +0,0 @@
-#!/bin/bash -e
-
-VERSION=""
-
-POSITIONAL=()
-while [[ $# -gt 0 ]]; do
-  key="$1"
-
-  case $key in
-      --version)
-      VERSION="$2"
-      shift
-      shift
-      ;;
-      *)
-      POSITIONAL+=("$1")
-      shift
-      ;;
-  esac
-done
-set -- "${POSITIONAL[@]}"
-
-NOTES="$@"
-
-if [ -z "$VERSION" ]; then
-    echo "--version is required";
-    exit 1
-fi
-
-echo "Version: $VERSION"
-echo "Notes: $NOTES"
-read -p "Make release? [y/N] " -r
-if [ -z "$REPLY" ] || [ "$REPLY" != "y" ]; then
-    exit 2
-fi
-
-source ./.secret-tokens
-
-# Tag and push to make windows and linux versions
-git push origin master
-git tag -a "$VERSION" -m "$NOTES"
-git push origin "$VERSION"
-
-# Make a macOS version
-./bin/package --release --version "$VERSION"
-
-# TODO: browser version
-
-# Finally, update github issues
-curl -X POST -H "x-release-token: $RELEASE_TOKEN"  https://actual-automoto.fly.dev/release/"$VERSION"

bin/package

@@ -1,163 +0,0 @@
-#!/bin/bash -e
-
-
-ROOT=`dirname $0`
-VERSION=""
-BETA=""
-RELEASE=""
-RELEASE_NOTES=""
-CI=${CI:-false}
-
-cd "$ROOT/.."
-
-POSITIONAL=()
-while [[ $# -gt 0 ]]; do
-  key="$1"
-
-  case $key in
-      --version)
-      VERSION="$2"
-      shift
-      shift
-      ;;
-      --beta)
-      RELEASE="beta"
-      shift
-      ;;
-      --release)
-      RELEASE="production"
-      shift
-      ;;
-      *)
-      POSITIONAL+=("$1")
-      shift
-      ;;
-  esac
-done
-set -- "${POSITIONAL[@]}"
-
-if [ -z "$VERSION" ] && [ -n "$RELEASE" ]; then
-    echo "Version is required if making a release"
-    exit 1
-fi
-
-if [ -n "$RELEASE" ]; then
-    if [ -z "$CIRCLE_TAG" ]; then
-        read -p "Make release: $RELEASE v$VERSION? [y/N] " -r
-        if [ -z "$REPLY" ] || [ "$REPLY" != "y" ]; then
-            exit 2
-        fi
-    fi
-
-    if [ "$RELEASE" == "production" ]; then
-        if [ -z "$CIRCLE_TAG" ]; then
-            RELEASE_NOTES=`git tag -l --format="%(contents:subject)" "$VERSION"`
-        else
-            RELEASE_NOTES=`git tag -l --format="%(contents:subject)" "$CIRCLE_TAG"`
-        fi
-    fi
-
-    PACKAGE_VERSION=`node -p -e "require('./packages/desktop-electron/package.json').version"`
-    if [ "$VERSION" != "$PACKAGE_VERSION" ]; then
-        echo "Version in desktop-electron/package.json does not match given version! ($PACKAGE_VERSION)"
-        exit 4
-    fi
-fi
-
-if [ "$OSTYPE" == "msys" ]; then
-    if [ $CI != true ]; then
-        read -s -p "Windows certificate password: " -r CSC_KEY_PASSWORD
-        export CSC_KEY_PASSWORD
-    elif [ -n "$CIRCLE_TAG" ]; then
-        # We only want to run this on CircleCI as Github doesn't have the CSC_KEY_PASSWORD secret set.
-        certutil -f -p ${CSC_KEY_PASSWORD} -importPfx ~/windows-shift-reset-llc.p12
-    fi
-fi
-
-# We only need to run linting once (and this doesn't seem to work on
-# Windows for some reason)
-if [[ $CI != true && "$OSTYPE" == "darwin"* ]]; then
-    yarn lint
-fi
-
-yarn patch-package
-
-yarn workspace mobile patch-package
-
-yarn workspace loot-core build:node
-
-yarn workspace @actual-app/web build
-
-
-rm -fr packages/desktop-electron/client-build
-cp -r packages/desktop-client/build packages/desktop-electron/client-build
-# Remove the embedded backend for the browser version. Will improve
-# this process
-rm -fr packages/desktop-electron/client-build/data
-rm -fr packages/desktop-electron/client-build/*kcab.*
-rm -fr packages/desktop-electron/client-build/*.wasm
-rm -fr packages/desktop-electron/client-build/*.map
-
-
-if [ -n "$RELEASE" ]; then
-  SENTRY_CLI="./packages/desktop-electron/node_modules/.bin/sentry-cli"
-  "$SENTRY_CLI" releases -o shift-reset-llc -p actual set-commits "$VERSION" --auto
-
-  echo "Uploading frontend sourcemaps to sentry for version $VERSION..."
-  "$SENTRY_CLI" releases -o shift-reset-llc -p actual files "$VERSION" \
-      upload-sourcemaps --url-prefix app://actual/static/js/ --rewrite ./packages/desktop-client/build/static/js
-
-  echo "Uploading backend sourcemaps to sentry for version $VERSION..."
-  "$SENTRY_CLI" releases -o shift-reset-llc -p actual files "$VERSION" \
-      delete app:///node_modules/loot-core/lib-dist/bundle.desktop.js
-
-  "$SENTRY_CLI" releases -o shift-reset-llc -p actual files "$VERSION" \
-      delete app:///node_modules/loot-core/lib-dist/bundle.desktop.js.map
-
-  "$SENTRY_CLI" releases -o shift-reset-llc -p actual files "$VERSION" \
-      upload-sourcemaps --url-prefix 'app:///node_modules/loot-core/lib-dist/' ./packages/loot-core/lib-dist/bundle.desktop*
-fi
-
-(
-    cd packages/desktop-electron;
-    yarn clean;
-
-    export npm_config_better_sqlite3_binary_host="https://static.actualbudget.com/prebuild/better-sqlite3"
-
-    if [ "$RELEASE" == "production" ]; then
-        if [ -f ../../.secret-tokens ]; then
-            source ../../.secret-tokens
-        fi
-        yarn build --publish always -c.releaseInfo.releaseNotes="$RELEASE_NOTES" --arm64 --x64
-
-        echo "\nCreated release $VERSION with release notes \"$RELEASE_NOTES\""
-    elif [ "$RELEASE" == "beta" ]; then
-        yarn build --publish never --arm64 --x64
-
-        WINDOWS_FILE="./dist/Actual Setup $VERSION.exe"
-        if [ -f "$WINDOWS_FILE" ]; then
-            scp "$WINDOWS_FILE" "jlongster.com:/sites/static.actualbudget/Actual-Setup-$VERSION.exe"
-            echo "Windows: https://static.actualbudget.com/Actual-Setup-$VERSION.exe"
-        else
-            echo "No Windows file found"
-        fi
-
-        MAC_FILE="./dist/Actual-$VERSION.dmg"
-        if [ -f "$MAC_FILE" ]; then
-            scp "$MAC_FILE" "jlongster.com:/sites/static.actualbudget.com/Actual-$VERSION.dmg"
-            echo "macOS: https://static.actualbudget.com/Actual-$VERSION.dmg"
-        else
-            echo "No macOS file found"
-        fi
-
-        LINUX_FILE="./dist/Actual-$VERSION-x86_64.AppImage"
-        if [ -f "$LINUX_FILE" ]; then
-            scp "$LINUX_FILE" "jlongster.com:/sites/static.actualbudget/Actual-$VERSION-x86_64.AppImage"
-            echo "Linux: https://static.actualbudget.com/Actual-$VERSION-x86_64.AppImage"
-        else
-            echo "No linux file found"
-        fi
-    else
-        SKIP_NOTARIZATION=true yarn build --publish never --x64
-    fi
-)

bin/package-browser

@@ -1,63 +1,10 @@
 #!/bin/bash -e
 
 ROOT=`dirname $0`
-VERSION=""
-RELEASE=""
-CI=${CI:-false}
 
 cd "$ROOT/.."
 
-POSITIONAL=()
-while [[ $# -gt 0 ]]; do
-  key="$1"
-
-  case $key in
-      --version)
-      VERSION="$2"
-      shift
-      shift
-      ;;
-      --beta)
-      RELEASE="beta"
-      shift
-      ;;
-      --release)
-      RELEASE="production"
-      shift
-      ;;
-      *)
-      POSITIONAL+=("$1")
-      shift
-      ;;
-  esac
-done
-set -- "${POSITIONAL[@]}"
-
-if [ -z "$VERSION" ] && [ -n "$RELEASE" ]; then
-    echo "Version is required if making a release"
-    exit 1
-fi
-
-if [ -n "$RELEASE" ]; then
-    read -p "Deploy release for browser: $RELEASE v$VERSION? [y/N] " -r
-    if [ -z "$REPLY" ] || [ "$REPLY" != "y" ]; then
-        exit 2
-    fi
-
-    PACKAGE_VERSION=`node -p -e "require('./packages/desktop-electron/package.json').version"`
-    if [ "$VERSION" != "$PACKAGE_VERSION" ] && [ "$VERSION-next" != "$PACKAGE_VERSION" ]; then
-        echo "Version in desktop-electron/package.json does not match given version! ($PACKAGE_VERSION)"
-        exit 4
-    fi
-fi
-
-# There's no need to check linting in CI as it'll be done in a different step.
-if [ $CI != true ]; then
-    yarn lint
-fi
-
-ACTUAL_RELEASE_TYPE=$RELEASE yarn workspace loot-core build:browser
-
-REACT_APP_RELEASE_TYPE=$RELEASE yarn workspace @actual-app/web build:browser
+yarn workspace loot-core build:browser
+yarn workspace @actual-app/web build:browser
 
 echo "packages/desktop-client/build"

bin/package-electron

@@ -0,0 +1,57 @@
+#!/bin/bash -e
+
+
+ROOT=`dirname $0`
+RELEASE=""
+CI=${CI:-false}
+
+cd "$ROOT/.."
+
+POSITIONAL=()
+while [[ $# -gt 0 ]]; do
+  key="$1"
+
+  case $key in
+      --release)
+      RELEASE="production"
+      shift
+      ;;
+      *)
+      POSITIONAL+=("$1")
+      shift
+      ;;
+  esac
+done
+set -- "${POSITIONAL[@]}"
+
+if [ "$OSTYPE" == "msys" ]; then
+    if [ $CI != true ]; then
+        read -s -p "Windows certificate password: " -r CSC_KEY_PASSWORD
+        export CSC_KEY_PASSWORD
+    elif [ -n "$CIRCLE_TAG" ]; then
+        # We only want to run this on CircleCI as Github doesn't have the CSC_KEY_PASSWORD secret set.
+        certutil -f -p ${CSC_KEY_PASSWORD} -importPfx ~/windows-shift-reset-llc.p12
+    fi
+fi
+
+yarn workspace loot-core build:node
+
+yarn workspace @actual-app/web build --mode=desktop
+
+yarn workspace desktop-electron update-client
+
+(
+    cd packages/desktop-electron;
+    yarn clean;
+
+    if [ "$RELEASE" == "production" ]; then
+        if [ -f ../../.secret-tokens ]; then
+            source ../../.secret-tokens
+        fi
+        yarn build
+
+        echo "\nCreated release"
+    else
+        SKIP_NOTARIZATION=true yarn build
+    fi
+)

bin/run-vrt

@@ -0,0 +1,32 @@
+#!/bin/sh
+
+# See here for more information: https://github.com/actualbudget/actual/tree/master/packages/desktop-client#visual-regression
+
+if [ ! -d "node_modules" ] || [ "$(ls -A node_modules)" = "" ]; then
+    yarn
+fi
+
+E2E_START_URL="${E2E_START_URL:-https://localhost:3001}"
+VRT_ARGS=""
+
+# Loop through all arguments
+while [ $# -gt 0 ]; do
+    key="$1"
+    case $key in
+        --e2e-start-url)
+            E2E_START_URL="$2"
+            shift
+            ;;
+        *)
+            VRT_ARGS="$VRT_ARGS $1"
+            ;;
+    esac
+    shift
+done
+
+echo "Running VRT tests with the following parameters:"
+echo "E2E_START_URL: $E2E_START_URL"
+echo "VRT_ARGS: $VRT_ARGS"
+
+MSYS_NO_PATHCONV=1 docker run --rm --network host -v "$(pwd)":/work/ -w /work/ -it mcr.microsoft.com/playwright:v1.41.1-jammy /bin/bash \
+  -c "E2E_START_URL=$E2E_START_URL yarn vrt $VRT_ARGS"

docker-compose.yml

@@ -0,0 +1,18 @@
+###################################################
+# This creates and stands up the development
+# docker container. Depends on the Dockerfile and
+# docker-start.sh files.
+###################################################
+
+services:
+  actual-development:
+    build: .
+    image: actual-development
+    environment:
+      - HTTPS
+    ports:
+      - '3001:3001'
+    volumes:
+      - '.:/app'
+    restart: 'no'
+

package.json

@@ -18,36 +18,67 @@
     ]
   },
   "scripts": {
-    "start": "npm-run-all --parallel 'start:desktop-*'",
+    "start": "yarn start:browser",
+    "start:desktop": "yarn rebuild-electron && npm-run-all --parallel 'start:desktop-*'",
     "start:desktop-node": "yarn workspace loot-core watch:node",
     "start:desktop-client": "yarn workspace @actual-app/web watch",
-    "start:desktop-electron": "yarn workspace Actual watch",
+    "start:desktop-electron": "yarn workspace desktop-electron watch",
+    "start:electron": "yarn start:desktop",
     "start:browser": "npm-run-all --parallel 'start:browser-*'",
     "start:browser-backend": "yarn workspace loot-core watch:browser",
     "start:browser-frontend": "yarn workspace @actual-app/web start:browser",
-    "test": "yarn workspaces foreach --parallel --verbose run test",
-    "test:debug": "yarn workspaces foreach --verbose run test",
+    "build:browser": "./bin/package-browser",
+    "build:desktop": "./bin/package-electron",
+    "build:api": "yarn workspace @actual-app/api build",
+    "generate:i18n": "yarn workspace @actual-app/web generate:i18n",
+    "test": "yarn workspaces foreach --all --parallel --verbose run test",
+    "test:debug": "yarn workspaces foreach --all --verbose run test",
+    "e2e": "yarn workspaces foreach --all --parallel --verbose run e2e",
+    "vrt": "yarn workspaces foreach --all --parallel --verbose run vrt",
+    "vrt:docker": "./bin/run-vrt",
     "rebuild-electron": "./node_modules/.bin/electron-rebuild -f -m ./packages/loot-core",
     "rebuild-node": "yarn workspace loot-core rebuild",
-    "lint": "yarn workspaces foreach --verbose run lint",
-    "postinstall": "rm -rf ./packages/loot-design/node_modules/react && rm -rf ./packages/mobile/node_modules/react && rm -rf ./node_modules/react-native && patch-package"
+    "lint": "eslint . --max-warnings 0 --ext .js,.jsx,.ts,.tsx",
+    "lint:verbose": "DEBUG=eslint:cli-engine eslint . --max-warnings 0",
+    "typecheck": "yarn tsc && tsc-strict",
+    "jq": "./node_modules/node-jq/bin/jq",
+    "prepare": "husky"
   },
   "devDependencies": {
-    "cross-env": "^5.1.5",
-    "husky": "^3.0.4",
-    "npm-run-all": "^4.1.3",
-    "patch-package": "^6.1.2",
-    "prettier": "^1.18.1",
-    "pretty-quick": "^1.11.1",
-    "shelljs": "^0.8.2",
-    "source-map-support": "^0.5.21"
+    "@typescript-eslint/eslint-plugin": "^8.1.0",
+    "@typescript-eslint/parser": "^8.1.0",
+    "confusing-browser-globals": "^1.0.11",
+    "cross-env": "^7.0.3",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-import-resolver-typescript": "3.6.1",
+    "eslint-plugin-import": "2.29.1",
+    "eslint-plugin-jsx-a11y": "^6.9.0",
+    "eslint-plugin-prettier": "5.2.1",
+    "eslint-plugin-react": "7.35.0",
+    "eslint-plugin-react-hooks": "^4.6.2",
+    "eslint-plugin-rulesdir": "^0.2.2",
+    "husky": "^9.0.11",
+    "lint-staged": "^15.2.9",
+    "node-jq": "^4.0.1",
+    "npm-run-all": "^4.1.5",
+    "prettier": "3.3.3",
+    "source-map-support": "^0.5.21",
+    "typescript": "^5.5.4",
+    "typescript-strict-plugin": "^2.4.4"
   },
   "resolutions": {
-    "@babel/preset-env": "^7.15.1",
-    "@babel/core": "^7.15.1",
-    "@babel/runtime": "^7.15.1",
-    "@babel/helper-plugin-utils": "^7.14.5",
-    "react-error-overlay": "6.0.9"
+    "rollup": "4.9.4"
   },
-  "packageManager": "yarn@3.2.0"
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "lint-staged": {
+    "*.{js,jsx,ts,tsx,md,json}": "prettier --write"
+  },
+  "packageManager": "yarn@4.3.1",
+  "browserslist": [
+    "electron 24.0",
+    "defaults"
+  ]
 }

packages/api/.gitignore

@@ -1 +1,5 @@
 app/bundle.api.js*
+app/stats.json
+migrations
+default-db.sqlite
+mocks/budgets/**/*

packages/api/README.md

@@ -2,4 +2,4 @@
 npm install @actual-app/api
 ```
 
-View docs here: https://actualbudget.com/docs/developers/using-the-API/
+View docs here: https://actualbudget.org/docs/api/

packages/api/__snapshots__/methods.test.ts.snap

@@ -0,0 +1,21 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`API setup and teardown successfully loads budget 1`] = `
+Array [
+  "2016-10",
+  "2016-11",
+  "2016-12",
+  "2017-01",
+  "2017-02",
+  "2017-03",
+  "2017-04",
+  "2017-05",
+  "2017-06",
+  "2017-07",
+  "2017-08",
+  "2017-09",
+  "2017-10",
+  "2017-11",
+  "2017-12",
+]
+`;

packages/api/app/query.js

@@ -11,24 +11,24 @@ class Query {
       validateRefs: true,
       limit: null,
       offset: null,
-      ...state
+      ...state,
     };
   }
 
   filter(expr) {
     return new Query({
       ...this.state,
-      filterExpressions: [...this.state.filterExpressions, expr]
+      filterExpressions: [...this.state.filterExpressions, expr],
     });
   }
 
   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])
-      )
+        expr => !exprSet.has(Object.keys(expr)[0]),
+      ),
     });
   }
 
@@ -37,13 +37,13 @@ class Query {
       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;
   }
@@ -55,7 +55,7 @@ class Query {
 
     return new Query({
       ...this.state,
-      groupExpressions: [...this.state.groupExpressions, ...exprs]
+      groupExpressions: [...this.state.groupExpressions, ...exprs],
     });
   }
 
@@ -66,7 +66,7 @@ class Query {
 
     return new Query({
       ...this.state,
-      orderExpressions: [...this.state.orderExpressions, ...exprs]
+      orderExpressions: [...this.state.orderExpressions, ...exprs],
     });
   }
 
@@ -99,24 +99,6 @@ class Query {
   }
 }
 
-function getPrimaryOrderBy(query, defaultOrderBy) {
-  let orderExprs = query.serialize().orderExpressions;
-  if (orderExprs.length === 0) {
-    if (defaultOrderBy) {
-      return { order: 'asc', ...defaultOrderBy };
-    }
-    return null;
-  }
-
-  let firstOrder = orderExprs[0];
-  if (typeof firstOrder === 'string') {
-    return { field: firstOrder, order: 'asc' };
-  }
-  // Handle this form: { field: 'desc' }
-  let [field] = Object.keys(firstOrder);
-  return { field, order: firstOrder[field] };
-}
-
-module.exports = function q(table) {
+export function q(table) {
   return new Query({ table });
-};
+}

packages/api/index.js

@@ -1,34 +0,0 @@
-let bundle = require('./app/bundle.api.js');
-let injected = require('./injected');
-let methods = require('./methods');
-let utils = require('./utils');
-let actualApp;
-
-async function init({ budgetId, config } = {}) {
-  if (actualApp) {
-    return;
-  }
-
-  global.fetch = require('node-fetch');
-
-  await bundle.init({ budgetId, config });
-  actualApp = bundle.lib;
-
-  injected.send = bundle.lib.send;
-  return bundle.lib;
-}
-
-async function shutdown() {
-  if (actualApp) {
-    await actualApp.send('close-budget');
-    actualApp = null;
-  }
-}
-
-module.exports = {
-  init,
-  shutdown,
-  utils,
-  internal: bundle.lib,
-  ...methods
-};

packages/api/index.ts

@@ -0,0 +1,53 @@
+import type {
+  RequestInfo as FetchInfo,
+  RequestInit as FetchInit,
+  // @ts-ignore: false-positive commonjs module error on build until typescript 5.3
+} from 'node-fetch'; // with { 'resolution-mode': 'import' };
+
+// loot-core types
+import type { InitConfig } from 'loot-core/server/main';
+
+// @ts-ignore: bundle not available until we build it
+// eslint-disable-next-line import/extensions
+import * as bundle from './app/bundle.api.js';
+import * as injected from './injected';
+import { validateNodeVersion } from './validateNodeVersion';
+
+let actualApp: null | typeof bundle.lib;
+export const internal = bundle.lib;
+
+// DEPRECATED: remove the next line in @actual-app/api v7
+export * as methods from './methods';
+
+export * from './methods';
+export * as utils from './utils';
+
+export async function init(config: InitConfig = {}) {
+  if (actualApp) {
+    return;
+  }
+
+  validateNodeVersion();
+
+  if (!globalThis.fetch) {
+    globalThis.fetch = (url: URL | RequestInfo, init?: RequestInit) => {
+      return import('node-fetch').then(({ default: fetch }) =>
+        fetch(url as unknown as FetchInfo, init as unknown as FetchInit),
+      ) as unknown as Promise<Response>;
+    };
+  }
+
+  await bundle.init(config);
+  actualApp = bundle.lib;
+
+  injected.override(bundle.lib.send);
+  return bundle.lib;
+}
+
+export async function shutdown() {
+  if (actualApp) {
+    await actualApp.send('sync');
+    await actualApp.send('close-budget');
+    actualApp = null;
+  }
+}

packages/api/injected.js

@@ -1,5 +1,7 @@
 // TODO: comment on why it works this way
 
-let send;
+export let send;
 
-module.exports = { send };
+export function override(sendImplementation) {
+  send = sendImplementation;
+}

packages/api/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',
+  },
+};

packages/api/methods.js

@@ -1,211 +0,0 @@
-const q = require('./app/query');
-const injected = require('./injected');
-
-function send(name, args) {
-  return injected.send(name, args);
-}
-
-async function runImport(name, func) {
-  await send('api/start-import', { budgetName: name });
-  try {
-    await func();
-  } catch (e) {
-    await send('api/abort-import');
-    throw e;
-  }
-  await send('api/finish-import');
-}
-
-async function loadBudget(budgetId) {
-  return send('api/load-budget', { id: budgetId });
-}
-
-async function batchBudgetUpdates(func) {
-  await send('api/batch-budget-start');
-  try {
-    await func();
-  } finally {
-    await send('api/batch-budget-end');
-  }
-}
-
-function runQuery(query) {
-  return send('api/query', { query: query.serialize() });
-}
-
-function getBudgetMonths() {
-  return send('api/budget-months');
-}
-
-function getBudgetMonth(month) {
-  return send('api/budget-month', { month });
-}
-
-function setBudgetAmount(month, categoryId, value) {
-  return send('api/budget-set-amount', { month, categoryId, amount: value });
-}
-
-function setBudgetCarryover(month, categoryId, flag) {
-  return send('api/budget-set-carryover', { month, categoryId, flag });
-}
-
-function addTransactions(accountId, transactions) {
-  return send('api/transactions-add', { accountId, transactions });
-}
-
-function importTransactions(accountId, transactions) {
-  return send('api/transactions-import', { accountId, transactions });
-}
-
-function getTransactions(accountId, startDate, endDate) {
-  return send('api/transactions-get', { accountId, startDate, endDate });
-}
-
-function filterTransactions(accountId, text) {
-  return send('api/transactions-filter', { accountId, text });
-}
-
-function updateTransaction(id, fields) {
-  return send('api/transaction-update', { id, fields });
-}
-
-function deleteTransaction(id) {
-  return send('api/transaction-delete', { id });
-}
-
-function getAccounts() {
-  return send('api/accounts-get');
-}
-
-function createAccount(account, initialBalance) {
-  return send('api/account-create', { account, initialBalance });
-}
-
-function updateAccount(id, fields) {
-  return send('api/account-update', { id, fields });
-}
-
-function closeAccount(id, transferAccountId, transferCategoryId) {
-  return send('api/account-close', {
-    id,
-    transferAccountId,
-    transferCategoryId
-  });
-}
-
-function reopenAccount(id) {
-  return send('api/account-reopen', { id });
-}
-
-function deleteAccount(id) {
-  return send('api/account-delete', { id });
-}
-
-function getCategoryGroups() {
-  return send('api/categories-get', { grouped: true });
-}
-
-function createCategoryGroup(group) {
-  return send('api/category-group-create', { group });
-}
-
-function updateCategoryGroup(id, fields) {
-  return send('api/category-group-update', { id, fields });
-}
-
-function deleteCategoryGroup(id, transferCategoryId) {
-  return send('api/category-group-delete', { id, transferCategoryId });
-}
-
-function getCategories() {
-  return send('api/categories-get', { grouped: false });
-}
-
-function createCategory(category) {
-  return send('api/category-create', { category });
-}
-
-function updateCategory(id, fields) {
-  return send('api/category-update', { id, fields });
-}
-
-function deleteCategory(id, transferCategoryId) {
-  return send('api/category-delete', { id, transferCategoryId });
-}
-
-function getPayees() {
-  return send('api/payees-get');
-}
-
-function createPayee(payee) {
-  return send('api/payee-create', { payee });
-}
-
-function updatePayee(id, fields) {
-  return send('api/payee-update', { id, fields });
-}
-
-function deletePayee(id) {
-  return send('api/payee-delete', { id });
-}
-
-function getPayeeRules(payeeId) {
-  return send('api/payee-rules-get', { payeeId });
-}
-
-function createPayeeRule(payeeId, rule) {
-  return send('api/payee-rule-create', { payee_id: payeeId, rule });
-}
-
-function updatePayeeRule(id, fields) {
-  return send('api/payee-rule-update', { id, fields });
-}
-
-function deletePayeeRule(id) {
-  return send('api/payee-rule-delete', { id });
-}
-
-module.exports = {
-  runImport,
-
-  runQuery,
-  q,
-
-  loadBudget,
-  batchBudgetUpdates,
-  getBudgetMonths,
-  getBudgetMonth,
-  setBudgetAmount,
-  setBudgetCarryover,
-
-  addTransactions,
-  importTransactions,
-  filterTransactions,
-  getTransactions,
-  updateTransaction,
-  deleteTransaction,
-
-  getAccounts,
-  createAccount,
-  updateAccount,
-  closeAccount,
-  reopenAccount,
-  deleteAccount,
-
-  getCategories,
-  createCategoryGroup,
-  updateCategoryGroup,
-  deleteCategoryGroup,
-  createCategory,
-  updateCategory,
-  deleteCategory,
-
-  getPayees,
-  createPayee,
-  updatePayee,
-  deletePayee,
-  getPayeeRules,
-  createPayeeRule,
-  deletePayeeRule,
-  updatePayeeRule
-};

packages/api/methods.test.ts

@@ -0,0 +1,657 @@
+// @ts-strict-ignore
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+import * as api from './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: string, name: string) {
+  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);
+  });
+
+  // api: getBudgets
+  test('getBudgets', async () => {
+    const budgets = await api.getBudgets();
+    expect(budgets).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'test-budget',
+          name: 'Default Test Db',
+        }),
+      ]),
+    );
+  });
+
+  // apis: getCategoryGroups, createCategoryGroup, updateCategoryGroup, deleteCategoryGroup
+  test('CategoryGroups: successfully update category groups', async () => {
+    const month = '2023-10';
+    global.currentMonth = month;
+
+    // get existing category groups
+    const groups = await api.getCategoryGroups();
+    expect(groups).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          hidden: false,
+          id: 'fc3825fd-b982-4b72-b768-5b30844cf832',
+          is_income: false,
+          name: 'Usual Expenses',
+        }),
+        expect.objectContaining({
+          hidden: false,
+          id: 'a137772f-cf2f-4089-9432-822d2ddc1466',
+          is_income: false,
+          name: 'Investments and Savings',
+        }),
+        expect.objectContaining({
+          hidden: false,
+          id: '2E1F5BDB-209B-43F9-AF2C-3CE28E380C00',
+          is_income: true,
+          name: 'Income',
+        }),
+      ]),
+    );
+
+    // 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, getAccountBalance
+  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' }),
+      ]),
+    );
+
+    expect(await api.getAccountBalance(accountId1)).toEqual(1000);
+    expect(await api.getAccountBalance(accountId2)).toEqual(0);
+
+    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,
+        }),
+      ]),
+    );
+  });
+
+  // apis: createPayee, getPayees, updatePayee, deletePayee
+  test('Payees: successfully update payees', async () => {
+    const payeeId1 = await api.createPayee({ name: 'test-payee1' });
+    const payeeId2 = await api.createPayee({ name: 'test-payee2' });
+    let payees = await api.getPayees();
+
+    // payees successfully created
+    expect(payees).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: payeeId1,
+          name: 'test-payee1',
+        }),
+        expect.objectContaining({
+          id: payeeId2,
+          name: 'test-payee2',
+        }),
+      ]),
+    );
+
+    await api.updatePayee(payeeId1, { name: 'test-updated-payee' });
+    await api.deletePayee(payeeId2);
+
+    // confirm update and delete were successful
+    payees = await api.getPayees();
+    expect(payees).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: payeeId1,
+          name: 'test-updated-payee',
+        }),
+        expect.not.objectContaining({
+          name: 'test-payee1',
+        }),
+        expect.not.objectContaining({
+          id: payeeId2,
+        }),
+      ]),
+    );
+  });
+
+  // apis: getRules, getPayeeRules, createRule, updateRule, deleteRule
+  test('Rules: successfully update rules', async () => {
+    await api.createPayee({ name: 'test-payee' });
+    await api.createPayee({ name: 'test-payee2' });
+
+    // create our test rules
+    const rule = await api.createRule({
+      stage: 'pre',
+      conditionsOp: 'and',
+      conditions: [
+        {
+          field: 'payee',
+          op: 'is',
+          value: 'test-payee',
+        },
+      ],
+      actions: [
+        {
+          op: 'set',
+          field: 'category',
+          value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
+        },
+      ],
+    });
+    const rule2 = await api.createRule({
+      stage: 'pre',
+      conditionsOp: 'and',
+      conditions: [
+        {
+          field: 'payee',
+          op: 'is',
+          value: 'test-payee2',
+        },
+      ],
+      actions: [
+        {
+          op: 'set',
+          field: 'category',
+          value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
+        },
+      ],
+    });
+
+    // get existing rules
+    const rules = await api.getRules();
+    expect(rules).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          actions: expect.arrayContaining([
+            expect.objectContaining({
+              field: 'category',
+              op: 'set',
+              type: 'id',
+              value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
+            }),
+          ]),
+          conditions: expect.arrayContaining([
+            expect.objectContaining({
+              field: 'payee',
+              op: 'is',
+              type: 'id',
+              value: 'test-payee2',
+            }),
+          ]),
+          conditionsOp: 'and',
+          id: rule2.id,
+          stage: 'pre',
+        }),
+        expect.objectContaining({
+          actions: expect.arrayContaining([
+            expect.objectContaining({
+              field: 'category',
+              op: 'set',
+              type: 'id',
+              value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
+            }),
+          ]),
+          conditions: expect.arrayContaining([
+            expect.objectContaining({
+              field: 'payee',
+              op: 'is',
+              type: 'id',
+              value: 'test-payee',
+            }),
+          ]),
+          conditionsOp: 'and',
+          id: rule.id,
+          stage: 'pre',
+        }),
+      ]),
+    );
+
+    // get by payee
+    expect(await api.getPayeeRules('test-payee')).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          actions: expect.arrayContaining([
+            expect.objectContaining({
+              field: 'category',
+              op: 'set',
+              type: 'id',
+              value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
+            }),
+          ]),
+          conditions: expect.arrayContaining([
+            expect.objectContaining({
+              field: 'payee',
+              op: 'is',
+              type: 'id',
+              value: 'test-payee',
+            }),
+          ]),
+          conditionsOp: 'and',
+          id: rule.id,
+          stage: 'pre',
+        }),
+      ]),
+    );
+
+    expect(await api.getPayeeRules('test-payee2')).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          actions: expect.arrayContaining([
+            expect.objectContaining({
+              field: 'category',
+              op: 'set',
+              type: 'id',
+              value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
+            }),
+          ]),
+          conditions: expect.arrayContaining([
+            expect.objectContaining({
+              field: 'payee',
+              op: 'is',
+              type: 'id',
+              value: 'test-payee2',
+            }),
+          ]),
+          conditionsOp: 'and',
+          id: rule2.id,
+          stage: 'pre',
+        }),
+      ]),
+    );
+
+    // update one rule
+    const updatedRule = {
+      ...rule,
+      stage: 'post',
+      conditionsOp: 'or',
+    };
+    expect(await api.updateRule(updatedRule)).toEqual(updatedRule);
+
+    expect(await api.getRules()).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          actions: expect.arrayContaining([
+            expect.objectContaining({
+              field: 'category',
+              op: 'set',
+              type: 'id',
+              value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
+            }),
+          ]),
+          conditions: expect.arrayContaining([
+            expect.objectContaining({
+              field: 'payee',
+              op: 'is',
+              type: 'id',
+              value: 'test-payee',
+            }),
+          ]),
+          conditionsOp: 'or',
+          id: rule.id,
+          stage: 'post',
+        }),
+        expect.objectContaining({
+          actions: expect.arrayContaining([
+            expect.objectContaining({
+              field: 'category',
+              op: 'set',
+              type: 'id',
+              value: 'fc3825fd-b982-4b72-b768-5b30844cf832',
+            }),
+          ]),
+          conditions: expect.arrayContaining([
+            expect.objectContaining({
+              field: 'payee',
+              op: 'is',
+              type: 'id',
+              value: 'test-payee2',
+            }),
+          ]),
+          conditionsOp: 'and',
+          id: rule2.id,
+          stage: 'pre',
+        }),
+      ]),
+    );
+
+    // delete rules
+    await api.deleteRule(rules[1].id);
+    expect(await api.getRules()).toHaveLength(1);
+
+    await api.deleteRule(rules[0].id);
+    expect(await api.getRules()).toHaveLength(0);
+  });
+
+  // apis: addTransactions, getTransactions, importTransactions, updateTransaction, deleteTransaction
+  test('Transactions: successfully update transactions', async () => {
+    const accountId = await api.createAccount({ name: 'test-account' }, 0);
+
+    let newTransaction = [
+      { date: '2023-11-03', imported_id: '11', amount: 100, notes: 'notes' },
+      { date: '2023-11-03', imported_id: '12', amount: 100, notes: '' },
+    ];
+
+    const addResult = await api.addTransactions(accountId, newTransaction, {
+      learnCategories: true,
+      runTransfers: true,
+    });
+    expect(addResult).toBe('ok');
+
+    expect(await api.getAccountBalance(accountId)).toEqual(200);
+    expect(
+      await api.getAccountBalance(accountId, new Date(2023, 10, 2)),
+    ).toEqual(0);
+
+    // confirm added transactions exist
+    let transactions = await api.getTransactions(
+      accountId,
+      '2023-11-01',
+      '2023-11-30',
+    );
+    expect(transactions).toEqual(
+      expect.arrayContaining(
+        newTransaction.map(trans => expect.objectContaining(trans)),
+      ),
+    );
+    expect(transactions).toHaveLength(2);
+
+    newTransaction = [
+      { date: '2023-12-03', imported_id: '11', amount: 100, notes: 'notes' },
+      { date: '2023-12-03', imported_id: '12', amount: 100, notes: 'notes' },
+      { date: '2023-12-03', imported_id: '22', amount: 200, notes: '' },
+    ];
+
+    const reconciled = await api.importTransactions(accountId, newTransaction);
+
+    // Expect it to reconcile and to have updated one of the previous transactions
+    expect(reconciled.added).toHaveLength(1);
+    expect(reconciled.updated).toHaveLength(1);
+
+    // confirm imported transactions exist
+    transactions = await api.getTransactions(
+      accountId,
+      '2023-12-01',
+      '2023-12-31',
+    );
+    expect(transactions).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ imported_id: '22', amount: 200 }),
+      ]),
+    );
+    expect(transactions).toHaveLength(1);
+
+    // confirm imported transactions update perfomed
+    transactions = await api.getTransactions(
+      accountId,
+      '2023-11-01',
+      '2023-11-30',
+    );
+    expect(transactions).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ notes: 'notes', amount: 100 }),
+      ]),
+    );
+    expect(transactions).toHaveLength(2);
+
+    const idToUpdate = reconciled.added[0];
+    const idToDelete = reconciled.updated[0];
+    await api.updateTransaction(idToUpdate, { amount: 500 });
+    await api.deleteTransaction(idToDelete);
+
+    // confirm updates and deletions work
+    transactions = await api.getTransactions(
+      accountId,
+      '2023-12-01',
+      '2023-12-31',
+    );
+    expect(transactions).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: idToUpdate, amount: 500 }),
+        expect.not.objectContaining({ id: idToDelete }),
+      ]),
+    );
+    expect(transactions).toHaveLength(1);
+  });
+});

packages/api/methods.ts

@@ -0,0 +1,218 @@
+// @ts-strict-ignore
+import type { Handlers } from 'loot-core/src/types/handlers';
+
+import * as injected from './injected';
+
+export { q } from './app/query';
+
+function send<K extends keyof Handlers, T extends Handlers[K]>(
+  name: K,
+  args?: Parameters<T>[0],
+): Promise<Awaited<ReturnType<T>>> {
+  return injected.send(name, args);
+}
+
+export async function runImport(name, func) {
+  await send('api/start-import', { budgetName: name });
+  try {
+    await func();
+  } catch (e) {
+    await send('api/abort-import');
+    throw e;
+  }
+  await send('api/finish-import');
+}
+
+export async function loadBudget(budgetId) {
+  return send('api/load-budget', { id: budgetId });
+}
+
+export async function downloadBudget(syncId, { password }: { password? } = {}) {
+  return send('api/download-budget', { syncId, password });
+}
+
+export async function getBudgets() {
+  return send('api/get-budgets');
+}
+
+export async function sync() {
+  return send('api/sync');
+}
+
+export async function runBankSync(args?: { accountId: string }) {
+  return send('api/bank-sync', args);
+}
+
+export async function batchBudgetUpdates(func) {
+  await send('api/batch-budget-start');
+  try {
+    await func();
+  } finally {
+    await send('api/batch-budget-end');
+  }
+}
+
+export function runQuery(query) {
+  return send('api/query', { query: query.serialize() });
+}
+
+export function getBudgetMonths() {
+  return send('api/budget-months');
+}
+
+export function getBudgetMonth(month) {
+  return send('api/budget-month', { month });
+}
+
+export function setBudgetAmount(month, categoryId, value) {
+  return send('api/budget-set-amount', { month, categoryId, amount: value });
+}
+
+export function setBudgetCarryover(month, categoryId, flag) {
+  return send('api/budget-set-carryover', { month, categoryId, flag });
+}
+
+export function addTransactions(
+  accountId,
+  transactions,
+  { learnCategories = false, runTransfers = false } = {},
+) {
+  return send('api/transactions-add', {
+    accountId,
+    transactions,
+    learnCategories,
+    runTransfers,
+  });
+}
+
+export function importTransactions(accountId, transactions) {
+  return send('api/transactions-import', { accountId, transactions });
+}
+
+export function getTransactions(accountId, startDate, endDate) {
+  return send('api/transactions-get', { accountId, startDate, endDate });
+}
+
+export function updateTransaction(id, fields) {
+  return send('api/transaction-update', { id, fields });
+}
+
+export function deleteTransaction(id) {
+  return send('api/transaction-delete', { id });
+}
+
+export function getAccounts() {
+  return send('api/accounts-get');
+}
+
+export function createAccount(account, initialBalance?) {
+  return send('api/account-create', { account, initialBalance });
+}
+
+export function updateAccount(id, fields) {
+  return send('api/account-update', { id, fields });
+}
+
+export function closeAccount(id, transferAccountId?, transferCategoryId?) {
+  return send('api/account-close', {
+    id,
+    transferAccountId,
+    transferCategoryId,
+  });
+}
+
+export function reopenAccount(id) {
+  return send('api/account-reopen', { id });
+}
+
+export function deleteAccount(id) {
+  return send('api/account-delete', { id });
+}
+
+export function getAccountBalance(id, cutoff?) {
+  return send('api/account-balance', { id, cutoff });
+}
+
+export function getCategoryGroups() {
+  return send('api/category-groups-get');
+}
+
+export function createCategoryGroup(group) {
+  return send('api/category-group-create', { group });
+}
+
+export function updateCategoryGroup(id, fields) {
+  return send('api/category-group-update', { id, fields });
+}
+
+export function deleteCategoryGroup(id, transferCategoryId?) {
+  return send('api/category-group-delete', { id, transferCategoryId });
+}
+
+export function getCategories() {
+  return send('api/categories-get', { grouped: false });
+}
+
+export function createCategory(category) {
+  return send('api/category-create', { category });
+}
+
+export function updateCategory(id, fields) {
+  return send('api/category-update', { id, fields });
+}
+
+export function deleteCategory(id, transferCategoryId?) {
+  return send('api/category-delete', { id, transferCategoryId });
+}
+
+export function getCommonPayees() {
+  return send('api/common-payees-get');
+}
+
+export function getPayees() {
+  return send('api/payees-get');
+}
+
+export function createPayee(payee) {
+  return send('api/payee-create', { payee });
+}
+
+export function updatePayee(id, fields) {
+  return send('api/payee-update', { id, fields });
+}
+
+export function deletePayee(id) {
+  return send('api/payee-delete', { id });
+}
+
+export function mergePayees(targetId, mergeIds) {
+  return send('api/payees-merge', { targetId, mergeIds });
+}
+
+export function getRules() {
+  return send('api/rules-get');
+}
+
+export function getPayeeRules(id) {
+  return send('api/payee-rules-get', { id });
+}
+
+export function createRule(rule) {
+  return send('api/rule-create', { rule });
+}
+
+export function updateRule(rule) {
+  return send('api/rule-update', { rule });
+}
+
+export function deleteRule(id: string) {
+  return send('api/rule-delete', id);
+}
+
+export function holdBudgetForNextMonth(month, amount) {
+  return send('api/budget-hold-for-next-month', { month, amount });
+}
+
+export function resetBudgetHold(month) {
+  return send('api/budget-reset-hold', { month });
+}

packages/api/migrations/1548957970627_remove-db-version.sql

@@ -1,5 +0,0 @@
-BEGIN TRANSACTION;
-
-DROP TABLE db_version;
-
-COMMIT;

packages/api/migrations/1550601598648_payees.sql

@@ -1,23 +0,0 @@
-BEGIN TRANSACTION;
-
-CREATE TABLE payees
-  (id TEXT PRIMARY KEY,
-   name TEXT,
-   category TEXT,
-   tombstone INTEGER DEFAULT 0,
-   transfer_acct TEXT);
-
-CREATE TABLE payee_rules
-  (id TEXT PRIMARY KEY,
-   payee_id TEXT,
-   type TEXT,
-   value TEXT,
-   tombstone INTEGER DEFAULT 0);
-
-CREATE INDEX payee_rules_lowercase_index ON payee_rules(LOWER(value));
-
-CREATE TABLE payee_mapping
-  (id TEXT PRIMARY KEY,
-   targetId TEXT);
-
-COMMIT;

packages/api/migrations/1555786194328_remove_category_group_unique.sql

@@ -1,25 +0,0 @@
-BEGIN TRANSACTION;
-
-CREATE TEMPORARY TABLE category_groups_tmp
-   (id TEXT PRIMARY KEY,
-    name TEXT UNIQUE,
-    is_income INTEGER DEFAULT 0,
-    sort_order REAL,
-    tombstone INTEGER DEFAULT 0);
-
-INSERT INTO category_groups_tmp SELECT * FROM category_groups;
-
-DROP TABLE category_groups;
-
-CREATE TABLE category_groups
-   (id TEXT PRIMARY KEY,
-    name TEXT,
-    is_income INTEGER DEFAULT 0,
-    sort_order REAL,
-    tombstone INTEGER DEFAULT 0);
-
-INSERT INTO category_groups SELECT * FROM category_groups_tmp;
-
-DROP TABLE category_groups_tmp;
-
-COMMIT;

packages/api/migrations/1561751833510_indexes.sql

@@ -1,7 +0,0 @@
-BEGIN TRANSACTION;
-
-CREATE INDEX trans_category_date ON transactions(category, date);
-CREATE INDEX trans_category ON transactions(category);
-CREATE INDEX trans_date ON transactions(date);
-
-COMMIT;

packages/api/migrations/1567699552727_budget.sql

@@ -1,38 +0,0 @@
-BEGIN TRANSACTION;
-
-DELETE FROM spreadsheet_cells WHERE
-  name NOT LIKE '%!budget\_%' ESCAPE '\' AND
-  name NOT LIKE '%!carryover\_%' ESCAPE '\' AND
-  name NOT LIKE '%!buffered';
-
-UPDATE OR REPLACE spreadsheet_cells SET name = REPLACE(name, '_', '-');
-
-UPDATE OR REPLACE spreadsheet_cells SET
-  name =
-    SUBSTR(name, 1, 28) ||
-    '-' ||
-    SUBSTR(name, 29, 4) ||
-    '-' ||
-    SUBSTR(name, 33, 4) ||
-    '-' ||
-    SUBSTR(name, 37, 4) ||
-    '-' ||
-    SUBSTR(name, 41, 12)
-WHERE name LIKE '%!budget-%' AND LENGTH(name) = 52;
-
-UPDATE OR REPLACE spreadsheet_cells SET
-  name =
-    SUBSTR(name, 1, 31) ||
-    '-' ||
-    SUBSTR(name, 32, 4) ||
-    '-' ||
-    SUBSTR(name, 36, 4) ||
-    '-' ||
-    SUBSTR(name, 40, 4) ||
-    '-' ||
-    SUBSTR(name, 44, 12)
-WHERE name LIKE '%!carryover-%' AND LENGTH(name) = 55;
-
-UPDATE spreadsheet_cells SET expr = SUBSTR(expr, 2) WHERE name LIKE '%!carryover-%';
-
-COMMIT;

packages/api/migrations/1582384163573_cleared.sql

@@ -1,6 +0,0 @@
-BEGIN TRANSACTION;
-
-ALTER TABLE transactions ADD COLUMN cleared INTEGER DEFAULT 1;
-ALTER TABLE transactions ADD COLUMN pending INTEGER DEFAULT 0;
-
-COMMIT;

packages/api/migrations/1597756566448_rules.sql

@@ -1,10 +0,0 @@
-BEGIN TRANSACTION;
-
-CREATE TABLE rules
-  (id TEXT PRIMARY KEY,
-   stage TEXT,
-   conditions TEXT,
-   actions TEXT,
-   tombstone INTEGER DEFAULT 0);
-
-COMMIT;

packages/api/migrations/1608652596043_parent_field.sql

@@ -1,13 +0,0 @@
-BEGIN TRANSACTION;
-
-ALTER TABLE transactions ADD COLUMN parent_id TEXT;
-
-UPDATE transactions SET
-  parent_id = CASE
-    WHEN isChild THEN SUBSTR(id, 1, INSTR(id, '/') - 1)
-    ELSE NULL
-  END;
-
-CREATE INDEX trans_parent_id ON transactions(parent_id);
-
-COMMIT;

packages/api/migrations/1608652596044_trans_views.sql

@@ -1,56 +0,0 @@
-BEGIN TRANSACTION;
-
-DROP VIEW IF EXISTS v_transactions_layer2;
-CREATE VIEW v_transactions_layer2 AS
-SELECT
-  t.id AS id,
-  t.isParent AS is_parent,
-  t.isChild AS is_child,
-  t.acct AS account,
-  CASE WHEN t.isChild = 0 THEN NULL ELSE t.parent_id END AS parent_id,
-  CASE WHEN t.isParent = 1 THEN NULL ELSE cm.transferId END AS category,
-  pm.targetId AS payee,
-  t.imported_description AS imported_payee,
-  IFNULL(t.amount, 0) AS amount,
-  t.notes AS notes,
-  t.date AS date,
-  t.financial_id AS imported_id,
-  t.error AS error,
-  t.starting_balance_flag AS starting_balance_flag,
-  t.transferred_id AS transfer_id,
-  t.sort_order AS sort_order,
-  t.cleared AS cleared,
-  t.tombstone AS tombstone
-FROM transactions t
-LEFT JOIN category_mapping cm ON cm.id = t.category
-LEFT JOIN payee_mapping pm ON pm.id = t.description
-WHERE
-  t.date IS NOT NULL AND
-  t.acct IS NOT NULL;
-
-CREATE INDEX trans_sorted ON transactions(date desc, starting_balance_flag, sort_order desc, id);
-
-DROP VIEW IF EXISTS v_transactions_layer1;
-CREATE VIEW v_transactions_layer1 AS
-SELECT t.* FROM v_transactions_layer2 t
-LEFT JOIN transactions t2 ON (t.is_child = 1 AND t2.id = t.parent_id)
-WHERE IFNULL(t.tombstone, 0) = 0 AND IFNULL(t2.tombstone, 0) = 0;
-
-DROP VIEW IF EXISTS v_transactions;
-CREATE VIEW v_transactions AS
-SELECT t.* FROM v_transactions_layer1 t
-ORDER BY t.date desc, t.starting_balance_flag, t.sort_order desc, t.id;
-
-
-DROP VIEW IF EXISTS v_categories;
-CREATE VIEW v_categories AS
-SELECT
-  id,
-  name,
-  is_income,
-  cat_group AS "group",
-  sort_order,
-  tombstone
-FROM categories;
-
-COMMIT;

packages/api/migrations/1612625548236_optimize.sql

@@ -1,7 +0,0 @@
-BEGIN TRANSACTION;
-
-CREATE INDEX messages_crdt_search ON messages_crdt(dataset, row, column, timestamp);
-
-ANALYZE;
-
-COMMIT;

packages/api/migrations/1614782639336_trans_views2.sql

@@ -1,33 +0,0 @@
-BEGIN TRANSACTION;
-
--- This adds the isChild/parent_id constraint in `where`
-DROP VIEW IF EXISTS v_transactions_layer2;
-CREATE VIEW v_transactions_layer2 AS
-SELECT
-  t.id AS id,
-  t.isParent AS is_parent,
-  t.isChild AS is_child,
-  t.acct AS account,
-  CASE WHEN t.isChild = 0 THEN NULL ELSE t.parent_id END AS parent_id,
-  CASE WHEN t.isParent = 1 THEN NULL ELSE cm.transferId END AS category,
-  pm.targetId AS payee,
-  t.imported_description AS imported_payee,
-  IFNULL(t.amount, 0) AS amount,
-  t.notes AS notes,
-  t.date AS date,
-  t.financial_id AS imported_id,
-  t.error AS error,
-  t.starting_balance_flag AS starting_balance_flag,
-  t.transferred_id AS transfer_id,
-  t.sort_order AS sort_order,
-  t.cleared AS cleared,
-  t.tombstone AS tombstone
-FROM transactions t
-LEFT JOIN category_mapping cm ON cm.id = t.category
-LEFT JOIN payee_mapping pm ON pm.id = t.description
-WHERE
-  t.date IS NOT NULL AND
-  t.acct IS NOT NULL AND
-  (t.isChild = 0 OR t.parent_id IS NOT NULL);
-
-COMMIT;

packages/api/migrations/1615745967948_meta.sql

@@ -1,10 +0,0 @@
-BEGIN TRANSACTION;
-
-CREATE TABLE __meta__ (key TEXT PRIMARY KEY, value TEXT);
-
-DROP VIEW IF EXISTS v_transactions_layer2;
-DROP VIEW IF EXISTS v_transactions_layer1;
-DROP VIEW IF EXISTS v_transactions;
-DROP VIEW IF EXISTS v_categories;
-
-COMMIT;

packages/api/migrations/1616167010796_accounts_order.sql

@@ -1,5 +0,0 @@
-BEGIN TRANSACTION;
-
-ALTER TABLE accounts ADD COLUMN sort_order REAL;
-
-COMMIT;

packages/api/migrations/1618975177358_schedules.sql

@@ -1,28 +0,0 @@
-BEGIN TRANSACTION;
-
-CREATE TABLE schedules
-  (id TEXT PRIMARY KEY,
-   rule TEXT,
-   active INTEGER DEFAULT 0,
-   completed INTEGER DEFAULT 0,
-   posts_transaction INTEGER DEFAULT 0,
-   tombstone INTEGER DEFAULT 0);
-
-CREATE TABLE schedules_next_date
-  (id TEXT PRIMARY KEY,
-   schedule_id TEXT,
-   local_next_date INTEGER,
-   local_next_date_ts INTEGER,
-   base_next_date INTEGER,
-   base_next_date_ts INTEGER);
-
-CREATE TABLE schedules_json_paths
-  (schedule_id TEXT PRIMARY KEY,
-   payee TEXT,
-   account TEXT,
-   amount TEXT,
-   date TEXT);
-
-ALTER TABLE transactions ADD COLUMN schedule TEXT;
-
-COMMIT;

packages/api/migrations/1632571489012_remove_cache.js

@@ -1,135 +0,0 @@
-export default async function runMigration(db, uuid) {
-  function getValue(node) {
-    return node.expr != null ? node.expr : node.cachedValue;
-  }
-
-  db.execQuery(`
-CREATE TABLE zero_budget_months
-  (id TEXT PRIMARY KEY,
-   buffered INTEGER DEFAULT 0); 
-
-CREATE TABLE zero_budgets
-  (id TEXT PRIMARY KEY,
-   month INTEGER,
-   category TEXT,
-   amount INTEGER DEFAULT 0,
-   carryover INTEGER DEFAULT 0);
-
-CREATE TABLE reflect_budgets
-  (id TEXT PRIMARY KEY,
-   month INTEGER,
-   category TEXT,
-   amount INTEGER DEFAULT 0,
-   carryover INTEGER DEFAULT 0);
-
-CREATE TABLE notes
-  (id TEXT PRIMARY KEY,
-   note TEXT);
-
-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
-  );
-  db.transaction(() => {
-    budget.map(monthBudget => {
-      let 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];
-
-      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';
-      db.runQuery(
-        `INSERT INTO ${table} (id, month, category, amount, carryover) VALUES (?, ?, ?, ?, ?)`,
-        [
-          `${month}-${cat}`,
-          dbmonth,
-          cat,
-          amount,
-          carryover.length > 0 && getValue(carryover[0]) === 'true' ? 1 : 0
-        ]
-      );
-    });
-  });
-
-  // Migrate buffers
-  let buffers = db.runQuery(
-    `SELECT * FROM spreadsheet_cells WHERE name LIKE 'budget%!buffered'`,
-    [],
-    true
-  );
-  db.transaction(() => {
-    buffers.map(buffer => {
-      let match = buffer.name.match(/^budget(\d+)!buffered$/);
-      if (match) {
-        let month = match[1].slice(0, 4) + '-' + match[1].slice(4);
-        let amount = parseInt(getValue(buffer));
-        if (isNaN(amount)) {
-          amount = 0;
-        }
-
-        db.runQuery(
-          `INSERT INTO zero_budget_months (id, buffered) VALUES (?, ?)`,
-          [month, amount]
-        );
-      }
-    });
-  });
-
-  // Migrate notes
-  let notes = db.runQuery(
-    `SELECT * FROM spreadsheet_cells WHERE name LIKE 'notes!%'`,
-    [],
-    true
-  );
-
-  let parseNote = str => {
-    try {
-      let value = JSON.parse(str);
-      return value && value !== '' ? value : null;
-    } catch (e) {
-      return null;
-    }
-  };
-
-  db.transaction(() => {
-    notes.forEach(note => {
-      let parsed = parseNote(getValue(note));
-      if (parsed) {
-        let [, id] = note.name.split('!');
-        db.runQuery(`INSERT INTO notes (id, note) VALUES (?, ?)`, [id, parsed]);
-      }
-    });
-  });
-
-  db.execQuery(`
-    DROP TABLE spreadsheet_cells;
-    ANALYZE;
-    VACUUM;
-  `);
-}

packages/api/package.json

@@ -1,21 +1,40 @@
 {
   "name": "@actual-app/api",
-  "version": "4.1.5",
+  "version": "24.10.1",
   "license": "MIT",
   "description": "An API for Actual",
-  "main": "index.js",
+  "engines": {
+    "node": ">=18.12.0"
+  },
+  "main": "dist/index.js",
+  "types": "@types/index.d.ts",
   "files": [
-    "app",
-    "default-db.sqlite",
-    "index.js",
-    "injected.js",
-    "methods.js",
-    "migrations",
-    "utils.js"
+    "dist",
+    "@types"
   ],
+  "scripts": {
+    "build:app": "yarn workspace loot-core build:api",
+    "build:node": "tsc --p tsconfig.dist.json && tsc-alias -p tsconfig.dist.json",
+    "build:migrations": "cp migrations/*.sql dist/migrations",
+    "build:default-db": "cp default-db.sqlite dist/",
+    "build": "yarn run clean && 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",
+    "clean": "rm -rf dist @types"
+  },
   "dependencies": {
-    "better-sqlite3": "^7.5.0",
-    "node-fetch": "^1.6.3",
-    "uuid": "3.3.2"
+    "@actual-app/crdt": "workspace:^",
+    "better-sqlite3": "^9.6.0",
+    "compare-versions": "^6.1.0",
+    "node-fetch": "^3.3.2",
+    "uuid": "^9.0.1"
+  },
+  "devDependencies": {
+    "@swc/core": "^1.5.3",
+    "@swc/jest": "^0.2.36",
+    "@types/jest": "^27.5.2",
+    "@types/uuid": "^9.0.2",
+    "jest": "^27.5.1",
+    "tsc-alias": "^1.8.8",
+    "typescript": "^5.5.4"
   }
 }

packages/api/test.js

@@ -1,8 +0,0 @@
-let api = require('./index');
-
-async function run() {
-  let app = await api.init({ config: { dataDir: '/tmp' } });
-  await app.send('create-budget', { testMode: true });
-}
-
-run();

packages/api/tsconfig.dist.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    // Using ES2021 because that’s the newest version where
+    // the latest Node 16.x release supports all of the features
+    "target": "ES2021",
+    "module": "CommonJS",
+    "noEmit": false,
+    "declaration": true,
+    "outDir": "dist",
+    "declarationDir": "@types",
+    "paths": {
+      "loot-core/src/*": ["./loot-core/*"],
+      "loot-core/*": ["./@types/loot-core/*"],
+    }
+  },
+  "include": ["."],
+  "exclude": ["**/node_modules/*", "dist", "@types"]
+}

packages/api/utils.js

@@ -1,9 +1,7 @@
-function amountToInteger(n) {
+export function amountToInteger(n) {
   return Math.round(n * 100);
 }
 
-function integerToAmount(n) {
+export function integerToAmount(n) {
   return parseFloat((n / 100).toFixed(2));
 }
-
-module.exports = { amountToInteger, integerToAmount };

packages/api/validateNodeVersion.js

@@ -0,0 +1,16 @@
+import { satisfies } from 'compare-versions';
+
+import * as packageJson from './package.json';
+
+export function validateNodeVersion() {
+  if (process?.versions?.node) {
+    const nodeVersion = process?.versions?.node;
+    const minimumNodeVersion = packageJson.engines.node;
+
+    if (!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`,
+      );
+    }
+  }
+}

packages/crdt/.gitignore

@@ -0,0 +1,2 @@
+bin/protoc-gen-js
+bin/protoc

packages/crdt/README.md

@@ -0,0 +1,27 @@
+# `@actual-app/crdt`
+
+This package contains the core CRDT logic that enables Actual’s syncing. It is shared between the client and server. We may or may not follow semver when updating this package; any usage of it outside Actual is undocumented and at your own risk.
+
+## protobuf
+
+We use [protobuf](https://developers.google.com/protocol-buffers/) to encode messages as binary data to send across the network.
+
+### Generating protobuf
+
+The protobuf is generated by using the [protoc](https://github.com/protocolbuffers/protobuf) compiler.
+
+This can be installed by downloading one of the [pre-built binaries](https://github.com/protocolbuffers/protobuf/releases/) and placing it in your `$PATH`. The version used to build the current protobuf is [v3.20.1](https://github.com/protocolbuffers/protobuf/releases/tag/v3.20.1). You’ll also need to [download the latest version of `protoc-gen-js`](https://github.com/protocolbuffers/protobuf-javascript/releases/latest). For convenience, you can put both of these binaries in `./bin`.
+
+Once installed, the protobuf can be generated by running `./bin/generate-proto`.
+
+However there is one very important thing to remember! The default output includes this near the top:
+
+```
+var global = (function() { return this || window || global || self || Function('return this')(); }).call(null);
+```
+
+This will not work with our CSP directives. You must manually modify this to this:
+
+```
+var global = globalThis;
+```

packages/crdt/bin/generate-proto

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+cd "$(dirname "$(dirname "$0")")"
+
+if ! [ -x "$(command -v protoc)" ]; then
+  echo 'Error: protoc is not installed. See the readme for installation instructions.' >&2
+  exit 1
+fi
+
+export PATH="$PWD/bin:$PATH"
+
+protoc --plugin="protoc-gen-ts=../../node_modules/.bin/protoc-gen-ts" \
+  --ts_opt=esModuleInterop=true \
+  --ts_out="src/proto" \
+  --js_out=import_style=commonjs,binary:src/proto \
+  --proto_path=src/proto \
+  sync.proto
+
+../../node_modules/.bin/prettier --write src/proto/*.d.ts
+
+echo 'One more step! Find the `var global = ...` declaration in src/proto/sync_pb.js and change it to `var global = globalThis;`'

packages/crdt/index.ts

@@ -0,0 +1 @@
+export * from './src/main';

packages/crdt/jest.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.(t|j)sx?$': '@swc/jest',
+  },
+};

packages/crdt/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@actual-app/crdt",
+  "version": "2.1.0",
+  "license": "MIT",
+  "description": "CRDT layer of Actual",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build:node": "tsc --p tsconfig.dist.json",
+    "proto:generate": "./bin/generate-proto",
+    "build": "rm -rf dist && yarn run build:node && cp src/proto/sync_pb.d.ts dist/src/proto/",
+    "test": "jest -c jest.config.js"
+  },
+  "dependencies": {
+    "google-protobuf": "^3.12.0-rc.1",
+    "murmurhash": "^2.0.1",
+    "uuid": "^9.0.1"
+  },
+  "devDependencies": {
+    "@swc/core": "^1.5.3",
+    "@swc/jest": "^0.2.36",
+    "@types/jest": "^27.5.2",
+    "@types/uuid": "^9.0.2",
+    "jest": "^27.5.1",
+    "ts-protoc-gen": "^0.15.0",
+    "typescript": "^5.5.4"
+  }
+}

packages/crdt/src/crdt/index.ts

@@ -0,0 +1,13 @@
+import * as merkle from './merkle';
+
+export { merkle };
+export {
+  getClock,
+  setClock,
+  makeClock,
+  makeClientId,
+  serializeClock,
+  deserializeClock,
+  type Clock,
+  Timestamp,
+} from './timestamp';

packages/crdt/src/crdt/merkle.test.ts

@@ -0,0 +1,200 @@
+import * as merkle from './merkle';
+import { Timestamp } from './timestamp';
+
+function message(timestampStr: string, hash: number) {
+  const timestamp = Timestamp.parse(timestampStr)!;
+  timestamp.hash = () => hash;
+  return { timestamp };
+}
+
+function insertMessages(
+  trie: merkle.TrieNode,
+  messages: ReturnType<typeof message>[],
+) {
+  messages.forEach(msg => {
+    trie = merkle.insert(trie, msg.timestamp);
+  });
+  return trie;
+}
+
+describe('merkle trie', () => {
+  test('adding an item works', () => {
+    let trie = merkle.insert(
+      merkle.emptyTrie(),
+      Timestamp.parse('2018-11-12T13:21:40.122Z-0000-0123456789ABCDEF')!,
+    );
+    trie = merkle.insert(
+      trie,
+      Timestamp.parse('2018-11-13T13:21:40.122Z-0000-0123456789ABCDEF')!,
+    );
+    expect(trie).toMatchSnapshot();
+  });
+
+  test('diff returns the correct time difference', () => {
+    let trie1 = merkle.emptyTrie();
+    let trie2 = merkle.emptyTrie();
+
+    const messages = [
+      // First client messages
+      message('2018-11-13T13:20:40.122Z-0000-0123456789ABCDEF', 1000),
+      message('2018-11-14T13:05:35.122Z-0000-0123456789ABCDEF', 1100),
+      message('2018-11-15T22:19:00.122Z-0000-0123456789ABCDEF', 1200),
+
+      // Second client messages
+      message('2018-11-20T13:19:40.122Z-0000-0123456789ABCDEF', 1300),
+      message('2018-11-25T13:19:40.122Z-0000-0123456789ABCDEF', 1400),
+    ];
+
+    trie1 = merkle.insert(trie1, messages[0].timestamp);
+    trie1 = merkle.insert(trie1, messages[1].timestamp);
+    trie1 = merkle.insert(trie1, messages[2].timestamp);
+    expect(trie1.hash).toBe(788);
+
+    trie2 = merkle.insert(trie2, messages[3].timestamp);
+    trie2 = merkle.insert(trie2, messages[4].timestamp);
+    expect(trie2.hash).toBe(108);
+
+    expect(new Date(merkle.diff(trie1, trie2)!).toISOString()).toBe(
+      '2018-11-02T17:15:00.000Z',
+    );
+
+    trie1 = merkle.insert(trie1, messages[3].timestamp);
+    trie1 = merkle.insert(trie1, messages[4].timestamp);
+    trie2 = merkle.insert(trie2, messages[0].timestamp);
+    trie2 = merkle.insert(trie2, messages[1].timestamp);
+    trie2 = merkle.insert(trie2, messages[2].timestamp);
+    expect(trie1.hash).toBe(888);
+    expect(trie1.hash).toBe(trie2.hash);
+  });
+
+  test('diffing works with empty tries', () => {
+    const trie1 = merkle.emptyTrie();
+    const trie2 = merkle.insert(
+      merkle.emptyTrie(),
+      Timestamp.parse('2009-01-02T10:17:37.789Z-0000-0000testinguuid1')!,
+    );
+
+    expect(merkle.diff(trie1, trie2)).toBe(0);
+  });
+
+  test('pruning works and keeps correct hashes', () => {
+    const messages = [
+      message('2018-11-01T01:00:00.000Z-0000-0123456789ABCDEF', 1000),
+      message('2018-11-01T01:09:00.000Z-0000-0123456789ABCDEF', 1100),
+      message('2018-11-01T01:18:00.000Z-0000-0123456789ABCDEF', 1200),
+      message('2018-11-01T01:27:00.000Z-0000-0123456789ABCDEF', 1300),
+      message('2018-11-01T01:36:00.000Z-0000-0123456789ABCDEF', 1400),
+      message('2018-11-01T01:45:00.000Z-0000-0123456789ABCDEF', 1500),
+      message('2018-11-01T01:54:00.000Z-0000-0123456789ABCDEF', 1600),
+      message('2018-11-01T02:03:00.000Z-0000-0123456789ABCDEF', 1700),
+      message('2018-11-01T02:10:00.000Z-0000-0123456789ABCDEF', 1800),
+      message('2018-11-01T02:19:00.000Z-0000-0123456789ABCDEF', 1900),
+      message('2018-11-01T02:28:00.000Z-0000-0123456789ABCDEF', 2000),
+      message('2018-11-01T02:37:00.000Z-0000-0123456789ABCDEF', 2100),
+    ];
+
+    let trie = merkle.emptyTrie();
+    messages.forEach(msg => {
+      trie = merkle.insert(trie, msg.timestamp);
+    });
+    expect(trie.hash).toBe(2496);
+    expect(trie).toMatchSnapshot();
+
+    const pruned = merkle.prune(trie);
+    expect(pruned.hash).toBe(2496);
+    expect(pruned).toMatchSnapshot();
+  });
+
+  test('diffing differently shaped tries returns correct time', () => {
+    const messages = [
+      message('2018-11-01T01:00:00.000Z-0000-0123456789ABCDEF', 1000),
+      message('2018-11-01T01:09:00.000Z-0000-0123456789ABCDEF', 1100),
+      message('2018-11-01T01:18:00.000Z-0000-0123456789ABCDEF', 1200),
+      message('2018-11-01T01:27:00.000Z-0000-0123456789ABCDEF', 1300),
+      message('2018-11-01T01:36:00.000Z-0000-0123456789ABCDEF', 1400),
+      message('2018-11-01T01:45:00.000Z-0000-0123456789ABCDEF', 1500),
+      message('2018-11-01T01:54:00.000Z-0000-0123456789ABCDEF', 1600),
+      message('2018-11-01T02:03:00.000Z-0000-0123456789ABCDEF', 1700),
+      message('2018-11-01T02:10:00.000Z-0000-0123456789ABCDEF', 1800),
+      message('2018-11-01T02:19:00.000Z-0000-0123456789ABCDEF', 1900),
+      message('2018-11-01T02:28:00.000Z-0000-0123456789ABCDEF', 2000),
+      message('2018-11-01T02:37:00.000Z-0000-0123456789ABCDEF', 2100),
+    ];
+
+    const trie = insertMessages({}, messages);
+
+    // Case 0: It always returns a base time when comparing with an
+    // empty trie
+    expect(new Date(merkle.diff(merkle.emptyTrie(), trie)!).toISOString()).toBe(
+      '1970-01-01T00:00:00.000Z',
+    );
+    expect(new Date(merkle.diff(trie, merkle.emptyTrie())!).toISOString()).toBe(
+      '1970-01-01T00:00:00.000Z',
+    );
+
+    // Case 1: Add an older message that modifies the trie in such a
+    // way that it modifies the 1st out of 3 branches (so it will be
+    // pruned away)
+    const trie1 = insertMessages(trie, [
+      message('2018-11-01T00:59:00.000Z-0000-0123456789ABCDEF', 900),
+    ]);
+
+    // Normal comparison works
+    expect(new Date(merkle.diff(trie1, trie)!).toISOString()).toBe(
+      '2018-11-01T00:54:00.000Z',
+    );
+
+    // Comparing the pruned new trie is lossy, so it returns an even older time
+    expect(
+      new Date(merkle.diff(merkle.prune(trie1), trie)!).toISOString(),
+    ).toBe('2018-11-01T00:45:00.000Z');
+
+    // Comparing the pruned original trie is just as lossy
+    expect(
+      new Date(merkle.diff(trie1, merkle.prune(trie))!).toISOString(),
+    ).toBe('2018-11-01T00:45:00.000Z');
+
+    // Pruning both tries is just as lossy as well, since the changed
+    // key is pruned away in both cases and it won't find a changed
+    // key so it bails at the point
+    expect(
+      new Date(
+        merkle.diff(merkle.prune(trie1), merkle.prune(trie))!,
+      ).toISOString(),
+    ).toBe('2018-11-01T00:45:00.000Z');
+
+    // Case 2: Add two messages similar to the above case, but the
+    // second message modifies the 2nd key at the same level as the
+    // first message modifying the 1st key
+    const trie2 = insertMessages(trie, [
+      message('2018-11-01T00:59:00.000Z-0000-0123456789ABCDEF', 900),
+      message('2018-11-01T01:15:00.000Z-0000-0123456789ABCDEF', 1422),
+    ]);
+
+    // Normal comparison works
+    expect(new Date(merkle.diff(trie2, trie)!).toISOString()).toBe(
+      '2018-11-01T00:54:00.000Z',
+    );
+
+    // Same as case 1
+    expect(
+      new Date(merkle.diff(merkle.prune(trie2), trie)!).toISOString(),
+    ).toBe('2018-11-01T00:45:00.000Z');
+
+    // Same as case 1
+    expect(
+      new Date(merkle.diff(trie2, merkle.prune(trie))!).toISOString(),
+    ).toBe('2018-11-01T00:45:00.000Z');
+
+    // Pruning both tries is very lossy and this ends up returning a
+    // time that only covers the second message. Syncing will need
+    // multiple passes to sync up. This happens because the second
+    // message provides a "changed path" that the diff takes which
+    // ignores the first message.
+    expect(
+      new Date(
+        merkle.diff(merkle.prune(trie2), merkle.prune(trie))!,
+      ).toISOString(),
+    ).toBe('2018-11-01T01:12:00.000Z');
+  });
+});

packages/crdt/src/crdt/merkle.ts

@@ -0,0 +1,181 @@
+// TODO: Ok, several problems:
+//
+// * If nothing matches between two merkle trees, we should fallback
+// * to the last window instead the front one (use 0 instead of the
+// * key)
+//
+// * Need to check to make sure if account exists when handling
+// * transaction changes in syncing
+
+import { Timestamp } from './timestamp';
+
+/**
+ * Represents a node within a trinary radix trie.
+ */
+export type TrieNode = {
+  '0'?: TrieNode;
+  '1'?: TrieNode;
+  '2'?: TrieNode;
+  hash?: number;
+};
+
+type NumberTrieNodeKey = keyof Omit<TrieNode, 'hash'>;
+
+export function emptyTrie(): TrieNode {
+  return { hash: 0 };
+}
+
+function isNumberTrieNodeKey(input: string): input is NumberTrieNodeKey {
+  return ['0', '1', '2'].includes(input);
+}
+
+export function getKeys(trie: TrieNode): NumberTrieNodeKey[] {
+  return Object.keys(trie).filter(isNumberTrieNodeKey);
+}
+
+export function keyToTimestamp(key: string): number {
+  // 16 is the length of the base 3 value of the current time in
+  // minutes. Ensure it's padded to create the full value
+  const fullkey = key + '0'.repeat(16 - key.length);
+
+  // Parse the base 3 representation
+  return parseInt(fullkey, 3) * 1000 * 60;
+}
+
+/**
+ * Mutates `trie` to insert a node at `timestamp`
+ */
+export function insert(trie: TrieNode, timestamp: Timestamp) {
+  const hash = timestamp.hash();
+  const key = Number(Math.floor(timestamp.millis() / 1000 / 60)).toString(3);
+
+  trie = Object.assign({}, trie, { hash: (trie.hash || 0) ^ hash });
+  return insertKey(trie, key, hash);
+}
+
+function insertKey(trie: TrieNode, key: string, hash: number): TrieNode {
+  if (key.length === 0) {
+    return trie;
+  }
+  const c = key[0];
+  const t = isNumberTrieNodeKey(c) ? trie[c] : undefined;
+  const n = t || {};
+  return Object.assign({}, trie, {
+    [c]: Object.assign({}, n, insertKey(n, key.slice(1), hash), {
+      hash: (n.hash || 0) ^ hash,
+    }),
+  });
+}
+
+export function build(timestamps: Timestamp[]) {
+  const trie = emptyTrie();
+  for (const timestamp of timestamps) {
+    insert(trie, timestamp);
+  }
+  return trie;
+}
+
+export function diff(trie1: TrieNode, trie2: TrieNode): number | null {
+  if (trie1.hash === trie2.hash) {
+    return null;
+  }
+
+  let node1 = trie1;
+  let node2 = trie2;
+  let k = '';
+
+  // This loop will eventually stop when it traverses down to find
+  // where the hashes differ, or otherwise when there are no leaves
+  // left (this shouldn't happen, if that's the case the hash check at
+  // the top of this function should pass)
+  while (1) {
+    const keyset = new Set([...getKeys(node1), ...getKeys(node2)]);
+    const keys = [...keyset.values()];
+    keys.sort();
+
+    let diffkey: null | '0' | '1' | '2' = null;
+
+    // Traverse down the trie through keys that aren't the same. We
+    // traverse down the keys in order. Stop in two cases: either one
+    // of the nodes doesn't have the key, or a different key isn't
+    // found. For the former case, we have to that because pruning is
+    // lossy. We don't know if we've pruned off a changed key so we
+    // can't traverse down anymore. For the latter case, it means two
+    // things: either we've hit the bottom of the tree, or the changed
+    // key has been pruned off. In the latter case we have a "partial"
+    // key and will fill the rest with 0s. Note that if multiple older
+    // messages were added into one trie, it's possible we will
+    // generate a time that only encompasses *some* of the those
+    // messages. Pruning is lossy, and we traverse down the left-most
+    // changed time that we know of, because of pruning it might take
+    // multiple passes to sync up a trie.
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+
+      const next1 = node1[key];
+      const next2 = node2[key];
+
+      if (!next1 || !next2) {
+        break;
+      }
+
+      if (next1.hash !== next2.hash) {
+        diffkey = key;
+        break;
+      }
+    }
+
+    if (!diffkey) {
+      return keyToTimestamp(k);
+    }
+
+    k += diffkey;
+    node1 = node1[diffkey] || emptyTrie();
+    node2 = node2[diffkey] || emptyTrie();
+  }
+
+  // eslint-disable-next-line no-unreachable
+  return null;
+}
+
+export function prune(trie: TrieNode, n = 2): TrieNode {
+  // Do nothing if empty
+  if (!trie.hash) {
+    return trie;
+  }
+
+  const keys = getKeys(trie);
+  keys.sort();
+
+  const next: TrieNode = { hash: trie.hash };
+
+  // Prune child nodes.
+  for (const k of keys.slice(-n)) {
+    const node = trie[k];
+
+    if (!node) {
+      throw new Error(`TrieNode for key ${k} could not be found`);
+    }
+
+    next[k] = prune(node, n);
+  }
+
+  return next;
+}
+
+export function debug(trie: TrieNode, k = '', indent = 0): string {
+  const str =
+    ' '.repeat(indent) +
+    (k !== '' ? `k: ${k} ` : '') +
+    `hash: ${trie.hash || '(empty)'}\n`;
+  return (
+    str +
+    getKeys(trie)
+      .map(key => {
+        const node = trie[key];
+        if (!node) return '';
+        return debug(node, key, indent + 2);
+      })
+      .join('')
+  );
+}

packages/crdt/src/crdt/timestamp.test.ts

@@ -0,0 +1,326 @@
+import { Timestamp } from './timestamp';
+
+describe('Timestamp', function () {
+  let now = 0;
+  let prevNow: typeof Date.now;
+
+  beforeEach(function () {
+    prevNow = Date.now;
+    Date.now = () => now;
+    Timestamp.init({ node: '1' });
+  });
+
+  afterEach(() => {
+    Date.now = prevNow;
+  });
+
+  describe('comparison', function () {
+    it('should be in order', function () {
+      const sendTimestamp = Timestamp.send();
+
+      expect(Timestamp.zero).toBe(Timestamp.zero);
+      expect(Timestamp.max > Timestamp.zero).toBeTruthy();
+      expect(sendTimestamp && sendTimestamp > Timestamp.zero).toBeTruthy();
+      expect(sendTimestamp && sendTimestamp < Timestamp.max).toBeTruthy();
+    });
+  });
+
+  describe('parsing', function () {
+    it('should not parse', function () {
+      const invalidInputs = [
+        null,
+        undefined,
+        {},
+        [],
+        42,
+        '',
+        ' ',
+        '0',
+        'invalid',
+        '1969-1-1T0:0:0.0Z-0-0-0',
+        '1969-01-01T00:00:00.000Z-0000-0000000000000000',
+        '10000-01-01T00:00:00.000Z-FFFF-FFFFFFFFFFFFFFFF',
+        '9999-12-31T23:59:59.999Z-10000-FFFFFFFFFFFFFFFF',
+        '9999-12-31T23:59:59.999Z-FFFF-10000000000000000',
+      ];
+      for (const invalidInput of invalidInputs) {
+        expect(Timestamp.parse(invalidInput as string)).toBe(null);
+      }
+    });
+
+    it('should parse', function () {
+      const validInputs = [
+        '1970-01-01T00:00:00.000Z-0000-0000000000000000',
+        '2015-04-24T22:23:42.123Z-1000-0123456789ABCDEF',
+        '9999-12-31T23:59:59.999Z-FFFF-FFFFFFFFFFFFFFFF',
+      ];
+      for (const validInput of validInputs) {
+        const parsed = Timestamp.parse(validInput)!;
+        expect(typeof parsed).toBe('object');
+        expect(parsed.millis() >= 0).toBeTruthy();
+        expect(parsed.millis() < 253402300800000).toBeTruthy();
+        expect(parsed.counter() >= 0).toBeTruthy();
+        expect(parsed.counter() < 65536).toBeTruthy();
+        expect(typeof parsed.node()).toBe('string');
+        expect(parsed.toString()).toBe(validInput);
+      }
+    });
+  });
+
+  describe('send', function () {
+    it('should send monotonically with a monotonic clock', function () {
+      now = 10;
+      expect(Timestamp.send()).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.010Z-0000-0000000000000001'),
+      );
+      now++;
+      expect(Timestamp.send()).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.011Z-0000-0000000000000001'),
+      );
+      now++;
+      expect(Timestamp.send()).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.012Z-0000-0000000000000001'),
+      );
+    });
+
+    it('should send monotonically with a stuttering clock', function () {
+      now = 20;
+      expect(Timestamp.send()).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.020Z-0000-0000000000000001'),
+      );
+      expect(Timestamp.send()).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.020Z-0001-0000000000000001'),
+      );
+      expect(Timestamp.send()).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.020Z-0002-0000000000000001'),
+      );
+      now++;
+      expect(Timestamp.send()).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.021Z-0000-0000000000000001'),
+      );
+    });
+
+    it('should send monotonically with a regressing clock', function () {
+      now = 30;
+      expect(Timestamp.send()).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.030Z-0000-0000000000000001'),
+      );
+      now--;
+      expect(Timestamp.send()).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.030Z-0001-0000000000000001'),
+      );
+      expect(Timestamp.send()).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.030Z-0002-0000000000000001'),
+      );
+      now = 31;
+      expect(Timestamp.send()).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.031Z-0000-0000000000000001'),
+      );
+    });
+
+    it('should fail with counter overflow', function () {
+      now = 40;
+      for (let i = 0; i < 65536; i++) Timestamp.send();
+      expect(Timestamp.send).toThrow(Timestamp.OverflowError);
+    });
+
+    it('should fail with clock drift', function () {
+      now = -(5 * 60 * 1000 + 1);
+      expect(Timestamp.send).toThrow(Timestamp.ClockDriftError);
+    });
+  });
+
+  describe('recv', function () {
+    it('should receive monotonically with a global monotonic clock', function () {
+      now = 52;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.051Z-0000-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.052Z-0000-0000000000000001'),
+      );
+      now = 54;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.053Z-0000-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.054Z-0000-0000000000000001'),
+      );
+      now = 56;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.055Z-0000-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.056Z-0000-0000000000000001'),
+      );
+    });
+
+    it('should receive monotonically with a global stuttering clock', function () {
+      now = 61;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.062Z-0000-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.062Z-0001-0000000000000001'),
+      );
+      now = 62;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.062Z-0001-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.062Z-0002-0000000000000001'),
+      );
+      now = 62;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.062Z-0002-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.062Z-0003-0000000000000001'),
+      );
+      now = 63;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.062Z-0004-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.063Z-0000-0000000000000001'),
+      );
+    });
+
+    it('should receive monotonically with a local stuttering clock', function () {
+      now = 73;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.071Z-0000-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.073Z-0000-0000000000000001'),
+      );
+      now = 73;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.072Z-0000-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.073Z-0001-0000000000000001'),
+      );
+      now = 74;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.073Z-0000-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.074Z-0000-0000000000000001'),
+      );
+    });
+
+    it('should receive monotonically with a remote stuttering clock', function () {
+      now = 81;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.083Z-0000-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.083Z-0001-0000000000000001'),
+      );
+      now = 82;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.083Z-0001-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.083Z-0002-0000000000000001'),
+      );
+      now = 83;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.083Z-0002-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.083Z-0003-0000000000000001'),
+      );
+      now = 84;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.083Z-0003-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.084Z-0000-0000000000000001'),
+      );
+    });
+    it('should receive monotonically with a local regressing clock', function () {
+      now = 93;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.091Z-0000-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.093Z-0000-0000000000000001'),
+      );
+      now = 92;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.092Z-0000-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.093Z-0001-0000000000000001'),
+      );
+      now = 91;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.093Z-0000-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.093Z-0002-0000000000000001'),
+      );
+    });
+    it('should receive monotonically with a remote regressing clock', function () {
+      now = 101;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.103Z-0000-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.103Z-0001-0000000000000001'),
+      );
+      now = 102;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.102Z-0000-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.103Z-0002-0000000000000001'),
+      );
+      now = 103;
+      expect(
+        Timestamp.recv(
+          Timestamp.parse('1970-01-01T00:00:00.101Z-0000-0000000000000002')!,
+        ),
+      ).toEqual(
+        Timestamp.parse('1970-01-01T00:00:00.103Z-0003-0000000000000001'),
+      );
+    });
+
+    // it('should fail with a duplicate node id', function() {
+    //   expect(function() {
+    //     Timestamp.recv(
+    //       Timestamp.parse('1970-01-01T00:00:00.101Z-0000-0000000000000001')
+    //     );
+    //   }).toThrow(Timestamp.DuplicateNodeError);
+    // });
+
+    it('should fail with clock drift', function () {
+      expect(function () {
+        Timestamp.recv(
+          Timestamp.parse('1980-01-01T00:00:00.101Z-0000-0000000000000002')!,
+        );
+      }).toThrow(Timestamp.ClockDriftError);
+    });
+  });
+});

packages/crdt/src/crdt/timestamp.ts

@@ -0,0 +1,358 @@
+import murmurhash from 'murmurhash';
+import { v4 as uuidv4 } from 'uuid';
+
+import { TrieNode } from './merkle';
+
+/**
+ * Hybrid Unique Logical Clock (HULC) timestamp generator
+ *
+ * Globally-unique, monotonic timestamps are generated from the
+ *    combination of the unreliable system time, a counter, and an
+ *    identifier for the current node (instance, machine, process, etc.).
+ *    These timestamps can accommodate clock stuttering (duplicate values),
+ *    regression, and node differences within the configured maximum drift.
+ *
+ * In order to generate timestamps locally or for transmission to another
+ *    node, use the send() method. For global causality, timestamps must
+ *    be included in each message processed by the system. Whenever a
+ *    message is received, its timestamp must be passed to the recv()
+ *    method.
+ *
+ * Timestamps serialize into a 46-character collatable string
+ *    example: 2015-04-24T22:23:42.123Z-1000-0123456789ABCDEF
+ *    example: 2015-04-24T22:23:42.123Z-1000-A219E7A71CC18912
+ *
+ * The 64-bit hybrid clock is based on the HLC specification,
+ * http://www.cse.buffalo.edu/tech-reports/2014-04.pdf
+ */
+
+export type Clock = {
+  timestamp: MutableTimestamp;
+  merkle: TrieNode;
+};
+
+// A mutable global clock
+let clock: Clock;
+
+export function setClock(clock_: Clock): void {
+  clock = clock_;
+}
+
+export function getClock(): Clock {
+  return clock;
+}
+
+export function makeClock(timestamp: Timestamp, merkle: TrieNode = {}) {
+  return { timestamp: MutableTimestamp.from(timestamp), merkle };
+}
+
+export function serializeClock(clock: Clock): string {
+  return JSON.stringify({
+    timestamp: clock.timestamp.toString(),
+    merkle: clock.merkle,
+  });
+}
+
+export function deserializeClock(clock: string): Clock {
+  let data;
+  try {
+    data = JSON.parse(clock);
+  } catch (e) {
+    data = {
+      timestamp: '1970-01-01T00:00:00.000Z-0000-' + makeClientId(),
+      merkle: {},
+    };
+  }
+
+  const ts = Timestamp.parse(data.timestamp);
+
+  if (!ts) {
+    throw new Timestamp.InvalidError(data.timestamp);
+  }
+
+  return {
+    timestamp: MutableTimestamp.from(ts),
+    merkle: data.merkle,
+  };
+}
+
+export function makeClientId() {
+  return uuidv4().replace(/-/g, '').slice(-16);
+}
+
+const config = {
+  // Allow 5 minutes of clock drift
+  maxDrift: 5 * 60 * 1000,
+};
+
+const MAX_COUNTER = parseInt('0xFFFF');
+const MAX_NODE_LENGTH = 16;
+
+/**
+ * timestamp instance class
+ */
+export class Timestamp {
+  _state: { millis: number; counter: number; node: string };
+
+  constructor(millis: number, counter: number, node: string) {
+    this._state = {
+      millis,
+      counter,
+      node,
+    };
+  }
+
+  valueOf() {
+    return this.toString();
+  }
+
+  toString() {
+    return [
+      new Date(this.millis()).toISOString(),
+      ('0000' + this.counter().toString(16).toUpperCase()).slice(-4),
+      ('0000000000000000' + this.node()).slice(-16),
+    ].join('-');
+  }
+
+  millis() {
+    return this._state.millis;
+  }
+
+  counter() {
+    return this._state.counter;
+  }
+
+  node() {
+    return this._state.node;
+  }
+
+  hash() {
+    return murmurhash.v3(this.toString());
+  }
+
+  // Timestamp generator initialization
+  // * sets the node ID to an arbitrary value
+  // * useful for mocking/unit testing
+  static init(options: { maxDrift?: number; node?: string } = {}) {
+    if (options.maxDrift) {
+      config.maxDrift = options.maxDrift;
+    }
+
+    setClock(
+      makeClock(
+        new Timestamp(
+          0,
+          0,
+          options.node
+            ? ('0000000000000000' + options.node).toString().slice(-16)
+            : '',
+        ),
+      ),
+    );
+  }
+
+  /**
+   * maximum timestamp
+   */
+
+  static max = Timestamp.parse(
+    '9999-12-31T23:59:59.999Z-FFFF-FFFFFFFFFFFFFFFF',
+  )!;
+
+  /**
+   * timestamp parsing
+   * converts a fixed-length string timestamp to the structured value
+   */
+  static parse(timestamp: string | Timestamp): Timestamp | null {
+    if (timestamp instanceof Timestamp) {
+      return timestamp;
+    }
+    if (typeof timestamp === 'string') {
+      const parts = timestamp.split('-');
+      if (parts && parts.length === 5) {
+        const millis = Date.parse(parts.slice(0, 3).join('-')).valueOf();
+        const counter = parseInt(parts[3], 16);
+        const node = parts[4];
+        if (
+          !isNaN(millis) &&
+          millis >= 0 &&
+          !isNaN(counter) &&
+          counter <= MAX_COUNTER &&
+          typeof node === 'string' &&
+          node.length <= MAX_NODE_LENGTH
+        ) {
+          return new Timestamp(millis, counter, node);
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Timestamp send. Generates a unique, monotonic timestamp suitable
+   * for transmission to another system in string format
+   */
+  static send(): Timestamp | null {
+    if (!clock) {
+      return null;
+    }
+
+    // retrieve the local wall time
+    const phys = Date.now();
+
+    // unpack the clock.timestamp logical time and counter
+    const lOld = clock.timestamp.millis();
+    const cOld = clock.timestamp.counter();
+
+    // calculate the next logical time and counter
+    // * ensure that the logical time never goes backward
+    // * increment the counter if phys time does not advance
+    const lNew = Math.max(lOld, phys);
+    const cNew = lOld === lNew ? cOld + 1 : 0;
+
+    // check the result for drift and counter overflow
+    if (lNew - phys > config.maxDrift) {
+      throw new Timestamp.ClockDriftError(lNew, phys, config.maxDrift);
+    }
+    if (cNew > MAX_COUNTER) {
+      throw new Timestamp.OverflowError();
+    }
+
+    // repack the logical time/counter
+    clock.timestamp.setMillis(lNew);
+    clock.timestamp.setCounter(cNew);
+
+    return new Timestamp(
+      clock.timestamp.millis(),
+      clock.timestamp.counter(),
+      clock.timestamp.node(),
+    );
+  }
+
+  // Timestamp receive. Parses and merges a timestamp from a remote
+  // system with the local timeglobal uniqueness and monotonicity are
+  // preserved
+  static recv(msg: Timestamp): Timestamp | null {
+    if (!clock) {
+      return null;
+    }
+
+    // retrieve the local wall time
+    const phys = Date.now();
+
+    // unpack the message wall time/counter
+    const lMsg = msg.millis();
+    const cMsg = msg.counter();
+
+    // assert the node id and remote clock drift
+    // if (msg.node() === clock.timestamp.node()) {
+    //   throw new Timestamp.DuplicateNodeError(clock.timestamp.node());
+    // }
+    if (lMsg - phys > config.maxDrift) {
+      throw new Timestamp.ClockDriftError();
+    }
+
+    // unpack the clock.timestamp logical time and counter
+    const lOld = clock.timestamp.millis();
+    const cOld = clock.timestamp.counter();
+
+    // calculate the next logical time and counter
+    // . ensure that the logical time never goes backward
+    // . if all logical clocks are equal, increment the max counter
+    // . if max = old > message, increment local counter
+    // . if max = messsage > old, increment message counter
+    // . otherwise, clocks are monotonic, reset counter
+    const lNew = Math.max(Math.max(lOld, phys), lMsg);
+    const cNew =
+      lNew === lOld && lNew === lMsg
+        ? Math.max(cOld, cMsg) + 1
+        : lNew === lOld
+          ? cOld + 1
+          : lNew === lMsg
+            ? cMsg + 1
+            : 0;
+
+    // check the result for drift and counter overflow
+    if (lNew - phys > config.maxDrift) {
+      throw new Timestamp.ClockDriftError();
+    }
+    if (cNew > MAX_COUNTER) {
+      throw new Timestamp.OverflowError();
+    }
+
+    // repack the logical time/counter
+    clock.timestamp.setMillis(lNew);
+    clock.timestamp.setCounter(cNew);
+
+    return new Timestamp(
+      clock.timestamp.millis(),
+      clock.timestamp.counter(),
+      clock.timestamp.node(),
+    );
+  }
+
+  /**
+   * zero/minimum timestamp
+   */
+
+  static zero = Timestamp.parse(
+    '1970-01-01T00:00:00.000Z-0000-0000000000000000',
+  )!;
+
+  static since = (isoString: string) => isoString + '-0000-0000000000000000';
+
+  /**
+   * error classes
+   */
+  static DuplicateNodeError = class DuplicateNodeError extends Error {
+    constructor(node: string) {
+      super('duplicate node identifier ' + node);
+      this.name = 'DuplicateNodeError';
+    }
+  };
+
+  static ClockDriftError = class ClockDriftError extends Error {
+    constructor(...args: unknown[]) {
+      super(
+        ['maximum clock drift exceeded'].concat(args as string[]).join(' '),
+      );
+      this.name = 'ClockDriftError';
+    }
+  };
+
+  static OverflowError = class OverflowError extends Error {
+    constructor() {
+      super('timestamp counter overflow');
+      this.name = 'OverflowError';
+    }
+  };
+
+  static InvalidError = class InvalidError extends Error {
+    constructor(...args: unknown[]) {
+      super(['timestamp is not valid'].concat(args.map(String)).join(' '));
+      this.name = 'InvalidError';
+    }
+  };
+}
+
+class MutableTimestamp extends Timestamp {
+  static from(timestamp: Timestamp) {
+    return new MutableTimestamp(
+      timestamp.millis(),
+      timestamp.counter(),
+      timestamp.node(),
+    );
+  }
+
+  setMillis(n: number) {
+    this._state.millis = n;
+  }
+
+  setCounter(n: number) {
+    this._state.counter = n;
+  }
+
+  setNode(n: string) {
+    this._state.node = n;
+  }
+}