kassza 0.12.0 → 0.14.0

package/dist/journal/index.cjs

@@ -0,0 +1,454 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_errors = require("../errors-EE96_6D_.cjs");
+const require_once = require("../once-BN_3B5OF.cjs");
+const require_dates = require("../dates-CPgBodkP.cjs");
+//#region src/journal/dates.ts
+const MAX_JOURNAL_RANGE_DAYS = 366;
+const DAY_IN_MS = 864e5;
+function invalid(message) {
+	return new require_errors.SzamlazzError(message, { category: "validation" });
+}
+function parseDay(value, field) {
+	try {
+		return require_dates.toAgentDate(value);
+	} catch {
+		throw invalid(`A napló ${field} dátuma YYYY-MM-DD formájú legyen, kapott: ${value}`);
+	}
+}
+function dayNumber(day) {
+	return Date.parse(`${day}T00:00:00Z`) / DAY_IN_MS;
+}
+function normalizeRange(range) {
+	const from = parseDay(range.from, "from");
+	const to = parseDay(range.to, "to");
+	const span = dayNumber(to) - dayNumber(from) + 1;
+	if (span < 1) throw invalid(`A napló időszakának kezdete (${from}) később van, mint a vége (${to}).`);
+	if (span > 366) throw invalid(`A napló egyszerre legfeljebb 366 napot kérdez le, kapott: ${span} nap.`);
+	return {
+		from,
+		to
+	};
+}
+function daysOf(range) {
+	const { from, to } = normalizeRange(range);
+	const days = [];
+	const last = dayNumber(to);
+	for (let day = dayNumber(from); day <= last; day++) days.push((/* @__PURE__ */ new Date(day * DAY_IN_MS)).toISOString().slice(0, 10));
+	return days;
+}
+function inRange(day, range) {
+	return day >= range.from && day <= range.to;
+}
+function recentRange(now, days) {
+	return {
+		from: require_dates.addBudapestDays(now, -(days - 1)),
+		to: require_dates.toAgentDate(now)
+	};
+}
+//#endregion
+//#region src/journal/entries.ts
+function withoutPdf(receipt) {
+	if (receipt.pdf === void 0) return receipt;
+	const { pdf: _pdf, ...rest } = receipt;
+	return rest;
+}
+function compact(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== void 0));
+}
+function inputDate(value, fallback) {
+	if (value instanceof Date || typeof value === "string") try {
+		return require_dates.toAgentDate(value);
+	} catch {
+		return fallback;
+	}
+	return fallback;
+}
+function receiptEntry(receipt, source, now) {
+	const reversal = receipt.type === "reversal";
+	return compact({
+		kind: "receipt",
+		type: reversal ? "reversal" : "document",
+		number: receipt.number,
+		date: inputDate(receipt.issueDate, require_dates.toAgentDate(now)),
+		recordedAt: require_dates.toBudapestTimestamp(now),
+		source,
+		orderNumber: receipt.orderNumber,
+		reversedNumber: reversal ? receipt.reversedReceiptNumber : void 0,
+		netTotal: receipt.totals.netAmount,
+		grossTotal: receipt.totals.grossAmount,
+		currency: receipt.currency,
+		isTest: receipt.isTest,
+		receipt: withoutPdf(receipt)
+	});
+}
+function invoiceDetailsEntry(details, source, now) {
+	const reversal = details.header.type === "reversal";
+	return compact({
+		kind: "invoice",
+		type: reversal ? "reversal" : "document",
+		number: details.header.number,
+		date: inputDate(details.header.issueDate, require_dates.toAgentDate(now)),
+		recordedAt: require_dates.toBudapestTimestamp(now),
+		source,
+		orderNumber: details.header.orderNumber,
+		reversedNumber: reversal ? details.header.referencedInvoiceNumber : void 0,
+		netTotal: details.totals.netAmount,
+		grossTotal: details.totals.grossAmount,
+		currency: details.header.currency,
+		isTest: details.header.test
+	});
+}
+function invoiceResultEntry(result, orderNumber, source, now) {
+	if (result.details) return invoiceDetailsEntry(result.details, source, now);
+	return compact({
+		kind: "invoice",
+		type: "document",
+		number: result.number,
+		date: require_dates.toAgentDate(now),
+		recordedAt: require_dates.toBudapestTimestamp(now),
+		source,
+		orderNumber,
+		netTotal: result.invoice?.netTotal,
+		grossTotal: result.invoice?.grossTotal
+	});
+}
+function eventEntry(event, now) {
+	const today = require_dates.toAgentDate(now);
+	const recordedAt = require_dates.toBudapestTimestamp(now);
+	if (event.kind === "receipt") return receiptEntry(event.document, "hook", now);
+	if (event.action === "payment") return void 0;
+	if (event.action === "created") return compact({
+		kind: "invoice",
+		type: "document",
+		number: event.number,
+		date: inputDate(event.input.issueDate, today),
+		recordedAt,
+		source: "hook",
+		orderNumber: event.input.orderNumber?.trim() || void 0,
+		netTotal: event.document.netTotal,
+		grossTotal: event.document.grossTotal,
+		currency: event.input.currency
+	});
+	return compact({
+		kind: "invoice",
+		type: "reversal",
+		number: event.number,
+		date: today,
+		recordedAt,
+		source: "hook",
+		reversedNumber: event.reversedNumber,
+		netTotal: event.document.netTotal,
+		grossTotal: event.document.grossTotal
+	});
+}
+//#endregion
+//#region src/journal/journal.ts
+const DEFAULT_PENDING_DAYS = 30;
+var JournalWriteError = class extends Error {
+	name = "JournalWriteError";
+	result;
+	orderNumber;
+	constructor(orderNumber, result, cause) {
+		super(`A(z) ${orderNumber} rendelés bizonylata elkészült, de a naplóba írás nem sikerült. A tétel befejezetlenként a naplóban maradt: a journal.settle() később pótolja. Ne állítsd ki újra a bizonylatot.`, { cause });
+		this.orderNumber = orderNumber;
+		this.result = result;
+	}
+};
+function requireOrderNumber(orderNumber) {
+	const trimmed = orderNumber?.trim();
+	if (!trimmed) throw new require_errors.SzamlazzError("A naplóhoz add meg a rendelésszámot (orderNumber).", { category: "validation" });
+	return trimmed;
+}
+const UNSETTLED_CATEGORIES = /* @__PURE__ */ new Set(["in_progress", "store_unavailable"]);
+function isDefinitelyNotCreated(error) {
+	if (!(error instanceof require_errors.SzamlazzError)) return false;
+	return !require_once.isUncertainOutcome(error) && !UNSETTLED_CATEGORIES.has(error.category) && error.details?.outcome !== "unknown";
+}
+function archivedReceipt(item) {
+	return "receipt" in item && typeof item.receipt === "object" ? item.receipt : item;
+}
+function archiveRange(receipts) {
+	const dates = receipts.map((receipt) => receipt.issueDate).filter((date) => /^\d{4}-\d{2}-\d{2}$/.test(date));
+	if (dates.length === 0) return void 0;
+	const sorted = [...dates].sort();
+	return {
+		from: sorted[0],
+		to: sorted[sorted.length - 1]
+	};
+}
+function createJournal(storage, options = {}) {
+	const now = options.now ?? (() => /* @__PURE__ */ new Date());
+	const put = (entry) => entry ? storage.putEntry(entry) : Promise.resolve(false);
+	async function reserve(kind, orderNumber) {
+		const current = now();
+		return storage.putReservation({
+			kind,
+			orderNumber: requireOrderNumber(orderNumber),
+			date: require_dates.toAgentDate(current),
+			reservedAt: require_dates.toBudapestTimestamp(current)
+		});
+	}
+	async function release(kind, orderNumber) {
+		await storage.deleteReservation(kind, requireOrderNumber(orderNumber));
+	}
+	async function track(kind, orderNumber, run, entryOf) {
+		const order = requireOrderNumber(orderNumber);
+		const ownsReservation = await reserve(kind, order);
+		let result;
+		try {
+			result = await run();
+		} catch (error) {
+			if (ownsReservation && isDefinitelyNotCreated(error)) await storage.deleteReservation(kind, order);
+			throw error;
+		}
+		try {
+			await storage.putEntry(entryOf(result));
+			await storage.deleteReservation(kind, order);
+		} catch (error) {
+			throw new JournalWriteError(order, result, error);
+		}
+		return result;
+	}
+	async function settleOne(api, reservation) {
+		if (reservation.kind === "receipt") {
+			if (!api.receipts) throw new TypeError("A nyugták rendezéséhez add meg a receipts API-t.");
+			const receipt = await api.receipts.find({
+				orderNumber: reservation.orderNumber,
+				downloadPdf: false
+			});
+			if (!receipt) return "notFound";
+			await storage.putEntry(receiptEntry(receipt, "settle", now()));
+			return "recorded";
+		}
+		if (!api.invoices) throw new TypeError("A számlák rendezéséhez add meg az invoices API-t.");
+		const details = await api.invoices.find({ orderNumber: reservation.orderNumber });
+		if (!details) return "notFound";
+		await storage.putEntry(invoiceDetailsEntry(details, "settle", now()));
+		return "recorded";
+	}
+	const journal = {
+		storage,
+		async record(event) {
+			await put(eventEntry(event, now()));
+		},
+		recordReceipt: (receipt) => storage.putEntry(receiptEntry(receipt, "manual", now())),
+		recordInvoice: (details) => storage.putEntry(invoiceDetailsEntry(details, "manual", now())),
+		reserve,
+		release,
+		trackReceipt: (orderNumber, run) => track("receipt", orderNumber, run, (result) => receiptEntry("receipt" in result ? result.receipt : result, "track", now())),
+		trackInvoice: (orderNumber, run) => track("invoice", orderNumber, run, (result) => invoiceResultEntry(result, requireOrderNumber(orderNumber), "track", now())),
+		async entries(query) {
+			return (await storage.listEntries(normalizeRange(query))).filter((entry) => query.kind === void 0 || entry.kind === query.kind).sort((a, b) => a.date.localeCompare(b.date) || a.number.localeCompare(b.number, "hu"));
+		},
+		async receipts(query) {
+			return (await journal.entries({
+				...query,
+				kind: "receipt"
+			})).map((entry) => entry.receipt).filter((receipt) => receipt !== void 0).filter((receipt) => query.includeTest === true || !receipt.isTest);
+		},
+		async pending(range) {
+			return storage.listReservations(range ?? recentRange(now(), 30));
+		},
+		async settle(api, settleOptions = {}) {
+			const reservations = await journal.pending(settleOptions.range);
+			const recorded = [];
+			const notFound = [];
+			const failed = [];
+			for (const reservation of reservations) try {
+				const outcome = await settleOne(api, reservation);
+				if (outcome === "recorded" || settleOptions.releaseNotFound === true) await storage.deleteReservation(reservation.kind, reservation.orderNumber);
+				if (outcome === "recorded") recorded.push(reservation);
+				else notFound.push(reservation);
+			} catch (error) {
+				failed.push({
+					reservation,
+					error
+				});
+			}
+			return {
+				recorded,
+				notFound,
+				failed
+			};
+		},
+		async reconcile(archive, reconcileOptions = {}) {
+			const receipts = archive.map(archivedReceipt);
+			const derived = archiveRange(receipts);
+			const range = reconcileOptions.from !== void 0 || reconcileOptions.to !== void 0 ? normalizeRange({
+				from: reconcileOptions.from ?? derived?.from ?? reconcileOptions.to ?? "",
+				to: reconcileOptions.to ?? derived?.to ?? reconcileOptions.from ?? ""
+			}) : derived;
+			const journaled = range ? await journal.entries({
+				...range,
+				kind: "receipt"
+			}) : [];
+			const known = new Set(journaled.map((entry) => entry.number));
+			const archived = /* @__PURE__ */ new Set();
+			const added = [];
+			for (const receipt of receipts) {
+				if (archived.has(receipt.number)) continue;
+				archived.add(receipt.number);
+				if (range && !inRange(receipt.issueDate, range)) continue;
+				if (known.has(receipt.number)) continue;
+				if (reconcileOptions.dryRun !== true) await storage.putEntry(receiptEntry(receipt, "reconcile", now()));
+				added.push(receipt.number);
+			}
+			const missingFromArchive = journaled.map((entry) => entry.number).filter((number) => !archived.has(number));
+			return {
+				range,
+				added,
+				missingFromArchive,
+				matched: journaled.length - missingFromArchive.length
+			};
+		}
+	};
+	return journal;
+}
+//#endregion
+//#region src/journal/storage.ts
+const JOURNAL_KEY_PREFIX = "szamlazz:journal:";
+const DEFAULT_JOURNAL_RETENTION_DAYS = 400;
+const DEFAULT_RESERVATION_TTL_DAYS = 30;
+const DAY_IN_SECONDS = 86400;
+const READ_BATCH = 50;
+function configurationError(message) {
+	return new require_errors.SzamlazzError(message, { category: "configuration" });
+}
+function positiveDays(value, fallback, field) {
+	if (value === void 0) return fallback;
+	if (!Number.isFinite(value) || value < 1) throw configurationError(`A(z) ${field} legalább 1 nap legyen, kapott: ${String(value)}`);
+	return Math.ceil(value);
+}
+function parseJson(value, guard) {
+	if (typeof value !== "string" || value === "") return void 0;
+	try {
+		const parsed = JSON.parse(value);
+		return guard(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function isEntry(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const entry = value;
+	return (entry.kind === "invoice" || entry.kind === "receipt") && typeof entry.number === "string" && typeof entry.date === "string";
+}
+function isReservation(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const reservation = value;
+	return (reservation.kind === "invoice" || reservation.kind === "receipt") && typeof reservation.orderNumber === "string" && typeof reservation.date === "string";
+}
+function slotTarget(value) {
+	if (typeof value !== "string") return void 0;
+	const separator = value.indexOf(":");
+	if (separator <= 0) return void 0;
+	const kind = value.slice(0, separator);
+	if (kind !== "invoice" && kind !== "receipt") return void 0;
+	return [kind, value.slice(separator + 1)];
+}
+async function inBatches(items, run) {
+	const results = [];
+	for (let index = 0; index < items.length; index += READ_BATCH) results.push(...await Promise.all(items.slice(index, index + READ_BATCH).map(run)));
+	return results;
+}
+function kvJournal(store, options = {}) {
+	const increment = store.increment?.bind(store);
+	if (!increment) throw configurationError("A naplóhoz olyan tároló kell, amely atomikusan tud számlálót növelni (increment), különben párhuzamos írásnál bejegyzés veszhet el. Használd a kassza/stores Redis, Upstash vagy Durable Object tárolóját. A Cloudflare KV erre nem alkalmas.");
+	const prefix = options.prefix ?? "szamlazz:journal:";
+	const retention = positiveDays(options.retentionDays, 400, "retentionDays") * DAY_IN_SECONDS;
+	const reservationTtl = positiveDays(options.reservationTtlDays, 30, "reservationTtlDays") * DAY_IN_SECONDS;
+	const entryKey = (kind, number) => `${prefix}entry:${kind}:${number}`;
+	const reservationKey = (kind, orderNumber) => `${prefix}reservation:${kind}:${orderNumber}`;
+	async function appendToDay(index, day, target, ttl) {
+		const slot = await increment?.(`${prefix}${index}:${day}:count`, ttl);
+		await store.set(`${prefix}${index}:${day}:${slot}`, target, ttl);
+	}
+	async function slotsOf(index, range) {
+		const targets = [];
+		for (const day of daysOf(range)) {
+			const count = Number.parseInt(await store.get(`${prefix}${index}:${day}:count`) ?? "0", 10);
+			if (!Number.isInteger(count) || count < 1) continue;
+			const slots = Array.from({ length: count }, (_, slot) => `${prefix}${index}:${day}:${slot + 1}`);
+			for (const value of await inBatches(slots, async (key) => store.get(key))) if (typeof value === "string") targets.push(value);
+		}
+		return [...new Set(targets)];
+	}
+	return {
+		async getEntry(kind, number) {
+			return parseJson(await store.get(entryKey(kind, number)), isEntry);
+		},
+		async putEntry(entry) {
+			const key = entryKey(entry.kind, entry.number);
+			const existing = await store.get(key);
+			if (existing !== void 0 && existing !== null) return false;
+			await appendToDay("day", entry.date, `${entry.kind}:${entry.number}`, retention);
+			const value = JSON.stringify(entry);
+			if (store.setIfAbsent) return store.setIfAbsent(key, value, retention);
+			await store.set(key, value, retention);
+			return true;
+		},
+		async listEntries(range) {
+			const normalized = normalizeRange(range);
+			return (await inBatches((await slotsOf("day", normalized)).map(slotTarget).filter((t) => t !== void 0), async ([kind, number]) => parseJson(await store.get(entryKey(kind, number)), isEntry))).filter((entry) => entry !== void 0 && inRange(entry.date, normalized));
+		},
+		async putReservation(reservation) {
+			const key = reservationKey(reservation.kind, reservation.orderNumber);
+			const value = JSON.stringify(reservation);
+			await appendToDay("rday", reservation.date, `${reservation.kind}:${reservation.orderNumber}`, reservationTtl);
+			if (store.setIfAbsent) return store.setIfAbsent(key, value, reservationTtl);
+			const existing = await store.get(key);
+			if (existing !== void 0 && existing !== null) return false;
+			await store.set(key, value, reservationTtl);
+			return true;
+		},
+		async deleteReservation(kind, orderNumber) {
+			await store.delete(reservationKey(kind, orderNumber));
+		},
+		async listReservations(range) {
+			return (await inBatches((await slotsOf("rday", normalizeRange(range))).map(slotTarget).filter((t) => t !== void 0), async ([kind, orderNumber]) => parseJson(await store.get(reservationKey(kind, orderNumber)), isReservation))).filter((reservation) => reservation !== void 0);
+		}
+	};
+}
+function memoryJournal() {
+	const entries = /* @__PURE__ */ new Map();
+	const reservations = /* @__PURE__ */ new Map();
+	const key = (kind, id) => `${kind}:${id}`;
+	return {
+		async getEntry(kind, number) {
+			return entries.get(key(kind, number));
+		},
+		async putEntry(entry) {
+			const id = key(entry.kind, entry.number);
+			if (entries.has(id)) return false;
+			entries.set(id, entry);
+			return true;
+		},
+		async listEntries(range) {
+			const normalized = normalizeRange(range);
+			return [...entries.values()].filter((entry) => inRange(entry.date, normalized));
+		},
+		async putReservation(reservation) {
+			const id = key(reservation.kind, reservation.orderNumber);
+			if (reservations.has(id)) return false;
+			reservations.set(id, reservation);
+			return true;
+		},
+		async deleteReservation(kind, orderNumber) {
+			reservations.delete(key(kind, orderNumber));
+		},
+		async listReservations(range) {
+			const normalized = normalizeRange(range);
+			return [...reservations.values()].filter((reservation) => inRange(reservation.date, normalized));
+		}
+	};
+}
+//#endregion
+exports.DEFAULT_JOURNAL_RETENTION_DAYS = DEFAULT_JOURNAL_RETENTION_DAYS;
+exports.DEFAULT_PENDING_DAYS = DEFAULT_PENDING_DAYS;
+exports.DEFAULT_RESERVATION_TTL_DAYS = DEFAULT_RESERVATION_TTL_DAYS;
+exports.JOURNAL_KEY_PREFIX = JOURNAL_KEY_PREFIX;
+exports.JournalWriteError = JournalWriteError;
+exports.MAX_JOURNAL_RANGE_DAYS = MAX_JOURNAL_RANGE_DAYS;
+exports.createJournal = createJournal;
+exports.kvJournal = kvJournal;
+exports.memoryJournal = memoryJournal;

package/dist/journal/index.d.cts

@@ -0,0 +1,18 @@
+import { n as KeyValueStore } from "../store-C1rHd9DB.cjs";
+import { _ as JournalRange, a as JournalReceiptQuery, c as JournalSettleApi, d as JournalWriteError, f as createJournal, g as JournalEntryType, h as JournalEntrySource, i as JournalOptions, l as JournalSettleOptions, m as JournalEntry, n as Journal, o as JournalReconcileOptions, p as JournalDocumentKind, r as JournalEntryQuery, s as JournalReconciliation, t as DEFAULT_PENDING_DAYS, u as JournalSettlement, v as JournalReservation, y as JournalStorage } from "../journal-DvI81Kt7.cjs";
+//#region src/journal/dates.d.ts
+export declare const MAX_JOURNAL_RANGE_DAYS = 366;
+//#endregion
+//#region src/journal/storage.d.ts
+export declare const JOURNAL_KEY_PREFIX = "szamlazz:journal:";
+export declare const DEFAULT_JOURNAL_RETENTION_DAYS = 400;
+export declare const DEFAULT_RESERVATION_TTL_DAYS = 30;
+interface KvJournalOptions {
+  readonly prefix?: string | undefined;
+  readonly retentionDays?: number | undefined;
+  readonly reservationTtlDays?: number | undefined;
+}
+export declare function kvJournal(store: KeyValueStore, options?: KvJournalOptions): JournalStorage;
+export declare function memoryJournal(): JournalStorage;
+//#endregion
+export { DEFAULT_PENDING_DAYS, type Journal, type JournalDocumentKind, type JournalEntry, type JournalEntryQuery, type JournalEntrySource, type JournalEntryType, type JournalOptions, type JournalRange, type JournalReceiptQuery, type JournalReconcileOptions, type JournalReconciliation, type JournalReservation, type JournalSettleApi, type JournalSettleOptions, type JournalSettlement, type JournalStorage, JournalWriteError, type KvJournalOptions, createJournal };

package/dist/journal/index.d.ts

@@ -0,0 +1,18 @@
+import { n as KeyValueStore } from "../store-C1rHd9DB.js";
+import { _ as JournalRange, a as JournalReceiptQuery, c as JournalSettleApi, d as JournalWriteError, f as createJournal, g as JournalEntryType, h as JournalEntrySource, i as JournalOptions, l as JournalSettleOptions, m as JournalEntry, n as Journal, o as JournalReconcileOptions, p as JournalDocumentKind, r as JournalEntryQuery, s as JournalReconciliation, t as DEFAULT_PENDING_DAYS, u as JournalSettlement, v as JournalReservation, y as JournalStorage } from "../journal-Y9qrIB8G.js";
+//#region src/journal/dates.d.ts
+export declare const MAX_JOURNAL_RANGE_DAYS = 366;
+//#endregion
+//#region src/journal/storage.d.ts
+export declare const JOURNAL_KEY_PREFIX = "szamlazz:journal:";
+export declare const DEFAULT_JOURNAL_RETENTION_DAYS = 400;
+export declare const DEFAULT_RESERVATION_TTL_DAYS = 30;
+interface KvJournalOptions {
+  readonly prefix?: string | undefined;
+  readonly retentionDays?: number | undefined;
+  readonly reservationTtlDays?: number | undefined;
+}
+export declare function kvJournal(store: KeyValueStore, options?: KvJournalOptions): JournalStorage;
+export declare function memoryJournal(): JournalStorage;
+//#endregion
+export { DEFAULT_PENDING_DAYS, type Journal, type JournalDocumentKind, type JournalEntry, type JournalEntryQuery, type JournalEntrySource, type JournalEntryType, type JournalOptions, type JournalRange, type JournalReceiptQuery, type JournalReconcileOptions, type JournalReconciliation, type JournalReservation, type JournalSettleApi, type JournalSettleOptions, type JournalSettlement, type JournalStorage, JournalWriteError, type KvJournalOptions, createJournal };