Init bun and flake file

.env.example

@@ -9,6 +9,8 @@ ACTUAL_DATA_DIR=.cache
 BANK_INITIAL_REFRESH_TOKEN=initial-valid-refresh-token
 BANK_OAUTH_CLIENT_ID=your-client-id
 BANK_OAUTH_CLIENT_SECRET=your-client-secret
+BANK_OAUTH_STATE=your-state
+BANK_OAUTH_REDIRECT_URI=http://your-redirect-uri.com
 BANK_ACCOUNT_IDS=your-account-id1,your-account-id2
 # Configuration
 LOG_LEVEL=info# trace | error | warn | info | debug | trace

.gitea/workflows/deploy.yml

@@ -15,11 +15,13 @@ jobs:
       ACTUAL_SERVER_URL: ${{ secrets.ACTUAL_SERVER_URL }}
       ACTUAL_PASSWORD: ${{ secrets.ACTUAL_PASSWORD }}
       ACTUAL_ACCOUNT_IDS: ${{ secrets.ACTUAL_ACCOUNT_IDS }}
-      ACTUAL_DATA_DIR: ${{ vars.ACTUAL_DATA_DIR }}
+      ACTUAL_DATA_DIR: ${{ var.ACTUAL_DATA_DIR }}
       # Bank
       BANK_INITIAL_REFRESH_TOKEN: ${{ secrets.BANK_INITIAL_REFRESH_TOKEN }}
       BANK_OAUTH_CLIENT_ID: ${{ secrets.BANK_OAUTH_CLIENT_ID }}
       BANK_OAUTH_CLIENT_SECRET: ${{ secrets.BANK_OAUTH_CLIENT_SECRET }}
+      BANK_OAUTH_STATE: ${{ secrets.BANK_OAUTH_STATE }}
+      BANK_OAUTH_REDIRECT_URI: ${{ secrets.BANK_OAUTH_REDIRECT_URI }}
       BANK_ACCOUNT_IDS: ${{ secrets.BANK_ACCOUNT_IDS }}
       # Configuration
       LOG_LEVEL: ${{ vars.LOG_LEVEL }}

Dockerfile

@@ -3,6 +3,9 @@ LABEL authors="Martin Berg Alstad"
 
 COPY . .
 
-RUN --mount=type=cache,id=npm,target=/store npm install --omit=dev --frozen-lockfile
+ENV PNPM_HOME="/pnpm"
+ENV PATH="$PNPM_HOME:$PATH"
+RUN corepack enable
+RUN --mount=type=cache,id=pnpm,target=/pnpm/store pnpm install --prod --frozen-lockfile
 
-ENTRYPOINT ["npm", "run", "start-prod"]
+CMD ["pnpm", "start-prod"]

docker-compose.yml

@@ -1,7 +1,7 @@
 services:
   server:
     container_name: actual_sparebank1_cronjob
-    restart: no
+    restart: unless-stopped
     build:
       context: .
     environment:
@@ -14,14 +14,13 @@ services:
       - BANK_INITIAL_REFRESH_TOKEN
       - BANK_OAUTH_CLIENT_ID
       - BANK_OAUTH_CLIENT_SECRET
+      - BANK_OAUTH_STATE
+      - BANK_OAUTH_REDIRECT_URI
       - BANK_ACCOUNT_IDS
       - LOG_LEVEL
       - DB_DIRECTORY # Required for Docker Compose
       - DB_FILENAME
-      - TRANSACTION_RELATIVE_FROM_DATE
-      - TRANSACTION_RELATIVE_TO_DATE
     volumes:
-      # TODO CACHE directory in volume?
       - data:/${DB_DIRECTORY}
 
 volumes:

flake.lock

@@ -2,16 +2,16 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1738277201,
-        "narHash": "sha256-6L+WXKCw5mqnUIExvqkD99pJQ41xgyCk6z/H9snClwk=",
+        "lastModified": 1738680400,
+        "narHash": "sha256-ooLh+XW8jfa+91F1nhf9OF7qhuA/y1ChLx6lXDNeY5U=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "666e1b3f09c267afd66addebe80fb05a5ef2b554",
+        "rev": "799ba5bffed04ced7067a91798353d360788b30d",
         "type": "github"
       },
       "original": {
         "owner": "NixOS",
-        "ref": "nixos-24.11",
+        "ref": "nixos-unstable",
         "repo": "nixpkgs",
         "type": "github"
       }

flake.nix

@@ -1,6 +1,6 @@
 {
   inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.11";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
   };
 
   outputs = inputs@{ nixpkgs, ... }:
@@ -16,10 +16,7 @@
         in
         pkgs.mkShell {
           packages = with pkgs; [
-            git
-            nodejs_22
-            pnpm
-            nodePackages.prettier
+            bun
           ];
 
           shellHook = "fish";

httpRequests/sparebank1API.http

@@ -51,8 +51,6 @@ GET {{bankingBaseUrl}}/accounts
 Authorization: Bearer {{ACCESS_TOKEN}}
 
 ### Fetch all transactions of specific days (inclusive)
-GET {{bankingBaseUrl}}/transactions?accountKey={{accountKey1}}&accountKey={{accountKey2}}&
-    fromDate=2025-01-20&
-    toDate=2025-01-24
+GET {{bankingBaseUrl}}/transactions?accountKey={{brukskontoAccountKey}}&fromDate=2025-01-20&toDate=2025-01-22
 Authorization: Bearer {{ACCESS_TOKEN}}
 Accept: application/vnd.sparebank1.v1+json; charset=utf-8

package.json

@@ -4,6 +4,7 @@
   "description": "",
   "main": "index.js",
   "scripts": {
+    "preinstall": "npx only-allow pnpm",
     "start": "dotenvx run --env-file=.env.local -- node --import=tsx ./src/main.ts | pino-pretty",
     "start-prod": "node --import=tsx ./src/main.ts",
     "run-once": "ONCE=true dotenvx run --env-file=.env.local -- node --import=tsx ./src/main.ts | pino-pretty",
@@ -34,7 +35,8 @@
     "pino-pretty": "^13.0.0",
     "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
-    "typescript": "^5.7.3"
+    "typescript": "^5.7.3",
+    "@types/bun": "latest"
   },
   "prettier": {
     "semi": false,

src/actual.ts

@@ -12,14 +12,13 @@ import logger from "@/logger.ts"
 export interface Actual {
   importTransactions: (
     accountId: UUID,
-    transactions: Iterable<ActualTransaction>,
+    transactions: ReadonlyArray<ActualTransaction>,
   ) => Promise<ImportTransactionsResponse>
 
   shutdown: () => Promise<void>
 }
 
 export interface ActualTransaction extends TransactionEntity {
-  account: UUID
   payee_name?: string
 }
 
@@ -52,7 +51,7 @@ export class ActualImpl implements Actual {
 
   async importTransactions(
     accountId: UUID,
-    transactions: Iterable<ActualTransaction>,
+    transactions: ReadonlyArray<ActualTransaction>,
   ): Promise<ImportTransactionsResponse> {
     return actual.importTransactions(accountId, transactions)
   }

src/bank/db/queries.ts

@@ -50,7 +50,7 @@ function insertRefreshToken(
   db: Database.Database,
   refreshToken: string,
   expiresIn: number,
-): void {
+) {
   insert(db, "refresh-token", refreshToken, expiresIn)
 }
 
@@ -59,7 +59,7 @@ function insert(
   key: TokenKey,
   token: string,
   expiresIn: number,
-): void {
+) {
   db.prepare("INSERT OR REPLACE INTO tokens VALUES (?, ?, ?)").run(
     key,
     token,
@@ -82,10 +82,3 @@ export function fetchToken(
     }
   )
 }
-
-export function clearTokens(db: Database.Database): void {
-  db.prepare("DELETE FROM tokens WHERE key in ( ?, ? )").run([
-    "access-token",
-    "refresh-token",
-  ] as TokenKey[])
-}

src/bank/sparebank1.ts

@@ -1,16 +1,17 @@
-import { BANK_INITIAL_REFRESH_TOKEN } from "@/../config.ts"
+import {
+  BANK_INITIAL_REFRESH_TOKEN,
+  TRANSACTION_RELATIVE_FROM_DATE,
+  TRANSACTION_RELATIVE_TO_DATE,
+} from "@/../config.ts"
 import logger from "@/logger.ts"
-import dayjs, { Dayjs } from "dayjs"
+import dayjs from "dayjs"
 import { Database } from "better-sqlite3"
 import {
-  clearTokens,
   fetchToken,
   insertTokens,
   type TokenResponse,
 } from "@/bank/db/queries.ts"
 import * as Api from "./sparebank1Api.ts"
-import { ActualTransaction } from "@/actual.ts"
-import { bankTransactionIntoActualTransaction } from "@/mappings.ts"
 
 export interface OAuthTokenResponse {
   access_token: string
@@ -26,12 +27,8 @@ export type BookingStatus = "PENDING" | "BOOKED"
 export interface Transaction {
   id: string
   nonUniqueId: string
-  // The Id of the account
-  accountKey: string
-  // Unix time
-  date: number
-  // Amount in NOK
-  amount: number
+  date: number // Unix time
+  amount: number // Amount in NOK
   cleanedDescription: string
   remoteAccountName: string
   bookingStatus: BookingStatus
@@ -44,15 +41,9 @@ export interface TransactionResponse {
 }
 
 export interface Bank {
-  fetchTransactions: (
-    interval: Interval,
+  transactionsPastDay: (
     ...accountKeys: ReadonlyArray<string>
-  ) => Promise<ReadonlyArray<ActualTransaction>>
-}
-
-export interface Interval {
-  fromDate: Dayjs
-  toDate: Dayjs
+  ) => Promise<TransactionResponse>
 }
 
 export class Sparebank1Impl implements Bank {
@@ -62,19 +53,6 @@ export class Sparebank1Impl implements Bank {
     this.db = db
   }
 
-  async fetchTransactions(
-    interval: Interval,
-    ...accountKeys: ReadonlyArray<string>
-  ): Promise<ReadonlyArray<ActualTransaction>> {
-    const response = await Api.transactions(
-      await this.getAccessToken(),
-      accountKeys,
-      interval,
-    )
-    const sparebankTransactions = response.transactions
-    return sparebankTransactions.map(bankTransactionIntoActualTransaction)
-  }
-
   private async getAccessToken(): Promise<string> {
     const accessToken = fetchToken(this.db, "access-token")
 
@@ -98,21 +76,34 @@ export class Sparebank1Impl implements Bank {
     } else if (this.isValidToken(tokenResponse)) {
       return tokenResponse.token
     }
-    logger.warn("Refresh token expired, deleting tokens from database")
-    clearTokens(this.db)
+    // TODO clear database, if refresh token is invalid, will cause Exceptions on each call
     throw new Error("Refresh token is expired. Create a new one")
   }
 
-  private async fetchNewTokens(): Promise<OAuthTokenResponse> {
+  async fetchNewTokens(): Promise<OAuthTokenResponse> {
     const refreshToken = await this.getRefreshToken()
     const result = await Api.refreshToken(refreshToken)
 
     if (result.status === "failure") {
-      throw new Error(`Failed to fetch refresh token: '${result.data}'`)
+      throw logger.error({
+        err: new Error(`Failed to fetch refresh token: '${result.data}'`),
+      })
     }
     const oAuthToken = result.data
 
     insertTokens(this.db, oAuthToken)
     return oAuthToken
   }
+
+  async transactionsPastDay(
+    ...accountKeys: ReadonlyArray<string>
+  ): Promise<TransactionResponse> {
+    const today = dayjs()
+    const fromDate = today.subtract(TRANSACTION_RELATIVE_FROM_DATE, "days")
+    const toDate = today.subtract(TRANSACTION_RELATIVE_TO_DATE, "days")
+    return await Api.transactions(await this.getAccessToken(), accountKeys, {
+      fromDate,
+      toDate,
+    })
+  }
 }

src/bank/sparebank1Api.ts

@@ -1,12 +1,11 @@
-import { BANK_OAUTH_CLIENT_ID, BANK_OAUTH_CLIENT_SECRET } from "@/../config.ts"
+import { BANK_OAUTH_CLIENT_ID, BANK_OAUTH_CLIENT_SECRET } from "../../config.ts"
 import type {
-  Interval,
   OAuthTokenResponse,
   TransactionResponse,
 } from "@/bank/sparebank1.ts"
 import logger from "@/logger.ts"
+import { type Dayjs } from "dayjs"
 import { toISODateString } from "@/date.ts"
-import * as querystring from "node:querystring"
 
 const baseUrl = "https://api.sparebank1.no"
 
@@ -14,23 +13,32 @@ type Success<T> = { status: "success"; data: T }
 type Failure<T> = { status: "failure"; data: T }
 type Result<OK, Err> = Success<OK> | Failure<Err>
 
-const success = <T>(data: T): Success<T> => ({ status: "success", data: data })
-const failure = <T>(data: T): Failure<T> => ({ status: "failure", data: data })
+function success<T>(data: T): Success<T> {
+  return { status: "success", data: data }
+}
+
+function failure<T>(data: T): Failure<T> {
+  return { status: "failure", data: data }
+}
 
 export async function transactions(
   accessToken: string,
   accountKeys: string | ReadonlyArray<string>,
-  interval?: Interval,
+  timePeriod?: {
+    fromDate: Dayjs
+    toDate: Dayjs
+  },
 ): Promise<TransactionResponse> {
-  const queryString = querystring.stringify({
-    accountKey: accountKeys,
-    ...(interval && {
-      fromDate: toISODateString(interval.fromDate),
-      toDate: toISODateString(interval.toDate),
+  const queries = new URLSearchParams({
+    // TODO allow multiple accountKeys
+    accountKey: typeof accountKeys === "string" ? accountKeys : accountKeys[0],
+    ...(timePeriod && {
+      fromDate: toISODateString(timePeriod.fromDate),
+      toDate: toISODateString(timePeriod.toDate),
     }),
   })
 
-  const url = `${baseUrl}/personal/banking/transactions?${queryString}`
+  const url = `${baseUrl}/personal/banking/transactions?${queries}`
   logger.debug(`Sending GET request to '${url}'`)
   const response = await fetch(url, {
     headers: {
@@ -50,7 +58,7 @@ export async function transactions(
 export async function refreshToken(
   refreshToken: string,
 ): Promise<Result<OAuthTokenResponse, string>> {
-  const queries = querystring.stringify({
+  const queries = new URLSearchParams({
     client_id: BANK_OAUTH_CLIENT_ID,
     client_secret: BANK_OAUTH_CLIENT_SECRET,
     refresh_token: refreshToken,

src/fs.ts

@@ -1,13 +0,0 @@
-import * as fs from "node:fs"
-import logger from "./logger"
-
-export function createDirsIfMissing(...directories: string[]): void {
-  directories.forEach(createDirIfMissing)
-}
-
-export function createDirIfMissing(directory: string): void {
-  if (!fs.existsSync(directory)) {
-    logger.info(`Missing '${directory}', creating...`)
-    fs.mkdirSync(directory, { recursive: true })
-  }
-}

src/logger.ts

@@ -4,14 +4,6 @@ import { LOG_LEVEL } from "../config.ts"
 /**
  * / Returns a logging instance with the default log-level "info"
  */
-const logger = pino(
-  pino.destination({
-    level: LOG_LEVEL,
-  }),
-)
-
-console.log = function (...args): void {
-  logger.info(args, args?.[0])
-}
-
-export default logger
+export default pino({
+  level: LOG_LEVEL,
+})

src/main.ts

@@ -1,67 +1,73 @@
 import { type Actual, ActualImpl } from "@/actual.ts"
 import { cronJobDaily } from "@/cron.ts"
-import { type Bank, type Interval, Sparebank1Impl } from "@/bank/sparebank1.ts"
 import {
+  type Bank,
+  Sparebank1Impl,
+  type Transaction,
+} from "@/bank/sparebank1.ts"
+import { bankTransactionIntoActualTransaction } from "@/mappings.ts"
+import {
+  ACTUAL_ACCOUNT_IDS,
   ACTUAL_DATA_DIR,
   BANK_ACCOUNT_IDS,
   DB_DIRECTORY,
   DB_FILENAME,
-  TRANSACTION_RELATIVE_FROM_DATE,
-  TRANSACTION_RELATIVE_TO_DATE,
 } from "../config.ts"
 import logger from "@/logger.ts"
 import type { UUID } from "node:crypto"
 import { createDb } from "@/bank/db/queries.ts"
+import * as fs from "node:fs"
 import { CronJob } from "cron"
-import { createDirsIfMissing } from "@/fs.ts"
-import dayjs from "dayjs"
 
+// TODO Transports api for pino https://github.com/pinojs/pino/blob/HEAD/docs/transports.md
 // TODO move tsx to devDependency. Requires ts support for Node with support for @ alias
+// TODO global exception handler, log and graceful shutdown
 // TODO verbatimSyntax in tsconfig, conflicts with jest
 // TODO multi module project. Main | DAL | Sparebank1 impl
 // TODO store last fetched date in db, and refetch from that date, if app has been offline for some time
-// TODO do not fetch if saturday or sunday
 
 export async function daily(actual: Actual, bank: Bank): Promise<void> {
   // Fetch transactions from the bank
-  const actualTransactions = await bank.fetchTransactions(
-    relativeInterval(),
-    ...BANK_ACCOUNT_IDS,
-  )
-  logger.info(`Fetched ${actualTransactions.length} transactions`)
+  const transactions = await fetchTransactionsFromPastDay(bank)
+  logger.info(`Fetched ${transactions.length} transactions`)
 
-  const transactionsByAccount = Object.groupBy(
+  // TODO multiple accounts
+  const accountId = ACTUAL_ACCOUNT_IDS[0] as UUID
+  const actualTransactions = transactions.map((transaction) =>
+    // TODO move to Bank interface?
+    bankTransactionIntoActualTransaction(transaction, accountId),
+  )
+
+  // TODO Import transactions into Actual
+  //  If multiple accounts, loop over them
+  //  Get account ID from mapper
+
+  const response = await actual.importTransactions(
+    accountId,
     actualTransactions,
-    (transaction) => transaction.account,
-  )
-
-  const responses = await Promise.all(
-    Object.entries(transactionsByAccount).map(([accountId, transactions]) =>
-      actual.importTransactions(accountId as UUID, transactions || []),
-    ),
-  )
-
-  logger.debug(
-    responses.map((response) => ({
-      added: response.added,
-      updated: response.updated,
-    })),
-    "Finished importing transactions",
   )
+  logger.info(`ImportTransactionsResponse=${JSON.stringify(response)}`)
 }
 
-function relativeInterval(): Interval {
-  const today = dayjs()
-  return {
-    fromDate: today.subtract(TRANSACTION_RELATIVE_FROM_DATE, "days"),
-    toDate: today.subtract(TRANSACTION_RELATIVE_TO_DATE, "days"),
+async function fetchTransactionsFromPastDay(
+  bank: Bank,
+): Promise<ReadonlyArray<Transaction>> {
+  const response = await bank.transactionsPastDay(...BANK_ACCOUNT_IDS)
+  return response.transactions
+}
+
+function createDirIfMissing(directory: string): void {
+  if (!fs.existsSync(directory)) {
+    logger.info(`Missing '${directory}', creating...`)
+    fs.mkdirSync(directory, { recursive: true })
   }
 }
 
 async function main(): Promise<void> {
   logger.info("Starting application")
 
-  createDirsIfMissing(ACTUAL_DATA_DIR, DB_DIRECTORY)
+  createDirIfMissing(ACTUAL_DATA_DIR)
+  createDirIfMissing(DB_DIRECTORY)
 
   const actual = await ActualImpl.init()
   const databaseFilePath = `${DB_DIRECTORY}/${DB_FILENAME}.sqlite`
@@ -76,21 +82,14 @@ async function main(): Promise<void> {
 
   let cronJob: CronJob | undefined
   if (process.env.ONCE) {
-    try {
-      return await daily(actual, bank)
-    } finally {
-      await shutdown()
-    }
+    await daily(actual, bank)
+    await shutdown()
+    return
   }
 
   logger.info("Waiting for CRON job to start")
   // TODO init and shutdown resources when job runs?
-  try {
-    cronJob = cronJobDaily(async () => await daily(actual, bank))
-  } catch (exception) {
-    logger.error(exception, "Caught exception at daily job, shutting down!")
-    await shutdown()
-  }
+  cronJob = cronJobDaily(async () => await daily(actual, bank))
 
   async function shutdown(): Promise<void> {
     logger.info("Shutting down, Bye!")

src/mappings.ts

@@ -3,44 +3,27 @@ import type { UUID } from "node:crypto"
 import dayjs from "dayjs"
 import { toISODateString } from "@/date.ts"
 import { type ActualTransaction } from "@/actual.ts"
-import { ACTUAL_ACCOUNT_IDS, BANK_ACCOUNT_IDS } from "../config.ts"
-import logger from "@/logger.ts"
 
 export function bankTransactionIntoActualTransaction(
   transaction: Transaction,
+  accountId: UUID,
 ): ActualTransaction {
   return {
     id: transaction.id,
     // Transactions with the same id will be ignored
     imported_id: transaction.nonUniqueId,
-    account: getActualAccountId(transaction),
+    account: accountId,
     // The value without decimals
-    amount: Math.floor(transaction.amount * 100),
+    amount: transaction.amount * 100,
     date: toISODateString(dayjs(transaction.date)),
     payee_name: transaction.cleanedDescription,
     // TODO if not cleared or nonUniqueId is 0, rerun later
-    cleared: isCleared(transaction),
+    cleared: transaction.bookingStatus === "BOOKED",
   }
 }
 
-export function isCleared(transaction: Transaction): boolean {
-  const id = Number(transaction.nonUniqueId)
-  return transaction.bookingStatus === "BOOKED" && !Number.isNaN(id) && id > 0
-}
-
-function getActualAccountId(transcation: Transaction): UUID {
-  for (
-    let i = 0;
-    i < Math.min(ACTUAL_ACCOUNT_IDS.length, BANK_ACCOUNT_IDS.length);
-    i++
-  ) {
-    if (BANK_ACCOUNT_IDS[i] === transcation.accountKey) {
-      return ACTUAL_ACCOUNT_IDS[i] as UUID
-    }
-  }
-  const error = new Error(
-    "Failed to find ActualAccountId, length of BANK_ACCOUNT_IDS and ACTUAL_ACCOUNT_IDS must match",
-  )
-  logger.error(error)
-  throw error
+// TODO take the account from the bank and match it to the actual account
+//  Use ENV
+export function bankAccountIntoActualAccount(account: string): string {
+  throw new Error("Not implemented")
 }

tests/stubs/bankStub.ts

@@ -1,45 +1,41 @@
 import type {
   Bank,
   BookingStatus,
-  Interval,
-  Transaction,
+  TransactionResponse,
 } from "@/bank/sparebank1.ts"
 import dayjs from "dayjs"
-import { ActualTransaction } from "@/actual.ts"
-import { bankTransactionIntoActualTransaction } from "@/mappings.ts"
 
 export class BankStub implements Bank {
-  async fetchTransactions(
-    _interval: Interval,
+  async transactionsPastDay(
     _accountIds: ReadonlyArray<string> | string,
-  ): Promise<ReadonlyArray<ActualTransaction>> {
+  ): Promise<TransactionResponse> {
     const someFields = {
       date: dayjs("2019-08-20").unix(),
       cleanedDescription: "Test transaction",
       remoteAccountName: "Test account",
       bookingStatus: "BOOKED" as BookingStatus,
-      accountKey: "1",
     }
-    const bankTransactions: ReadonlyArray<Transaction> = [
-      {
-        id: "1",
-        nonUniqueId: "1",
-        amount: 100,
-        ...someFields,
-      },
-      {
-        id: "2",
-        nonUniqueId: "2",
-        amount: 200,
-        ...someFields,
-      },
-      {
-        id: "3",
-        nonUniqueId: "3",
-        amount: -50,
-        ...someFields,
-      },
-    ]
-    return bankTransactions.map(bankTransactionIntoActualTransaction)
+    return {
+      transactions: [
+        {
+          id: "1",
+          nonUniqueId: "1",
+          amount: 100,
+          ...someFields,
+        },
+        {
+          id: "2",
+          nonUniqueId: "2",
+          amount: 200,
+          ...someFields,
+        },
+        {
+          id: "3",
+          nonUniqueId: "3",
+          amount: -50,
+          ...someFields,
+        },
+      ],
+    }
   }
 }