@moatless/bookkeeping 0.1.0

package/dist/services/document-download.d.ts

@@ -0,0 +1,46 @@
+import type { IStorageService } from "../storage/interface";
+export interface DocumentMetadata {
+    fileName: string;
+    mimeType?: string;
+    sourceIntegration: string;
+    sourceId: string;
+}
+export interface DownloadableFile {
+    id: string;
+    contentType: string;
+    description?: string;
+}
+export interface FileDownloader {
+    /**
+     * Get files linked to a journal entry
+     * @param journalEntryId - The journal entry ID to filter by
+     * @returns List of downloadable files
+     */
+    getFilesForEntry(journalEntryId: string): Promise<DownloadableFile[]>;
+    /**
+     * Download a file by ID
+     * @param id - The file/upload ID
+     * @returns Binary data and content type
+     */
+    downloadFile(id: string): Promise<{
+        data: ArrayBuffer;
+        contentType: string;
+    }>;
+}
+export interface DownloadFilesOptions {
+    storage: IStorageService;
+    repoPath: string;
+    entryDir: string;
+    journalEntryId: string;
+    downloader: FileDownloader;
+    sourceIntegration: string;
+}
+/**
+ * Download files for a journal entry and save them to documents.yaml
+ * Returns the number of files downloaded
+ */
+export declare function downloadFilesForEntry(options: DownloadFilesOptions): Promise<number>;
+/**
+ * Get extension from MIME type
+ */
+export declare function getExtensionFromMimeType(mimeType: string): string;

package/dist/services/document-download.js

@@ -0,0 +1,105 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { toYaml, parseYaml } from "../utils/yaml";
+/**
+ * Slugify text for filenames
+ */
+function slugify(text, maxLength = 40) {
+    return text
+        .toLowerCase()
+        .slice(0, maxLength)
+        .replace(/[^a-z0-9\s-]/g, "")
+        .replace(/\s+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+/** Map MIME types to file extensions */
+const EXTENSION_MAP = {
+    "application/pdf": ".pdf",
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "image/tiff": ".tiff",
+    "application/octet-stream": ".bin",
+};
+/**
+ * Download files for a journal entry and save them to documents.yaml
+ * Returns the number of files downloaded
+ */
+export async function downloadFilesForEntry(options) {
+    const { storage, repoPath, entryDir, journalEntryId, downloader, sourceIntegration } = options;
+    // Get files linked to this journal entry
+    const linkedFiles = await downloader.getFilesForEntry(journalEntryId);
+    if (linkedFiles.length === 0) {
+        return 0;
+    }
+    // Load existing documents.yaml if present
+    const documentsPath = `${entryDir}/documents.yaml`;
+    let existingDocs = [];
+    try {
+        const { content } = await storage.readFile(documentsPath);
+        existingDocs = parseYaml(content) || [];
+    }
+    catch {
+        // documents.yaml doesn't exist yet
+    }
+    // Track which sourceIds are already downloaded
+    const downloadedSourceIds = new Set(existingDocs
+        .filter((d) => d.sourceIntegration === sourceIntegration)
+        .map((d) => d.sourceId));
+    let filesDownloaded = 0;
+    const absoluteDir = path.join(repoPath, entryDir);
+    // Ensure directory exists
+    await fs.mkdir(absoluteDir, { recursive: true });
+    for (const file of linkedFiles) {
+        // Skip if already downloaded
+        if (downloadedSourceIds.has(file.id)) {
+            continue;
+        }
+        try {
+            // Download the file
+            const result = await downloader.downloadFile(file.id);
+            // Determine extension from content type
+            const ext = EXTENSION_MAP[file.contentType || result.contentType] || ".bin";
+            // Generate filename from description or ID (never use generic "document")
+            const baseName = file.description
+                ? slugify(file.description)
+                : file.id.slice(0, 8);
+            const existingFilenames = existingDocs.map((d) => d.fileName);
+            let filename = `${baseName}${ext}`;
+            let counter = 1;
+            while (existingFilenames.includes(filename)) {
+                filename = `${baseName}-${counter}${ext}`;
+                counter++;
+            }
+            // Save file
+            const filePath = path.join(absoluteDir, filename);
+            const buffer = Buffer.from(result.data);
+            await fs.writeFile(filePath, buffer);
+            // Add to documents list
+            existingDocs.push({
+                fileName: filename,
+                mimeType: file.contentType || result.contentType,
+                sourceIntegration,
+                sourceId: file.id,
+            });
+            filesDownloaded++;
+        }
+        catch (error) {
+            // Log but continue with other files
+            console.error(`\n  Warning: Failed to download file ${file.id}: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    // Write updated documents.yaml if any files were downloaded
+    if (filesDownloaded > 0) {
+        await storage.writeFile(documentsPath, toYaml(existingDocs));
+    }
+    return filesDownloaded;
+}
+/**
+ * Get extension from MIME type
+ */
+export function getExtensionFromMimeType(mimeType) {
+    return EXTENSION_MAP[mimeType] || ".bin";
+}

package/dist/services/fortnox-inbox.d.ts

@@ -0,0 +1,18 @@
+import type { FortnoxClient } from "@moatless/fortnox-client";
+import type { FilesystemStorageService } from "../storage/filesystem";
+export interface FortnoxInboxSyncProgress {
+    current: number;
+    total: number;
+    message?: string;
+}
+export interface FortnoxInboxSyncOptions {
+    onProgress?: (progress: FortnoxInboxSyncProgress) => void;
+}
+export interface FortnoxInboxSyncResult {
+    newCount: number;
+    existingCount: number;
+}
+/**
+ * Sync inbox files from Fortnox to local filesystem
+ */
+export declare function syncFortnoxInbox(client: FortnoxClient, storage: FilesystemStorageService, options?: FortnoxInboxSyncOptions): Promise<FortnoxInboxSyncResult>;

package/dist/services/fortnox-inbox.js

@@ -0,0 +1,150 @@
+import { toYaml, parseYaml } from "../utils/yaml";
+/**
+ * Slugify text for terminal-friendly filenames
+ */
+function slugify(text, maxLength = 30) {
+    return text
+        .toLowerCase()
+        .slice(0, maxLength)
+        .replace(/[^a-z0-9\s-]/g, "")
+        .replace(/\s+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+function _getExtensionFromContentType(contentType) {
+    const map = {
+        "application/pdf": ".pdf",
+        "image/jpeg": ".jpg",
+        "image/png": ".png",
+        "image/gif": ".gif",
+        "image/webp": ".webp",
+        "image/tiff": ".tiff",
+        "application/octet-stream": ".bin",
+    };
+    return map[contentType] || ".bin";
+}
+/**
+ * Check if a file was already downloaded by scanning existing documents.yaml files
+ */
+async function isAlreadyDownloaded(storage, inboxDir, sourceId) {
+    try {
+        const entries = await storage.listDirectory(inboxDir);
+        for (const entry of entries) {
+            if (entry.type !== "dir")
+                continue;
+            const documentsPath = `${inboxDir}/${entry.name}/documents.yaml`;
+            try {
+                const fileContent = await storage.readFile(documentsPath);
+                if (fileContent?.content) {
+                    const documents = parseYaml(fileContent.content);
+                    if (documents?.some((doc) => doc.sourceId === sourceId)) {
+                        return true;
+                    }
+                }
+            }
+            catch {
+                // documents.yaml doesn't exist or can't be read, skip
+            }
+        }
+    }
+    catch {
+        // Inbox directory doesn't exist
+    }
+    return false;
+}
+/**
+ * Sync inbox files from Fortnox to local filesystem
+ */
+export async function syncFortnoxInbox(client, storage, options = {}) {
+    const { onProgress = () => { } } = options;
+    // Fetch inbox files
+    const allFiles = [];
+    // Get root inbox
+    const rootResponse = await client.getInboxFiles();
+    const rootFiles = rootResponse.Folder?.Files ?? rootResponse.Files ?? [];
+    const folders = rootResponse.Folder?.Folders ?? [];
+    allFiles.push(...rootFiles);
+    // Fetch files from each folder
+    if (Array.isArray(folders)) {
+        for (const folder of folders) {
+            if (folder?.Id) {
+                try {
+                    const folderResponse = await client.getInboxFolder(folder.Id);
+                    const folderFiles = folderResponse.Folder?.Files ?? folderResponse.Files ?? [];
+                    allFiles.push(...folderFiles);
+                }
+                catch {
+                    // Skip folders that can't be read
+                }
+            }
+        }
+    }
+    const totalFiles = allFiles.length;
+    onProgress({ current: 0, total: totalFiles, message: "Fetching inbox files..." });
+    if (totalFiles === 0) {
+        return { newCount: 0, existingCount: 0 };
+    }
+    // Download each file
+    let newCount = 0;
+    let existingCount = 0;
+    const today = new Date().toISOString().slice(0, 10);
+    // Track used directory names to handle duplicates
+    const usedDirNames = new Set();
+    // First, scan existing directories
+    try {
+        const entries = await storage.listDirectory("inbox");
+        for (const entry of entries) {
+            if (entry.type === "dir") {
+                usedDirNames.add(entry.name);
+            }
+        }
+    }
+    catch {
+        // Inbox directory doesn't exist yet
+    }
+    for (const file of allFiles) {
+        // Check if this file was already downloaded
+        const alreadyDownloaded = await isAlreadyDownloaded(storage, "inbox", file.Id);
+        if (alreadyDownloaded) {
+            existingCount++;
+            onProgress({ current: newCount + existingCount, total: totalFiles });
+            continue;
+        }
+        // Generate directory name from filename
+        const baseName = file.Name.replace(/\.[^/.]+$/, ""); // Remove extension
+        const slug = slugify(baseName) || file.Id.slice(0, 8);
+        let dirName = `${today}-${slug}`;
+        // Handle duplicate directory names
+        if (usedDirNames.has(dirName)) {
+            dirName = `${dirName}-${file.Id.slice(0, 8)}`;
+        }
+        usedDirNames.add(dirName);
+        const uploadDir = `inbox/${dirName}`;
+        try {
+            // Download file
+            const result = await client.downloadFromInbox(file.Id);
+            // Use original filename
+            const filename = file.Name;
+            // Save file
+            const filePath = `${uploadDir}/${filename}`;
+            await storage.writeBinaryFile(filePath, Buffer.from(result.data));
+            // Write documents.yaml
+            const documents = [
+                {
+                    fileName: filename,
+                    mimeType: result.contentType,
+                    sourceIntegration: "fortnox",
+                    sourceId: file.Id,
+                },
+            ];
+            const documentsPath = `${uploadDir}/documents.yaml`;
+            await storage.writeFile(documentsPath, toYaml(documents));
+            newCount++;
+        }
+        catch {
+            // Skip files that can't be downloaded
+        }
+        onProgress({ current: newCount + existingCount, total: totalFiles });
+    }
+    return { newCount, existingCount };
+}

package/dist/services/fortnox-journal.d.ts

@@ -0,0 +1,22 @@
+import type { FortnoxClient } from "@moatless/fortnox-client";
+import type { FilesystemStorageService } from "../storage/filesystem";
+export interface FortnoxSyncProgress {
+    current: number;
+    total: number;
+    message?: string;
+    phase?: "discovering" | "fetching";
+}
+export interface FortnoxJournalSyncOptions {
+    downloadFiles?: boolean;
+    targetYear?: number;
+    onProgress?: (progress: FortnoxSyncProgress) => void;
+}
+export interface FortnoxJournalSyncResult {
+    entriesCount: number;
+    fiscalYearsCount: number;
+    entriesWithFilesDownloaded: number;
+}
+export declare function syncFortnoxJournalEntries(client: FortnoxClient, storage: FilesystemStorageService, options?: FortnoxJournalSyncOptions): Promise<FortnoxJournalSyncResult>;
+export declare function syncFortnoxChartOfAccounts(client: FortnoxClient, storage: FilesystemStorageService): Promise<{
+    accountsCount: number;
+}>;

package/dist/services/fortnox-journal.js

@@ -0,0 +1,166 @@
+import { fiscalYearDirName } from "../utils/file-namer";
+import { toYaml } from "../utils/yaml";
+import { mapFortnoxVoucherToJournalEntry } from "../transformers/fortnox";
+import { JournalService } from "./journal.service";
+export async function syncFortnoxJournalEntries(client, storage, options = {}) {
+    const { downloadFiles = false, targetYear, onProgress = () => { } } = options;
+    const journalService = new JournalService(storage);
+    // 1. Fetch fiscal years
+    const fiscalYearsResponse = await client.getFinancialYears();
+    const allFiscalYears = fiscalYearsResponse.data;
+    // Filter fiscal years if targeting a specific year
+    const fiscalYears = targetYear
+        ? allFiscalYears.filter((fy) => parseInt(fy.FromDate.slice(0, 4), 10) === targetYear)
+        : allFiscalYears;
+    if (targetYear && fiscalYears.length === 0) {
+        return {
+            entriesCount: 0,
+            fiscalYearsCount: 0,
+            entriesWithFilesDownloaded: 0,
+        };
+    }
+    // 2. Fetch voucher list for each fiscal year
+    const voucherRefs = [];
+    const existingEntriesByYear = new Map();
+    for (const fy of fiscalYears) {
+        const fyYear = fy.Id;
+        const pathYear = parseInt(fy.FromDate.slice(0, 4), 10);
+        const existingRecords = await journalService.listJournalEntryRecords(pathYear);
+        existingEntriesByYear.set(pathYear, existingRecords);
+        let hasMore = true;
+        let page = 1;
+        while (hasMore) {
+            const response = await client.getVouchers(fyYear, { page, pageSize: 100 });
+            for (const voucher of response.data) {
+                voucherRefs.push({
+                    series: voucher.VoucherSeries,
+                    number: voucher.VoucherNumber ?? 0,
+                    year: voucher.Year ?? fyYear,
+                    fiscalYear: fy,
+                    pathYear,
+                });
+            }
+            hasMore = response.pagination.hasNextPage;
+            page++;
+            // Report discovery progress
+            onProgress({
+                current: voucherRefs.length,
+                total: 0,
+                message: "Discovering entries...",
+                phase: "discovering",
+            });
+        }
+    }
+    const totalEntries = voucherRefs.length;
+    onProgress({ current: 0, total: totalEntries, message: "Fetching entry details...", phase: "fetching" });
+    if (totalEntries === 0) {
+        await writeFortnoxFiscalYearsMetadata(storage, fiscalYears);
+        return {
+            entriesCount: 0,
+            fiscalYearsCount: fiscalYears.length,
+            entriesWithFilesDownloaded: 0,
+        };
+    }
+    // 3. Fetch full voucher details and write entries
+    const entryDirs = new Map();
+    const allVouchers = [];
+    let processed = 0;
+    for (const ref of voucherRefs) {
+        // Fetch full voucher with VoucherRows
+        const fullVoucherResponse = await client.getVoucher(ref.series, ref.number, ref.year);
+        const voucher = fullVoucherResponse.Voucher;
+        const journalEntry = mapFortnoxVoucherToJournalEntry(voucher);
+        const entryKey = journalEntry.externalId ??
+            `${journalEntry.series ?? ""}-${journalEntry.entryNumber}`;
+        const existingRecords = existingEntriesByYear.get(ref.pathYear);
+        const existingRecord = existingRecords?.get(entryKey);
+        const result = await journalService.upsertJournalEntry(ref.pathYear, journalEntry, existingRecord);
+        const entryDir = result.entryDir;
+        const entryId = `${voucher.VoucherSeries}-${voucher.VoucherNumber ?? 0}-${voucher.Year ?? 0}`;
+        entryDirs.set(entryId, entryDir);
+        allVouchers.push({ voucher, fiscalYear: ref.fiscalYear });
+        processed++;
+        onProgress({ current: processed, total: totalEntries, phase: "fetching" });
+    }
+    // 4. Write fiscal year metadata
+    await writeFortnoxFiscalYearsMetadata(storage, fiscalYears);
+    // 5. Download files for entries (if enabled)
+    let entriesWithFilesDownloaded = 0;
+    if (downloadFiles) {
+        for (const { voucher } of allVouchers) {
+            const entryId = `${voucher.VoucherSeries}-${voucher.VoucherNumber ?? 0}-${voucher.Year ?? 0}`;
+            const entryDir = entryDirs.get(entryId);
+            if (!entryDir)
+                continue;
+            try {
+                const connections = await client.getVoucherFileConnectionsForVoucher(voucher.VoucherSeries, voucher.VoucherNumber ?? 0, voucher.Year ?? 0);
+                for (const conn of connections) {
+                    try {
+                        const fileResult = await client.downloadFromArchive(conn.FileId);
+                        const filename = `attachment-${conn.FileId}.${getFortnoxExtension(fileResult.contentType)}`;
+                        const filePath = `${entryDir}/${filename}`;
+                        await storage.writeBinaryFile(filePath, Buffer.from(fileResult.data));
+                        entriesWithFilesDownloaded++;
+                    }
+                    catch {
+                        // Skip file download errors
+                    }
+                }
+            }
+            catch {
+                // Skip if can't get file connections
+            }
+        }
+    }
+    return {
+        entriesCount: allVouchers.length,
+        fiscalYearsCount: fiscalYears.length,
+        entriesWithFilesDownloaded,
+    };
+}
+export async function syncFortnoxChartOfAccounts(client, storage) {
+    // Fetch all accounts with pagination
+    const allAccounts = [];
+    let hasMore = true;
+    let page = 1;
+    while (hasMore) {
+        const response = await client.getAccounts({ page, pageSize: 500 });
+        for (const account of response.data) {
+            allAccounts.push({
+                code: account.Number.toString(),
+                name: account.Description,
+                description: account.Description,
+            });
+        }
+        hasMore = response.pagination.hasNextPage;
+        page++;
+    }
+    // Sort by account number
+    allAccounts.sort((a, b) => parseInt(a.code, 10) - parseInt(b.code, 10));
+    // Write accounts.yaml
+    const yamlContent = toYaml({ accounts: allAccounts });
+    await storage.writeFile("accounts.yaml", yamlContent);
+    return { accountsCount: allAccounts.length };
+}
+function getFortnoxExtension(contentType) {
+    const map = {
+        "application/pdf": "pdf",
+        "image/jpeg": "jpg",
+        "image/png": "png",
+        "image/gif": "gif",
+    };
+    return map[contentType] ?? "bin";
+}
+async function writeFortnoxFiscalYearsMetadata(storage, fiscalYears) {
+    for (const fy of fiscalYears) {
+        const fyDir = fiscalYearDirName({ start_date: fy.FromDate });
+        const metadataPath = `journal-entries/${fyDir}/_fiscal-year.yaml`;
+        const metadata = {
+            id: fy.Id,
+            startDate: fy.FromDate,
+            endDate: fy.ToDate,
+        };
+        const yamlContent = toYaml(metadata);
+        await storage.writeFile(metadataPath, yamlContent);
+    }
+}

package/dist/services/index.d.ts

@@ -0,0 +1,6 @@
+export { JournalService } from "./journal.service";
+export { syncJournalEntries, type SyncJournalConfig, } from "./journal-sync";
+export { downloadFilesForEntry, getExtensionFromMimeType, type DocumentMetadata, type DownloadableFile, type FileDownloader, type DownloadFilesOptions, } from "./document-download";
+export { syncFortnoxJournalEntries, syncFortnoxChartOfAccounts, type FortnoxSyncProgress, type FortnoxJournalSyncOptions, type FortnoxJournalSyncResult, } from "./fortnox-journal";
+export { syncFortnoxInbox, type FortnoxInboxSyncProgress, type FortnoxInboxSyncOptions, type FortnoxInboxSyncResult, } from "./fortnox-inbox";
+export { syncBokioJournalEntries, syncBokioChartOfAccounts, type BokioSyncProgress, type BokioJournalSyncOptions, type BokioJournalSyncResult, } from "./bokio-journal";

package/dist/services/index.js

@@ -0,0 +1,6 @@
+export { JournalService } from "./journal.service";
+export { syncJournalEntries, } from "./journal-sync";
+export { downloadFilesForEntry, getExtensionFromMimeType, } from "./document-download";
+export { syncFortnoxJournalEntries, syncFortnoxChartOfAccounts, } from "./fortnox-journal";
+export { syncFortnoxInbox, } from "./fortnox-inbox";
+export { syncBokioJournalEntries, syncBokioChartOfAccounts, } from "./bokio-journal";

package/dist/services/journal-sync.d.ts

@@ -0,0 +1,23 @@
+import type { FortnoxClient } from "@moatless/fortnox-client";
+import type { IStorageService } from "../storage/interface";
+import type { SyncJournalResult, FiscalYearInfo } from "../sync-types";
+/**
+ * Sync configuration for journal entries
+ */
+export interface SyncJournalConfig {
+    storage: IStorageService;
+    fortnoxClient: FortnoxClient;
+    organizationId: string;
+    financialYears: FiscalYearInfo[];
+    /** Optional logger */
+    log?: {
+        info: (data: object, msg: string) => void;
+        warn: (data: object, msg: string) => void;
+        error: (data: object, msg: string) => void;
+    };
+}
+/**
+ * Sync journal entries from Fortnox to storage
+ * Returns detailed stats grouped by fiscal year
+ */
+export declare function syncJournalEntries(config: SyncJournalConfig): Promise<SyncJournalResult>;

package/dist/services/journal-sync.js

@@ -0,0 +1,124 @@
+import { JournalService } from "./journal.service";
+import { mapFortnoxVoucherToJournalEntry } from "../transformers/fortnox";
+/**
+ * Default console logger
+ */
+const defaultLog = {
+    info: (data, msg) => console.log(`[INFO] ${msg}`, data),
+    warn: (data, msg) => console.warn(`[WARN] ${msg}`, data),
+    error: (data, msg) => console.error(`[ERROR] ${msg}`, data),
+};
+/**
+ * Sync journal entries from Fortnox to storage
+ * Returns detailed stats grouped by fiscal year
+ */
+export async function syncJournalEntries(config) {
+    const startTime = Date.now();
+    const { storage, fortnoxClient, organizationId, financialYears } = config;
+    const log = config.log ?? defaultLog;
+    const journalService = new JournalService(storage);
+    const fiscalYearStats = [];
+    const errors = [];
+    log.info({ organizationId, financialYears }, "Starting journal entries sync");
+    for (const fy of financialYears) {
+        const { externalId: fortnoxYearId, year } = fy;
+        const stats = {
+            year,
+            fetched: 0,
+            created: 0,
+            updated: 0,
+            unchanged: 0,
+            failed: 0,
+        };
+        try {
+            // Get existing entries from storage (uses calendar year for paths)
+            log.info({ year, fortnoxYearId }, "Loading existing entries from storage");
+            const existingEntries = await journalService.listJournalEntryRecords(year);
+            log.info({ year, existingCount: existingEntries.size }, "Loaded existing entries");
+            // Fetch all vouchers from Fortnox (uses Fortnox external ID)
+            log.info({ year, fortnoxYearId }, "Fetching vouchers from Fortnox");
+            const allVouchers = [];
+            let page = 1;
+            const pageSize = 100;
+            let hasNextPage = true;
+            while (hasNextPage) {
+                const response = await fortnoxClient.getVouchers(fortnoxYearId, { page, pageSize });
+                allVouchers.push(...response.data);
+                if (!response.pagination.hasNextPage) {
+                    hasNextPage = false;
+                }
+                else {
+                    page++;
+                }
+            }
+            stats.fetched = allVouchers.length;
+            log.info({ year, fetched: allVouchers.length }, "Fetched vouchers from Fortnox");
+            // Process each voucher
+            for (const voucherSummary of allVouchers) {
+                if (!voucherSummary.VoucherNumber) {
+                    log.warn({ voucherSeries: voucherSummary.VoucherSeries }, "Skipping voucher without number");
+                    stats.failed++;
+                    continue;
+                }
+                const externalId = `${voucherSummary.VoucherSeries}-${voucherSummary.VoucherNumber}`;
+                try {
+                    // Get full voucher details (list response doesn't include rows)
+                    const fullVoucherResponse = await fortnoxClient.getVoucher(voucherSummary.VoucherSeries, voucherSummary.VoucherNumber, fortnoxYearId);
+                    if (!fullVoucherResponse.Voucher) {
+                        log.warn({ externalId }, "Voucher not found");
+                        stats.failed++;
+                        continue;
+                    }
+                    const newEntry = mapFortnoxVoucherToJournalEntry(fullVoucherResponse.Voucher, year);
+                    const entryKey = newEntry.externalId ??
+                        `${newEntry.series ?? ""}-${newEntry.entryNumber}`;
+                    const existingRecord = existingEntries.get(entryKey);
+                    const result = await journalService.upsertJournalEntry(year, newEntry, existingRecord);
+                    if (result.action === "created") {
+                        stats.created++;
+                        log.info({ externalId }, "Created journal entry");
+                    }
+                    else if (result.action === "updated") {
+                        stats.updated++;
+                        log.info({ externalId }, "Updated journal entry");
+                    }
+                    else {
+                        stats.unchanged++;
+                    }
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : "Unknown error";
+                    log.error({ externalId, error: message }, "Failed to process voucher");
+                    errors.push({ year, externalId, message });
+                    stats.failed++;
+                }
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "Unknown error";
+            log.error({ year, error: message }, "Failed to sync fiscal year");
+            errors.push({ year, externalId: "*", message });
+            stats.failed++;
+        }
+        fiscalYearStats.push(stats);
+        log.info({ year, stats }, "Completed fiscal year sync");
+    }
+    // Calculate totals
+    const totals = fiscalYearStats.reduce((acc, fy) => ({
+        fetched: acc.fetched + fy.fetched,
+        created: acc.created + fy.created,
+        updated: acc.updated + fy.updated,
+        unchanged: acc.unchanged + fy.unchanged,
+        failed: acc.failed + fy.failed,
+    }), { fetched: 0, created: 0, updated: 0, unchanged: 0, failed: 0 });
+    const durationMs = Date.now() - startTime;
+    const success = errors.length === 0;
+    log.info({ organizationId, totals, errors: errors.length, durationMs }, "Journal entries sync completed");
+    return {
+        success,
+        fiscalYears: fiscalYearStats,
+        totals,
+        errors,
+        durationMs,
+    };
+}