kvitton-cli 0.4.2

package/dist/commands/sync-journal.js

@@ -0,0 +1,490 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import ora from "ora";
+import { FilesystemStorageService, mapBokioEntryToJournalEntry, mapJournalEntryToBokioRequest, journalEntryPath, journalEntryDirFromPath, toYaml, parseYaml, fiscalYearDirName, downloadFilesForEntry, } from "sync";
+import { loadConfig } from "../lib/env";
+import { createBokioClient } from "../lib/client";
+/** File extensions that should be uploaded as documents */
+const UPLOADABLE_EXTENSIONS = [".pdf", ".png", ".jpg", ".jpeg"];
+/** Map file extensions to MIME types */
+const MIME_TYPES = {
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+};
+export async function syncJournalCommand(options) {
+    const cwd = process.cwd();
+    // Load config
+    const spinner = ora("Loading configuration...").start();
+    let config;
+    try {
+        config = loadConfig(cwd);
+        spinner.succeed(`Provider: ${config.provider}`);
+    }
+    catch (error) {
+        spinner.fail(error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+    }
+    // Create client
+    const client = createBokioClient(config);
+    // Validate connection
+    const validateSpinner = ora("Connecting to Bokio...").start();
+    try {
+        const companyInfo = await client.getCompanyInformation();
+        validateSpinner.succeed(`Connected to: ${companyInfo.name}`);
+    }
+    catch (error) {
+        validateSpinner.fail("Failed to connect to Bokio");
+        console.error(error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+    }
+    // Determine which fiscal year(s) to sync
+    const targetYear = options.year
+        ? parseInt(options.year, 10)
+        : options.all
+            ? undefined
+            : new Date().getFullYear();
+    const yearLabel = targetYear ? `FY ${targetYear}` : "all years";
+    console.log(`  Syncing ${yearLabel}...\n`);
+    // Storage for file operations
+    const storage = new FilesystemStorageService(cwd);
+    // Sync chart of accounts first
+    const accountsSpinner = ora("Syncing chart of accounts...").start();
+    const accountsCount = await syncChartOfAccounts(client, storage);
+    accountsSpinner.succeed(`Synced ${accountsCount} accounts`);
+    // Sync journal entries
+    const shouldDownloadFiles = options.downloadFiles !== false;
+    const result = await syncJournalEntries(client, cwd, targetYear, shouldDownloadFiles, (progress) => {
+        process.stdout.write(`\r  Syncing: ${progress.current}/${progress.total} entries`);
+    });
+    const filesDownloadedLine = result.entriesWithFilesDownloaded > 0
+        ? `\n    - Downloaded files for ${result.entriesWithFilesDownloaded}/${result.totalEntries} entries`
+        : "";
+    console.log(`\n
+  Sync complete! (${yearLabel})
+    - ${accountsCount} accounts
+    - ${result.fiscalYearsCount} fiscal year(s)
+    - Downloaded: ${result.totalEntries} entries (${result.newEntries} new, ${result.existingEntries} existing)
+    - Uploaded: ${result.uploadedEntries} local entries${filesDownloadedLine}
+`);
+}
+/**
+ * Create a FileDownloader adapter for BokioClient
+ */
+function createBokioDownloader(client) {
+    return {
+        async getFilesForEntry(journalEntryId) {
+            // Bokio API requires query format: journalEntryId==UUID
+            const response = await client.getUploads({
+                query: `journalEntryId==${journalEntryId}`,
+            });
+            return response.data.map((upload) => ({
+                id: upload.id,
+                contentType: upload.contentType,
+                description: upload.description ?? undefined,
+            }));
+        },
+        async downloadFile(id) {
+            return client.downloadFile(id);
+        },
+    };
+}
+async function syncJournalEntries(client, repoPath, targetYear, downloadFiles, onProgress) {
+    const storage = new FilesystemStorageService(repoPath);
+    // 1. Fetch fiscal years
+    const fiscalYearsResponse = await client.getFiscalYears();
+    const allFiscalYears = fiscalYearsResponse.data;
+    // Filter fiscal years if targeting a specific year
+    const fiscalYears = targetYear
+        ? allFiscalYears.filter((fy) => parseInt(fy.startDate.slice(0, 4), 10) === targetYear)
+        : allFiscalYears;
+    if (targetYear && fiscalYears.length === 0) {
+        console.log(`  No fiscal year found for ${targetYear}`);
+        return {
+            totalEntries: 0,
+            newEntries: 0,
+            existingEntries: 0,
+            uploadedEntries: 0,
+            fiscalYearsCount: 0,
+            entriesWithFilesDownloaded: 0,
+        };
+    }
+    // 2. Fetch all entries with pagination
+    const allEntries = [];
+    let page = 1;
+    const pageSize = 100;
+    // First fetch to get total count
+    const firstPage = await client.getJournalEntries({ page: 1, pageSize: 1 });
+    const totalFromApi = firstPage.pagination.totalItems;
+    onProgress({ current: 0, total: totalFromApi });
+    if (totalFromApi === 0) {
+        await writeFiscalYearsMetadata(storage, fiscalYears);
+        // Even with no entries from API, we might have local entries to upload
+        const uploadedEntries = await uploadLocalEntries(client, storage, repoPath, fiscalYears);
+        return {
+            totalEntries: 0,
+            newEntries: 0,
+            existingEntries: 0,
+            uploadedEntries,
+            fiscalYearsCount: fiscalYears.length,
+            entriesWithFilesDownloaded: 0,
+        };
+    }
+    // Fetch all entries
+    while (true) {
+        const response = await client.getJournalEntries({ page, pageSize });
+        allEntries.push(...response.data);
+        onProgress({ current: allEntries.length, total: totalFromApi });
+        if (!response.pagination.hasNextPage)
+            break;
+        page++;
+    }
+    // 3. Filter entries by target fiscal year(s)
+    const entriesToSync = targetYear
+        ? allEntries.filter((entry) => {
+            const fy = findFiscalYear(entry.date, fiscalYears);
+            return fy !== undefined;
+        })
+        : allEntries;
+    // 4. Write each entry, tracking new vs existing, and download files
+    let newEntries = 0;
+    let existingEntries = 0;
+    let entriesWithFilesDownloaded = 0;
+    const downloader = createBokioDownloader(client);
+    for (const entry of entriesToSync) {
+        const fiscalYear = findFiscalYear(entry.date, allFiscalYears);
+        if (!fiscalYear)
+            continue;
+        const fyYear = parseInt(fiscalYear.startDate.slice(0, 4), 10);
+        const result = await writeJournalEntry(storage, fyYear, entry);
+        if (result.isNew) {
+            newEntries++;
+        }
+        else {
+            existingEntries++;
+        }
+        // Download files for this entry if enabled
+        if (downloadFiles && result.entryDir) {
+            const filesDownloaded = await downloadFilesForEntry({
+                storage,
+                repoPath,
+                entryDir: result.entryDir,
+                journalEntryId: entry.id,
+                downloader,
+                sourceIntegration: "bokio",
+            });
+            if (filesDownloaded > 0) {
+                entriesWithFilesDownloaded++;
+            }
+        }
+    }
+    // 5. Write fiscal year metadata
+    await writeFiscalYearsMetadata(storage, fiscalYears);
+    // 6. Upload local entries without externalId to Bokio
+    const uploadedEntries = await uploadLocalEntries(client, storage, repoPath, fiscalYears);
+    return {
+        totalEntries: entriesToSync.length,
+        newEntries,
+        existingEntries,
+        uploadedEntries,
+        fiscalYearsCount: fiscalYears.length,
+        entriesWithFilesDownloaded,
+    };
+}
+function findFiscalYear(date, fiscalYears) {
+    return fiscalYears.find((fy) => date >= fy.startDate && date <= fy.endDate);
+}
+async function writeJournalEntry(storage, fyYear, entry) {
+    const journalEntry = mapBokioEntryToJournalEntry({
+        id: entry.id,
+        journalEntryNumber: entry.journalEntryNumber,
+        date: entry.date,
+        title: entry.title,
+        items: entry.items.map((item) => ({
+            account: item.account,
+            debit: item.debit,
+            credit: item.credit,
+        })),
+    });
+    const entryPath = journalEntryPath(fyYear, journalEntry.series ?? null, journalEntry.entryNumber, journalEntry.entryDate, journalEntry.description);
+    const entryDir = journalEntryDirFromPath(entryPath);
+    // Check if entry already exists
+    const exists = await storage.exists(entryPath);
+    if (exists) {
+        return { isNew: false, entryDir };
+    }
+    const yamlContent = toYaml(journalEntry);
+    await storage.writeFile(entryPath, yamlContent);
+    return { isNew: true, entryDir };
+}
+async function writeFiscalYearsMetadata(storage, fiscalYears) {
+    for (const fy of fiscalYears) {
+        const fyDir = fiscalYearDirName({ start_date: fy.startDate });
+        const metadataPath = `journal-entries/${fyDir}/_fiscal-year.yaml`;
+        const metadata = {
+            id: fy.id,
+            startDate: fy.startDate,
+            endDate: fy.endDate,
+            status: fy.status,
+        };
+        const yamlContent = toYaml(metadata);
+        await storage.writeFile(metadataPath, yamlContent);
+    }
+}
+/**
+ * Parse journal entry number from Bokio (e.g., "A123" -> { series: "A", entryNumber: 123 })
+ */
+function parseJournalEntryNumber(journalEntryNumber) {
+    const numberMatch = journalEntryNumber.match(/\d+/);
+    const entryNumber = numberMatch ? parseInt(numberMatch[0], 10) : 0;
+    const series = journalEntryNumber.replace(/\d+/g, "") || undefined;
+    return {
+        series: series,
+        entryNumber,
+    };
+}
+/**
+ * List local entries without externalId (not yet synced to provider)
+ */
+async function listLocalEntriesWithoutExternalId(storage, fiscalYears) {
+    const result = [];
+    for (const fy of fiscalYears) {
+        const fyYear = parseInt(fy.startDate.slice(0, 4), 10);
+        const fyDir = `journal-entries/FY-${fyYear}`;
+        try {
+            const directories = await storage.listDirectory(fyDir);
+            for (const dir of directories) {
+                if (dir.type !== "dir" || dir.name.startsWith("_")) {
+                    continue;
+                }
+                const entryPath = `${dir.path}/entry.yaml`;
+                try {
+                    const { content } = await storage.readFile(entryPath);
+                    const entry = parseYaml(content);
+                    // Only include entries without externalId
+                    if (!entry.externalId) {
+                        result.push({
+                            entry,
+                            directoryPath: dir.path,
+                            fiscalYear: fy,
+                        });
+                    }
+                }
+                catch {
+                    // Skip entries that can't be read
+                }
+            }
+        }
+        catch {
+            // Fiscal year directory doesn't exist yet
+        }
+    }
+    return result;
+}
+/**
+ * Upload local entries without externalId to Bokio
+ */
+async function uploadLocalEntries(client, storage, repoPath, fiscalYears) {
+    const localEntries = await listLocalEntriesWithoutExternalId(storage, fiscalYears);
+    let uploadedCount = 0;
+    for (const { entry, directoryPath, fiscalYear } of localEntries) {
+        try {
+            // Upload to Bokio
+            const request = mapJournalEntryToBokioRequest(entry);
+            const bokioEntry = await client.createJournalEntry(request);
+            // Parse series and number from response
+            const parsed = parseJournalEntryNumber(bokioEntry.journalEntryNumber);
+            // Upload any document files in the directory
+            await uploadDocumentsForEntry(client, storage, path.join(repoPath, directoryPath), directoryPath, bokioEntry.id);
+            // Update entry with Bokio metadata (remove legacy fields)
+            const updatedEntry = {
+                ...entry,
+                externalId: bokioEntry.id,
+                series: parsed.series,
+                entryNumber: parsed.entryNumber,
+                sourceIntegration: "bokio",
+                sourceSyncedAt: new Date().toISOString(),
+                // Remove legacy fields by setting to undefined
+                voucherNumber: undefined,
+                voucherSeriesCode: undefined,
+            };
+            // Calculate new directory path
+            const fyYear = parseInt(fiscalYear.startDate.slice(0, 4), 10);
+            const newEntryPath = journalEntryPath(fyYear, updatedEntry.series ?? null, updatedEntry.entryNumber, updatedEntry.entryDate, updatedEntry.description);
+            const newDirPath = journalEntryDirFromPath(newEntryPath);
+            // Write updated entry.yaml
+            const yamlContent = toYaml(updatedEntry);
+            await storage.writeFile(`${directoryPath}/entry.yaml`, yamlContent);
+            // Rename directory if path changed
+            if (directoryPath !== newDirPath) {
+                // Check if target directory already exists
+                const targetExists = await storage.exists(`${newDirPath}/entry.yaml`);
+                if (targetExists) {
+                    console.warn(`  Warning: Cannot rename ${directoryPath} -> ${newDirPath} (target exists)`);
+                }
+                else {
+                    await storage.renameDirectory(directoryPath, newDirPath);
+                }
+            }
+            uploadedCount++;
+            console.log(`  Uploaded: ${entry.description} -> ${bokioEntry.journalEntryNumber}`);
+        }
+        catch (error) {
+            console.error(`  Failed to upload entry: ${entry.description}`, error instanceof Error ? error.message : error);
+        }
+    }
+    // Also retry document uploads for entries that have externalId but failed document upload
+    const retriedDocs = await retryFailedDocumentUploads(client, storage, repoPath, fiscalYears);
+    return uploadedCount + retriedDocs;
+}
+/**
+ * Upload documents for a journal entry and update document.yaml with sourceIntegration/sourceId
+ */
+async function uploadDocumentsForEntry(client, storage, absoluteDirPath, relativeDirPath, journalEntryId) {
+    const files = await fs.readdir(absoluteDirPath);
+    for (const filename of files) {
+        const ext = path.extname(filename).toLowerCase();
+        if (!UPLOADABLE_EXTENSIONS.includes(ext)) {
+            continue;
+        }
+        // Check if already uploaded via document.yaml
+        const docYamlPath = `${relativeDirPath}/document.yaml`;
+        let docMetadata = {};
+        try {
+            const { content } = await storage.readFile(docYamlPath);
+            docMetadata = parseYaml(content);
+            if (docMetadata.sourceIntegration === "bokio" && docMetadata.sourceId) {
+                // Already uploaded to Bokio
+                continue;
+            }
+        }
+        catch {
+            // No document.yaml, proceed with upload
+        }
+        try {
+            const filePath = path.join(absoluteDirPath, filename);
+            let fileBuffer = await fs.readFile(filePath);
+            // Check if file is base64 encoded (stored as text, not binary)
+            // Base64 PDF starts with "JVBERi" (%PDF- encoded)
+            const firstBytes = fileBuffer.subarray(0, 10).toString("utf8");
+            if (firstBytes.startsWith("JVBERi") || firstBytes.match(/^[A-Za-z0-9+/=]+$/)) {
+                // Decode base64
+                const base64Content = fileBuffer.toString("utf8");
+                fileBuffer = Buffer.from(base64Content, "base64");
+            }
+            const mimeType = MIME_TYPES[ext] || "application/octet-stream";
+            const file = new File([fileBuffer], filename, { type: mimeType });
+            const upload = await client.uploadFile({
+                file,
+                filename,
+                journalEntryId,
+            });
+            // Update document.yaml with Bokio source info
+            const updatedDocMetadata = {
+                ...docMetadata,
+                sourceIntegration: "bokio",
+                sourceId: upload.id,
+            };
+            await storage.writeFile(docYamlPath, toYaml(updatedDocMetadata));
+            console.log(`    Uploaded file: ${filename}`);
+        }
+        catch (fileError) {
+            console.warn(`\n  Warning: Failed to upload ${filename}`);
+            if (fileError &&
+                typeof fileError === "object" &&
+                "statusCode" in fileError) {
+                const apiErr = fileError;
+                console.warn(`    Status: ${apiErr.statusCode}`);
+                if (apiErr.response) {
+                    console.warn(`    Response: ${JSON.stringify(apiErr.response)}`);
+                }
+                else if (apiErr.message) {
+                    console.warn(`    Message: ${apiErr.message}`);
+                }
+            }
+            else if (fileError instanceof Error) {
+                console.warn(`    Error: ${fileError.message}`);
+            }
+            else {
+                console.warn(`    Error: ${fileError}`);
+            }
+        }
+    }
+}
+/**
+ * Retry document uploads for entries synced to Bokio but with documents not yet uploaded
+ */
+async function retryFailedDocumentUploads(client, storage, repoPath, fiscalYears) {
+    let retriedCount = 0;
+    for (const fy of fiscalYears) {
+        const fyYear = parseInt(fy.startDate.slice(0, 4), 10);
+        const fyDir = `journal-entries/FY-${fyYear}`;
+        try {
+            const directories = await storage.listDirectory(fyDir);
+            for (const dir of directories) {
+                if (dir.type !== "dir" || dir.name.startsWith("_")) {
+                    continue;
+                }
+                const entryPath = `${dir.path}/entry.yaml`;
+                const docPath = `${dir.path}/document.yaml`;
+                try {
+                    // Check if entry has externalId (already synced to Bokio)
+                    const { content: entryContent } = await storage.readFile(entryPath);
+                    const entry = parseYaml(entryContent);
+                    if (!entry.externalId || entry.sourceIntegration !== "bokio") {
+                        continue; // Not synced to Bokio yet
+                    }
+                    // Check if document.yaml exists and needs upload
+                    try {
+                        const { content: docContent } = await storage.readFile(docPath);
+                        const docMetadata = parseYaml(docContent);
+                        if (docMetadata.sourceIntegration === "bokio" && docMetadata.sourceId) {
+                            continue; // Already uploaded to Bokio
+                        }
+                        // Has document.yaml but not uploaded to Bokio - retry upload
+                        console.log(`\n  Retrying document upload for: ${entry.description}`);
+                        await uploadDocumentsForEntry(client, storage, path.join(repoPath, dir.path), dir.path, entry.externalId);
+                        retriedCount++;
+                    }
+                    catch {
+                        // No document.yaml, check for files to upload
+                        const absoluteDirPath = path.join(repoPath, dir.path);
+                        const files = await fs.readdir(absoluteDirPath);
+                        const hasUploadableFiles = files.some((f) => UPLOADABLE_EXTENSIONS.includes(path.extname(f).toLowerCase()));
+                        if (hasUploadableFiles) {
+                            console.log(`\n  Uploading documents for: ${entry.description}`);
+                            await uploadDocumentsForEntry(client, storage, absoluteDirPath, dir.path, entry.externalId);
+                            retriedCount++;
+                        }
+                    }
+                }
+                catch {
+                    // Skip entries that can't be read
+                }
+            }
+        }
+        catch {
+            // Fiscal year directory doesn't exist
+        }
+    }
+    return retriedCount;
+}
+/**
+ * Sync chart of accounts from Bokio to accounts.yaml
+ */
+async function syncChartOfAccounts(client, storage) {
+    const bokioAccounts = await client.getChartOfAccounts();
+    // Sort by account number and transform to expected format
+    const accounts = [...bokioAccounts]
+        .sort((a, b) => a.account - b.account)
+        .map((account) => ({
+        code: account.account.toString(),
+        name: account.name,
+        description: account.name,
+    }));
+    // Write accounts.yaml
+    const yamlContent = toYaml({ accounts });
+    await storage.writeFile("accounts.yaml", yamlContent);
+    return accounts.length;
+}