@rubydogjp/openkk-client-domain 26.1.12 → 26.2.0

package/dist/entries/import-export.js

@@ -1,31 +1,29 @@
+import { entryToVisualPairs, resolveEntryPairMetadata, } from "./entry-record.js";
 import { AppError } from "../shared/app-error.js";
-import { parseIsoLocalDate, weekdayJa } from "../shared/parse-utils.js";
+import { formatBusinessRatePercent, parseBusinessRate, parseIsoLocalDate, weekdayJa, } from "../shared/parse-utils.js";
+import { assertEntryLineCount, assertEntryImportItemCount, assertEntryImportLineCount, assertEntryImportSize, } from "./entry-limits.js";
+export { assertEntryImportSize, MAX_ENTRY_LINES, MAX_ENTRY_IMPORT_ITEMS, MAX_ENTRY_IMPORT_LINES, MAX_ENTRY_IMPORT_SIZE, } from "./entry-limits.js";
 export const OPENKK_JOURNAL_SCHEMA = "openkk-journal-v1";
 export function exportEntriesAsJson(entries) {
     return JSON.stringify({
         schema: OPENKK_JOURNAL_SCHEMA,
-        entries: entries.map((entry) => ({
-            localId: entry.localId ?? entry.id,
-            date: entry.date,
-            weekday: entry.weekday,
-            debit: entry.debit,
-            debitType: entry.debitType,
-            debitAmount: entry.debitAmount,
-            credit: entry.credit,
-            creditType: entry.creditType,
-            creditAmount: entry.creditAmount,
-            description: entry.description,
-            partner: entry.partner,
-            businessRate: entry.businessRate,
-            taxCategory: entry.taxCategory,
-            businessCategory: entry.businessCategory,
-            ...(entry.lines != null && entry.lines.length > 0
-                ? { lines: entry.lines.map((line) => ({ ...line })) }
-                : {}),
-        })),
+        entries: entries.map((entry) => {
+            const fields = journalFields(entry);
+            return {
+                localId: entry.localId ?? entry.id,
+                date: entry.date,
+                weekday: entry.weekday,
+                ...fields,
+                description: entry.description,
+                businessRate: formatBusinessRatePercent(entry.businessRate),
+                businessRateRatio: entry.businessRate,
+                lines: entry.lines.map((line) => ({ ...line })),
+            };
+        }),
     }, null, 2);
 }
 export function importEntriesFromJson(input) {
+    assertEntryImportSize(input.text.length);
     const parsed = parseEntriesJson(input.text);
     if (parsed.schema != null &&
         parsed.schema !== "" &&
@@ -35,34 +33,42 @@ export function importEntriesFromJson(input) {
     if (!Array.isArray(parsed.entries)) {
         throw importFileFormatError("entries array not found");
     }
+    assertEntryImportItemCount(parsed.entries.length);
     const seenLocalIds = new Set();
+    let importLineCount = 0;
     return parsed.entries.map((raw, index) => {
-        const entry = raw;
         const rowNo = index + 1;
+        if (!isRecord(raw)) {
+            throw importFileRowError(`row ${rowNo}: entry must be an object`, rowNo);
+        }
+        const entry = raw;
         const localId = validateRequiredLocalId(typeof entry.localId === "string" ? entry.localId : "", rowNo, seenLocalIds);
-        return normalizeEntry({
+        const normalized = normalizeEntry({
             fiscalPeriodId: input.fiscalPeriodId,
             id: `entry-${input.fiscalPeriodId}-json-${index + 1}`,
             rowNo,
             localId,
-            date: entry.date,
-            weekday: entry.weekday,
-            debit: entry.debit,
-            debitType: entry.debitType,
-            debitAmount: entry.debitAmount,
-            credit: entry.credit,
-            creditType: entry.creditType,
-            creditAmount: entry.creditAmount,
-            description: entry.description,
-            partner: entry.partner,
-            businessRate: entry.businessRate,
-            taxCategory: entry.taxCategory,
-            businessCategory: entry.businessCategory,
-            lines: Array.isArray(entry.lines) ? entry.lines : undefined,
+            date: stringValue(entry.date),
+            debit: stringValue(entry.debit),
+            debitType: stringValue(entry.debitType),
+            debitAmount: stringValue(entry.debitAmount),
+            credit: stringValue(entry.credit),
+            creditType: stringValue(entry.creditType),
+            creditAmount: stringValue(entry.creditAmount),
+            description: stringValue(entry.description),
+            partner: stringValue(entry.partner),
+            businessRate: stringValue(entry.businessRate),
+            businessRateRatio: entry.businessRateRatio ?? null,
+            taxCategory: stringValue(entry.taxCategory),
+            businessCategory: stringValue(entry.businessCategory),
+            lines: validateJsonLines(entry.lines, rowNo),
         });
+        importLineCount += normalized.lines.length;
+        assertEntryImportLineCount(importLineCount);
+        return normalized;
     });
 }
-const csvHeaders = [
+const journalCsvDataHeaders = [
     "localId",
     "date",
     "weekday",
@@ -75,31 +81,67 @@ const csvHeaders = [
     "description",
     "partner",
     "businessRate",
+    "businessRateRatio",
     "taxCategory",
     "businessCategory",
     "lines",
 ];
+const csvHeaders = [
+    ...journalCsvDataHeaders,
+    "openkkSchema",
+    "openkkEscapedFields",
+];
+const OPENKK_JOURNAL_CSV_SCHEMA = "openkk-journal-csv-v1";
+function journalFields(entry) {
+    const pair = entryToVisualPairs(entry)[0] ?? {
+        debit: null,
+        credit: null,
+    };
+    return {
+        debit: pair.debit?.accountName ?? "",
+        debitType: pair.debit?.accountType ?? "asset",
+        debitAmount: pair.debit?.amount ?? "",
+        credit: pair.credit?.accountName ?? "",
+        creditType: pair.credit?.accountType ?? "asset",
+        creditAmount: pair.credit?.amount ?? "",
+        ...resolveEntryPairMetadata(pair),
+    };
+}
 export function exportEntriesAsCsv(entries) {
     const lines = [csvHeaders.join(",")];
     for (const entry of entries) {
-        lines.push([
+        const fields = journalFields(entry);
+        const rawValues = [
             entry.localId ?? entry.id,
             entry.date,
             entry.weekday,
-            entry.debit,
-            entry.debitType,
-            entry.debitAmount,
-            entry.credit,
-            entry.creditType,
-            entry.creditAmount,
+            fields.debit,
+            fields.debitType,
+            fields.debitAmount,
+            fields.credit,
+            fields.creditType,
+            fields.creditAmount,
             entry.description,
-            entry.partner,
-            entry.businessRate,
-            entry.taxCategory,
-            entry.businessCategory,
-            entry.lines != null && entry.lines.length > 0
-                ? JSON.stringify(entry.lines)
-                : "",
+            fields.partner,
+            formatBusinessRatePercent(entry.businessRate),
+            String(entry.businessRate),
+            fields.taxCategory,
+            fields.businessCategory,
+            JSON.stringify(entry.lines),
+        ];
+        const escapedFields = [];
+        const safeValues = rawValues.map((value, index) => {
+            if (!needsSpreadsheetFormulaProtection(value))
+                return value;
+            const fieldName = journalCsvDataHeaders[index];
+            if (fieldName != null)
+                escapedFields.push(fieldName);
+            return `'${value}`;
+        });
+        lines.push([
+            ...safeValues,
+            OPENKK_JOURNAL_CSV_SCHEMA,
+            JSON.stringify(escapedFields),
         ]
             .map(escapeCsvField)
             .join(","));
@@ -107,44 +149,69 @@ export function exportEntriesAsCsv(entries) {
     return lines.join("\n");
 }
 export function importEntriesFromCsv(input) {
+    assertEntryImportSize(input.text.length);
     const rows = parseCsv(stripBom(input.text));
-    if (rows.length < 2) {
-        return [];
-    }
     const header = rows[0] ?? [];
     const indexMap = Object.fromEntries(csvHeaders.map((name) => [name, header.indexOf(name)]));
-    if (indexMap.date < 0 || indexMap.debit < 0 || indexMap.credit < 0) {
-        throw importFileFormatError("CSV header missing required columns: date, debit, credit");
+    if (indexMap.localId < 0 ||
+        indexMap.date < 0 ||
+        indexMap.debit < 0 ||
+        indexMap.credit < 0) {
+        throw importFileFormatError("CSV header missing required columns: localId, date, debit, credit");
     }
+    if (rows.length < 2)
+        return [];
+    assertEntryImportItemCount(rows.length - 1);
     const seenLocalIds = new Set();
+    let importLineCount = 0;
     return rows.slice(1).map((cells, index) => {
         const rowNo = index + 2;
-        const localId = validateRequiredLocalId(readCsvCell(cells, indexMap.localId), rowNo, seenLocalIds);
-        return normalizeEntry({
+        const escapedFields = parseCsvEscapedFields(cells, indexMap, rowNo);
+        const read = (field) => readJournalCsvCell(cells, indexMap[field], escapedFields.has(field));
+        const localId = validateRequiredLocalId(read("localId"), rowNo, seenLocalIds);
+        const normalized = normalizeEntry({
             fiscalPeriodId: input.fiscalPeriodId,
             id: `entry-${input.fiscalPeriodId}-csv-${index + 1}`,
             rowNo,
             localId,
-            date: readCsvCell(cells, indexMap.date),
-            weekday: readCsvCell(cells, indexMap.weekday),
-            debit: readCsvCell(cells, indexMap.debit),
-            debitType: readCsvCell(cells, indexMap.debitType),
-            debitAmount: readCsvCell(cells, indexMap.debitAmount),
-            credit: readCsvCell(cells, indexMap.credit),
-            creditType: readCsvCell(cells, indexMap.creditType),
-            creditAmount: readCsvCell(cells, indexMap.creditAmount),
-            description: readCsvCell(cells, indexMap.description),
-            partner: readCsvCell(cells, indexMap.partner),
-            businessRate: readCsvCell(cells, indexMap.businessRate),
-            taxCategory: readCsvCell(cells, indexMap.taxCategory),
-            businessCategory: readCsvCell(cells, indexMap.businessCategory),
-            lines: parseCsvLinesCell(readCsvCell(cells, indexMap.lines), rowNo),
+            date: read("date"),
+            debit: read("debit"),
+            debitType: read("debitType"),
+            debitAmount: read("debitAmount"),
+            credit: read("credit"),
+            creditType: read("creditType"),
+            creditAmount: read("creditAmount"),
+            description: read("description"),
+            partner: read("partner"),
+            businessRate: read("businessRate"),
+            businessRateRatio: read("businessRateRatio"),
+            taxCategory: read("taxCategory"),
+            businessCategory: read("businessCategory"),
+            lines: parseCsvLinesCell(read("lines"), rowNo),
         });
+        importLineCount += normalized.lines.length;
+        assertEntryImportLineCount(importLineCount);
+        return normalized;
     });
 }
+export function decodeJournalImportBytes(bytes) {
+    assertEntryImportSize(bytes.byteLength);
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch (error) {
+        throw new AppError({
+            messageForDeveloper: "entries import is not valid UTF-8",
+            messageForUser: "取込ファイルの文字コードを確認できませんでした。UTF-8形式で保存してからもう一度取り込んでください。",
+            originalMessage: error instanceof Error ? error.message : String(error),
+            statusCode: null,
+            code: null,
+        });
+    }
+}
 function parseCsvLinesCell(raw, rowNo) {
     if (raw.trim() === "")
-        return undefined;
+        return [];
     let parsed;
     try {
         parsed = JSON.parse(raw);
@@ -161,42 +228,100 @@ function normalizeEntry(input) {
     if (parseIsoLocalDate(input.date) == null) {
         throw importFileRowError(`row ${input.rowNo}: invalid date (${input.date})`, input.rowNo);
     }
-    return {
+    const partner = input.partner.trim();
+    const taxCategory = input.taxCategory.trim() || "対象外";
+    const businessCategory = input.businessCategory.trim() || "対象外";
+    const importedLines = normalizeLines(input.lines, input.rowNo);
+    const lines = importedLines.length > 0
+        ? importedLines
+        : [
+            pairInputToLine("debit", input),
+            pairInputToLine("credit", input),
+        ].map((line) => ({
+            ...line,
+            partnerName: partner === "" ? null : partner,
+            taxCategoryName: taxCategory,
+            businessCategoryName: businessCategory,
+        }));
+    const result = {
         id: input.id,
         localId: input.localId,
         fiscalPeriodId: input.fiscalPeriodId,
         date: input.date,
-        weekday: input.weekday && input.weekday.length > 0
-            ? input.weekday
-            : weekdayFromDate(input.date),
-        debit: input.debit || "未設定",
-        debitType: normalizeType(input.debitType),
-        debitAmount: normalizeAmount(input.debitAmount),
-        credit: input.credit || "未設定",
-        creditType: normalizeType(input.creditType),
-        creditAmount: normalizeAmount(input.creditAmount),
+        weekday: weekdayFromDate(input.date),
         description: input.description || "",
-        partner: input.partner || "",
-        businessRate: input.businessRate || "100",
-        taxCategory: input.taxCategory || "対象外",
-        businessCategory: input.businessCategory || "対象外",
-        lines: normalizeLines(input.lines),
+        businessRate: importedBusinessRate(input),
+        lines,
     };
+    assertNormalizedEntry(result, input.rowNo);
+    return result;
 }
-function normalizeLines(lines) {
-    if (lines == null || lines.length === 0)
-        return undefined;
-    return lines.map((line) => ({
-        side: line.side === "credit" ? "credit" : "debit",
-        accountName: line.accountName || "未設定",
-        accountType: normalizeType(line.accountType),
-        amount: normalizeAmount(line.amount),
-        ...(line.bookAccountId != null && line.bookAccountId.length > 0
-            ? { bookAccountId: line.bookAccountId }
-            : {}),
-    }));
+function pairInputToLine(side, input) {
+    const debit = side === "debit";
+    return {
+        id: null,
+        side,
+        accountName: (debit ? input.debit : input.credit).trim(),
+        accountType: normalizeType(debit ? input.debitType : input.creditType, input.rowNo, `${side} type`),
+        amount: normalizeAmount(debit ? input.debitAmount : input.creditAmount, input.rowNo, `${side} amount`),
+        bookAccountId: null,
+        partnerName: null,
+        taxCategoryId: null,
+        taxCategoryName: null,
+        businessCategoryId: null,
+        businessCategoryName: null,
+    };
 }
-function normalizeType(value) {
+function importedBusinessRate(input) {
+    const ratio = input.businessRateRatio;
+    if (ratio == null || ratio === "") {
+        return parseBusinessRate(input.businessRate);
+    }
+    const rate = typeof ratio === "number"
+        ? ratio
+        : typeof ratio === "string"
+            ? Number(ratio.trim())
+            : Number.NaN;
+    if (!Number.isFinite(rate) || rate < 0 || rate > 1) {
+        throw importFileRowError(`row ${input.rowNo}: invalid businessRateRatio`, input.rowNo);
+    }
+    return rate;
+}
+function normalizeLines(lines, rowNo) {
+    assertEntryLineCount(lines.length);
+    return lines.map((line, index) => {
+        if (!isRecord(line)) {
+            throw importFileRowError(`row ${rowNo}: line ${index + 1} must be an object`, rowNo);
+        }
+        if (line.side !== "debit" && line.side !== "credit") {
+            throw importFileRowError(`row ${rowNo}: line ${index + 1} has invalid side`, rowNo);
+        }
+        const accountName = stringValue(line.accountName).trim();
+        if (accountName === "") {
+            throw importFileRowError(`row ${rowNo}: line ${index + 1} account is required`, rowNo);
+        }
+        const bookAccountId = stringValue(line.bookAccountId).trim();
+        const partnerName = stringValue(line.partnerName).trim();
+        const taxCategoryId = stringValue(line.taxCategoryId).trim();
+        const taxCategoryName = stringValue(line.taxCategoryName).trim();
+        const businessCategoryId = stringValue(line.businessCategoryId).trim();
+        const businessCategoryName = stringValue(line.businessCategoryName).trim();
+        return {
+            side: line.side,
+            accountName,
+            accountType: normalizeType(stringValue(line.accountType), rowNo, `line ${index + 1} account type`),
+            amount: normalizeAmount(stringValue(line.amount), rowNo, `line ${index + 1} amount`),
+            id: null,
+            bookAccountId: bookAccountId === "" ? null : bookAccountId,
+            partnerName: partnerName === "" ? null : partnerName,
+            taxCategoryId: taxCategoryId === "" ? null : taxCategoryId,
+            taxCategoryName: taxCategoryName === "" ? null : taxCategoryName,
+            businessCategoryId: businessCategoryId === "" ? null : businessCategoryId,
+            businessCategoryName: businessCategoryName === "" ? null : businessCategoryName,
+        };
+    });
+}
+function normalizeType(value, rowNo, label) {
     if (value === "asset" ||
         value === "liability" ||
         value === "equity" ||
@@ -205,38 +330,83 @@ function normalizeType(value) {
         value === "expense") {
         return value;
     }
-    return "asset";
+    if (value.trim() === "")
+        return "asset";
+    throw importFileRowError(`row ${rowNo}: invalid ${label} (${value})`, rowNo);
 }
-function normalizeAmount(value) {
+function normalizeAmount(value, rowNo, label) {
     const n = Number(String(value).replaceAll(",", "").trim());
-    if (!Number.isFinite(n))
-        return "0";
+    if (!Number.isSafeInteger(n) || n < 0) {
+        throw importFileRowError(`row ${rowNo}: invalid ${label} (${value})`, rowNo);
+    }
     return n.toLocaleString("ja-JP");
 }
 function weekdayFromDate(dateText) {
     return weekdayJa(dateText) || "月";
 }
 function escapeCsvField(value) {
-    if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+    if (value.includes(",") ||
+        value.includes('"') ||
+        value.includes("\n") ||
+        value.includes("\r")) {
         return `"${value.replaceAll('"', '""')}"`;
     }
     return value;
 }
+function needsSpreadsheetFormulaProtection(value) {
+    return /^[=+\-@\t\r\n]/.test(value);
+}
+function parseCsvEscapedFields(cells, indexMap, rowNo) {
+    if (readCsvCell(cells, indexMap.openkkSchema) !== OPENKK_JOURNAL_CSV_SCHEMA) {
+        return new Set();
+    }
+    const raw = readCsvCell(cells, indexMap.openkkEscapedFields);
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw importFileRowError(`row ${rowNo}: invalid escaped fields metadata`, rowNo);
+    }
+    if (!Array.isArray(parsed) ||
+        parsed.some((field) => !isJournalCsvDataHeader(field))) {
+        throw importFileRowError(`row ${rowNo}: invalid escaped fields metadata`, rowNo);
+    }
+    return new Set(parsed);
+}
+function isJournalCsvDataHeader(value) {
+    return (typeof value === "string" &&
+        journalCsvDataHeaders.includes(value));
+}
+function readJournalCsvCell(cells, index, formulaProtected) {
+    const value = readCsvCell(cells, index);
+    return formulaProtected && value.startsWith("'") ? value.slice(1) : value;
+}
 function parseCsv(text) {
     const rows = [];
     let row = [];
     let field = "";
-    let inQuotes = false;
+    let state = "start";
+    const finishField = () => {
+        row.push(field);
+        field = "";
+        state = "start";
+    };
+    const finishRow = () => {
+        finishField();
+        rows.push(row);
+        row = [];
+    };
     for (let i = 0; i < text.length; i += 1) {
         const ch = text[i];
-        if (inQuotes) {
+        if (state === "quoted") {
             if (ch === '"') {
                 if (text[i + 1] === '"') {
                     field += '"';
                     i += 1;
                 }
                 else {
-                    inQuotes = false;
+                    state = "after_quote";
                 }
             }
             else {
@@ -244,30 +414,95 @@ function parseCsv(text) {
             }
             continue;
         }
+        const isLineBreak = ch === "\n" || ch === "\r";
+        if (state === "after_quote") {
+            if (ch === ",") {
+                finishField();
+                continue;
+            }
+            if (isLineBreak) {
+                finishRow();
+                if (ch === "\r" && text[i + 1] === "\n")
+                    i += 1;
+                continue;
+            }
+            throw importFileFormatError("CSV has an unexpected character after a closing quote");
+        }
         if (ch === '"') {
-            inQuotes = true;
+            if (state !== "start") {
+                throw importFileFormatError("CSV has an unexpected quote in an unquoted field");
+            }
+            state = "quoted";
             continue;
         }
         if (ch === ",") {
-            row.push(field);
-            field = "";
+            finishField();
             continue;
         }
-        if (ch === "\n") {
-            row.push(field);
-            rows.push(row);
-            row = [];
-            field = "";
+        if (isLineBreak) {
+            finishRow();
+            if (ch === "\r" && text[i + 1] === "\n")
+                i += 1;
             continue;
         }
-        if (ch !== "\r") {
-            field += ch;
-        }
+        field += ch;
+        state = "unquoted";
+    }
+    if (state === "quoted") {
+        throw importFileFormatError("CSV has an unterminated quoted field");
     }
-    row.push(field);
-    rows.push(row);
+    finishRow();
     return rows.filter((r) => r.some((v) => v.trim().length > 0));
 }
+function validateJsonLines(value, rowNo) {
+    if (value == null)
+        return [];
+    if (!Array.isArray(value)) {
+        throw importFileRowError(`row ${rowNo}: lines must be an array`, rowNo);
+    }
+    return value;
+}
+function assertNormalizedEntry(entry, rowNo) {
+    if (entry.description.trim() === "") {
+        throw importFileRowError(`row ${rowNo}: description is required`, rowNo);
+    }
+    for (const line of entry.lines) {
+        if (line.accountName.trim() === "") {
+            throw importFileRowError(`row ${rowNo}: account is required`, rowNo);
+        }
+    }
+    let debitTotal = 0;
+    let creditTotal = 0;
+    for (const line of entry.lines) {
+        const amount = numericAmount(line.amount);
+        if (line.side === "debit")
+            debitTotal += amount;
+        else
+            creditTotal += amount;
+        if (!Number.isSafeInteger(debitTotal) ||
+            !Number.isSafeInteger(creditTotal)) {
+            throw importFileRowError(`row ${rowNo}: entry totals exceed the safe integer range`, rowNo);
+        }
+    }
+    if (debitTotal <= 0 || creditTotal <= 0 || debitTotal !== creditTotal) {
+        throw importFileRowError(`row ${rowNo}: debit and credit totals must be positive and equal`, rowNo);
+    }
+    const rate = entry.businessRate;
+    if (!Number.isFinite(rate) || rate < 0 || rate > 1) {
+        throw importFileRowError(`row ${rowNo}: invalid business rate`, rowNo);
+    }
+}
+function numericAmount(value) {
+    return Number(value.replaceAll(",", ""));
+}
+function isRecord(value) {
+    return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" || typeof value === "number"
+        ? String(value)
+        : "";
+}
 function readCsvCell(cells, index) {
     if (index < 0)
         return "";
@@ -289,7 +524,11 @@ function stripBom(text) {
 }
 function parseEntriesJson(text) {
     try {
-        return JSON.parse(stripBom(text));
+        const parsed = JSON.parse(stripBom(text));
+        if (!isRecord(parsed)) {
+            throw new Error("journal JSON root must be an object");
+        }
+        return parsed;
     }
     catch (error) {
         throw new AppError({
@@ -297,6 +536,7 @@ function parseEntriesJson(text) {
             messageForUser: "JSONファイルの内容を確認できませんでした。ファイルの形式を確認してください。",
             originalMessage: error instanceof Error ? error.message : String(error),
             statusCode: null,
+            code: null,
         });
     }
 }
@@ -306,6 +546,7 @@ function importFileFormatError(messageForDeveloper) {
         messageForUser: "取込ファイルの形式を確認できませんでした。オープン会計で書き出したCSVまたはJSONを選択してください。",
         originalMessage: null,
         statusCode: null,
+        code: null,
     });
 }
 function importFileRowError(messageForDeveloper, rowNo) {
@@ -314,6 +555,7 @@ function importFileRowError(messageForDeveloper, rowNo) {
         messageForUser: `${rowNo}行目の取引データを確認できませんでした。ファイルの内容を修正してからもう一度取り込んでください。`,
         originalMessage: null,
         statusCode: null,
+        code: null,
     });
 }
 //# sourceMappingURL=import-export.js.map