@yolk-sdk/emulators 0.1.0-canary.96

package/dist/fortnox/api.mjs

@@ -0,0 +1,750 @@
+import { answeredOutsideCore, handlerFailedResponse } from "../emulator-http.mjs";
+import { buildRow, compareNumbers, defaultEmailInformation, formatQuantity, fortnoxEmulatorCountries, fortnoxEmulatorVatCodes, invoiceFromSeed, invoiceTotals, newRowDefaults } from "./state.mjs";
+import { Predicate, Result } from "effect";
+import * as Schema from "effect/Schema";
+//#region src/fortnox/api.ts
+/**
+* `ErrorInformation` codes the emulator answers with. The two customer-not-found codes are copied
+* from the rejection fixture; the `2999xxx` codes are synthetic emulator codes.
+*/
+const fortnoxEmulatorErrorCodes = {
+	customerNotFound: 2000204,
+	invoiceCustomerNotFound: 2000433,
+	unauthorized: 2999001,
+	invalidBody: 2999002,
+	invalidField: 2999003,
+	readOnlyField: 2999004,
+	notEditable: 2999005,
+	invoiceNotFound: 2999006,
+	unknownRoute: 2999007,
+	unsupportedQuery: 2999008,
+	rateLimited: 2999009,
+	upstreamError: 2999010
+};
+/** Fortnox API base path. */
+const fortnoxEmulatorBasePath = "/3";
+const jsonResponse = (status, body) => new Response(JSON.stringify(body), {
+	status,
+	headers: { "content-type": "application/json" }
+});
+/** A Fortnox `ErrorInformation` response with the lowercase fields of the rejection fixture. */
+const errorInformation = (status, code, message) => jsonResponse(status, { ErrorInformation: {
+	error: 1,
+	message,
+	code
+} });
+const codes = fortnoxEmulatorErrorCodes;
+const customerNotFound = () => errorInformation(404, codes.customerNotFound, "Synthetic placeholder: customer not found.");
+const invoiceCustomerNotFound = () => errorInformation(400, codes.invoiceCustomerNotFound, "Synthetic placeholder: customer not found.");
+const invoiceNotFound = () => errorInformation(404, codes.invoiceNotFound, "Synthetic: invoice not found.");
+const invalidBody = (message) => errorInformation(400, codes.invalidBody, `Synthetic: ${message}`);
+const invalidField = (message) => errorInformation(400, codes.invalidField, `Synthetic: ${message}`);
+const noReferencedEntity = (kind, value) => invalidField(`${kind} ${value} does not exist in the emulated company.`);
+const readOnlyField = (message) => errorInformation(400, codes.readOnlyField, `Synthetic: ${message}`);
+const notEditable = (message) => errorInformation(400, codes.notEditable, `Synthetic: ${message}`);
+const unsupportedQuery = (key) => errorInformation(400, codes.unsupportedQuery, key === "lastmodified" ? "Synthetic: query parameter lastmodified is not emulated (the emulator does not track modification times)." : `Synthetic: query parameter ${key} is not emulated.`);
+const previewPdfBase64 = "JVBERi0xLjQKJeLjz9MKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFtdIC9Db3VudCAwID4+CmVuZG9iagp0cmFpbGVyCjw8IC9Sb290IDEgMCBSID4+CiUlRU9GCg==";
+const previewPdfBytes = () => Uint8Array.from(atob(previewPdfBase64), (character) => character.charCodeAt(0));
+const isJsonObject = (value) => value !== void 0 && value !== null && Predicate.isObject(value) && !Array.isArray(value);
+const isoDatePattern = /^\d{4}-\d{2}-\d{2}$/;
+/** A real `YYYY-MM-DD` calendar date (no JavaScript rollover such as `2026-02-30`). */
+const isIsoDate = (value) => {
+	const parsed = Date.parse(`${value}T00:00:00.000Z`);
+	return isoDatePattern.test(value) && !Number.isNaN(parsed) && new Date(parsed).toISOString().slice(0, 10) === value;
+};
+const today = (env) => new Date(env.now()).toISOString().slice(0, 10);
+/** `date` plus `days`, or `undefined` when the result is not a representable `YYYY-MM-DD` date. */
+const addDays = (date, days) => {
+	const result = new Date(Date.parse(`${date}T00:00:00.000Z`) + days * 24 * 60 * 60 * 1e3);
+	if (Number.isNaN(result.getTime())) return void 0;
+	const iso = result.toISOString().slice(0, 10);
+	return isIsoDate(iso) ? iso : void 0;
+};
+const maxTermsOfPaymentDays = 365;
+/**
+* `TermsOfPayment` as a whole number of days (`0`–`365`, no sign or leading zeros), or
+* `undefined` when the value is not emulated. Fortnox also knows named terms (such as `K`); the
+* emulated company has day terms only.
+*/
+const termsOfPaymentDays = (value) => {
+	if (!/^(?:0|[1-9]\d{0,2})$/.test(value)) return void 0;
+	const days = Number(value);
+	return days <= maxTermsOfPaymentDays ? days : void 0;
+};
+const unsupportedTermsOfPayment = (value) => invalidField(`TermsOfPayment ${value} is not emulated (whole days from 0 to ${maxTermsOfPaymentDays} only).`);
+/**
+* The customer categorical values the emulator deliberately models. This is the emulated subset,
+* not Fortnox's full enum: other values (for example export or EU reverse-charge VAT) would change
+* invoice VAT, which the emulator does not model, so they are rejected.
+*/
+const emulatedCustomerVatTypes = ["SEVAT"];
+const emulatedCustomerTypes = ["COMPANY", "PRIVATE"];
+const unsupportedVatType = (value) => invalidField(`VATType ${value} is not emulated (supported: ${emulatedCustomerVatTypes.join(", ")}).`);
+const customerUrl = (env, customerNumber) => `${env.linkOrigin}/3/customers/${encodeURIComponent(customerNumber)}`;
+const invoiceUrl = (env, documentNumber) => `${env.linkOrigin}/3/invoices/${encodeURIComponent(documentNumber)}`;
+const renderCustomer = (env, customer) => ({
+	"@url": customerUrl(env, customer.CustomerNumber),
+	...customer
+});
+const renderCustomerRow = (env, customer) => ({
+	"@url": customerUrl(env, customer.CustomerNumber),
+	Address1: customer.Address1,
+	Address2: customer.Address2,
+	City: customer.City,
+	CustomerNumber: customer.CustomerNumber,
+	Email: customer.Email,
+	Name: customer.Name,
+	OrganisationNumber: customer.OrganisationNumber,
+	Phone: customer.Phone1,
+	ZipCode: customer.ZipCode
+});
+/**
+* A single-invoice read: JSON-number amounts. `dropEmptyCopies` leaves empty CC/BCC addresses out
+* of `EmailInformation`, as the email-send fixture response does.
+*/
+const renderInvoice = (env, invoice, dropEmptyCopies = false) => {
+	const source = invoice.EmailInformation;
+	const email = {
+		EmailAddressFrom: source.EmailAddressFrom,
+		EmailAddressTo: source.EmailAddressTo
+	};
+	if (!dropEmptyCopies || source.EmailAddressCC !== "") email.EmailAddressCC = source.EmailAddressCC;
+	if (!dropEmptyCopies || source.EmailAddressBCC !== "") email.EmailAddressBCC = source.EmailAddressBCC;
+	email.EmailSubject = source.EmailSubject;
+	email.EmailBody = source.EmailBody;
+	return {
+		"@url": invoiceUrl(env, invoice.DocumentNumber),
+		...invoice,
+		EmailInformation: email
+	};
+};
+/** An invoice list row, in the list fixture's shape: `CurrencyRate` is a numeric string. */
+const renderInvoiceRow = (env, invoice) => ({
+	"@url": invoiceUrl(env, invoice.DocumentNumber),
+	Balance: invoice.Balance,
+	Booked: invoice.Booked,
+	Cancelled: invoice.Cancelled,
+	CostCenter: invoice.CostCenter,
+	Currency: invoice.Currency,
+	CurrencyRate: String(invoice.CurrencyRate),
+	CurrencyUnit: invoice.CurrencyUnit,
+	CustomerName: invoice.CustomerName,
+	CustomerNumber: invoice.CustomerNumber,
+	DocumentNumber: invoice.DocumentNumber,
+	DueDate: invoice.DueDate,
+	ExternalInvoiceReference1: invoice.ExternalInvoiceReference1,
+	ExternalInvoiceReference2: invoice.ExternalInvoiceReference2,
+	FinalPayDate: invoice.FinalPayDate,
+	InvoiceDate: invoice.InvoiceDate,
+	InvoiceType: invoice.InvoiceType,
+	NoxFinans: invoice.NoxFinans,
+	OCR: invoice.OCR,
+	VoucherNumber: invoice.VoucherNumber,
+	VoucherSeries: invoice.VoucherSeries,
+	VoucherYear: invoice.VoucherYear,
+	WayOfDelivery: invoice.WayOfDelivery,
+	TermsOfPayment: invoice.TermsOfPayment,
+	Project: invoice.Project,
+	Sent: invoice.Sent,
+	Total: invoice.Total
+});
+/** The 400 for the first query key the route does not emulate, or `undefined`. */
+const unsupportedQueryKey = (query, allowed) => {
+	const key = [...query.keys()].find((candidate) => !allowed.includes(candidate));
+	return key === void 0 ? void 0 : unsupportedQuery(key);
+};
+const positiveInt = (query, key, fallback, maximum) => {
+	const raw = query.get(key);
+	if (raw === null) return fallback;
+	const value = Number(raw);
+	return /^\d+$/.test(raw) && value >= 1 && value <= maximum ? value : invalidField(`query parameter ${key} must be an integer from 1 to ${maximum}.`);
+};
+/** Fortnox default and maximum page sizes. */
+const defaultLimit = 100;
+const maxLimit = 500;
+/** One page plus `MetaInformation` (`@TotalPages` is at least 1, as the empty-list fixture shows). */
+const paginate = (items, query) => {
+	const limit = positiveInt(query, "limit", defaultLimit, maxLimit);
+	const page = positiveInt(query, "page", 1, Number.MAX_SAFE_INTEGER);
+	if (limit instanceof Response) return limit;
+	if (page instanceof Response) return page;
+	return {
+		items: items.slice((page - 1) * limit, page * limit),
+		meta: {
+			"@CurrentPage": page,
+			"@TotalPages": Math.max(1, Math.ceil(items.length / limit)),
+			"@TotalResources": items.length
+		}
+	};
+};
+const contains = (value, search) => value.toLowerCase().includes(search.toLowerCase());
+const customerSearch = {
+	customernumber: (customer, value) => customer.CustomerNumber === value,
+	name: (customer, value) => contains(customer.Name, value),
+	organisationnumber: (customer, value) => contains(customer.OrganisationNumber, value),
+	email: (customer, value) => contains(customer.Email, value),
+	city: (customer, value) => contains(customer.City, value),
+	phone: (customer, value) => contains(customer.Phone1, value) || contains(customer.Phone2, value)
+};
+const customerListQueryKeys = [
+	"page",
+	"limit",
+	"filter",
+	...Object.keys(customerSearch)
+];
+const listCustomers = (state, { query }, env) => {
+	const filter = query.get("filter");
+	if (filter !== null && filter !== "active" && filter !== "inactive") return invalidField(`unknown customer filter ${filter}.`);
+	const page = paginate(state.customers.filter((customer) => (filter === null || customer.Active === (filter === "active")) && Object.entries(customerSearch).every(([key, matches]) => {
+		const value = query.get(key);
+		return value === null || matches(customer, value);
+	})), query);
+	if (page instanceof Response) return page;
+	return jsonResponse(200, {
+		Customers: page.items.map((customer) => renderCustomerRow(env, customer)),
+		MetaInformation: page.meta
+	});
+};
+const findCustomer = (state, customerNumber) => state.customers.find((customer) => customer.CustomerNumber === customerNumber);
+const findInvoice = (state, documentNumber) => state.invoices.find((invoice) => invoice.DocumentNumber === documentNumber);
+const getCustomer = (state, { params }, env) => {
+	const customer = findCustomer(state, params.CustomerNumber ?? "");
+	return customer === void 0 ? customerNotFound() : jsonResponse(200, { Customer: renderCustomer(env, customer) });
+};
+/** The single resource object of a `{ <envelope>: { ... } }` write body. */
+const envelopeObject = (body, envelope) => {
+	const value = isJsonObject(body) ? body[envelope] : void 0;
+	return isJsonObject(body) && Object.keys(body).every((key) => key === envelope) && isJsonObject(value) ? value : invalidBody(`the request body must be { "${envelope}": { ... } }.`);
+};
+const writableCustomerStrings = [
+	"Name",
+	"OrganisationNumber",
+	"Email",
+	"Phone1",
+	"Phone2",
+	"Address1",
+	"Address2",
+	"City",
+	"ZipCode",
+	"CountryCode",
+	"Currency",
+	"VATNumber",
+	"VATType",
+	"TermsOfPayment",
+	"OurReference",
+	"YourReference",
+	"Comments",
+	"EmailInvoice",
+	"Type",
+	"CostCenter"
+];
+const isCustomerStringField = (key) => writableCustomerStrings.some((field) => field === key);
+/**
+* Why a customer field value is not emulated (fail closed), or `undefined`. The emulated company
+* has only SEK, no cost centers, terms of payment in whole days (0–365), `VATType` `SEVAT`, and
+* `Type` `COMPANY` or `PRIVATE`.
+*/
+const unsupportedCustomerValue = (key, value) => {
+	switch (key) {
+		case "Currency": return value === "SEK" ? void 0 : noReferencedEntity("Currency", value);
+		case "CostCenter": return value === "" ? void 0 : noReferencedEntity("CostCenter", value);
+		case "TermsOfPayment": return termsOfPaymentDays(value) === void 0 ? unsupportedTermsOfPayment(value) : void 0;
+		case "VATType": return emulatedCustomerVatTypes.includes(value) ? void 0 : unsupportedVatType(value);
+		case "Type": return emulatedCustomerTypes.includes(value) ? void 0 : invalidField(`Type ${value} is not emulated (supported: ${emulatedCustomerTypes.join(", ")}).`);
+		default: return;
+	}
+};
+/**
+* Quirk 2: an empty string keeps the stored value (unless the `emptyStringClears` drill knob is
+* set); omitted fields keep theirs. Quirk 5: `Country` is read-only. Unknown fields, wrong types,
+* and values the emulator does not support (non-SEK `Currency`, a `CostCenter`, `TermsOfPayment`
+* other than 0–365 days, `VATType` other than `SEVAT`, `Type` other than `COMPANY`/`PRIVATE`) are
+* rejected; the update is atomic.
+*/
+const customerUpdates = (fields, customer, env) => {
+	const updates = {};
+	for (const [key, value] of Object.entries(fields)) {
+		if (key === "Country") return readOnlyField("Country is read-only; set CountryCode instead.");
+		if (key === "CustomerNumber") {
+			if (value !== customer.CustomerNumber) return invalidField("CustomerNumber cannot be changed.");
+			continue;
+		}
+		if (key === "Active") {
+			if (!Predicate.isBoolean(value)) return invalidField("Active must be a boolean.");
+			updates.Active = value;
+			continue;
+		}
+		if (!isCustomerStringField(key)) return invalidField(`unknown customer field ${key}.`);
+		if (!Predicate.isString(value)) return invalidField(`${key} must be a string.`);
+		if (value === "" && !env.quirks.emptyStringClears) continue;
+		const unsupported = unsupportedCustomerValue(key, value);
+		if (unsupported !== void 0) return unsupported;
+		if (key === "CountryCode" && value !== "") {
+			const country = fortnoxEmulatorCountries.get(value);
+			if (country === void 0) return invalidField(`unknown CountryCode ${value}.`);
+			updates.Country = country;
+		}
+		updates[key] = value;
+	}
+	return updates;
+};
+const updateCustomer = (state, { params, body }, env) => {
+	const customer = findCustomer(state, params.CustomerNumber ?? "");
+	if (customer === void 0) return customerNotFound();
+	const fields = envelopeObject(body, "Customer");
+	if (fields instanceof Response) return fields;
+	const updates = customerUpdates(fields, customer, env);
+	if (updates instanceof Response) return updates;
+	const updated = {
+		...customer,
+		...updates
+	};
+	state.customers = state.customers.map((existing) => existing.CustomerNumber === updated.CustomerNumber ? updated : existing);
+	return jsonResponse(200, { Customer: renderCustomer(env, updated) });
+};
+const invoiceFilters = [
+	"cancelled",
+	"fullypaid",
+	"unpaid",
+	"unpaidoverdue",
+	"unbooked"
+];
+const isInvoiceFilter = (value) => invoiceFilters.some((filter) => filter === value);
+/**
+* Quirk 3: the payment-status filters consider booked invoices only (unless the
+* `paymentFiltersIncludeUnbooked` drill knob is set); `unbooked` returns unbooked, uncancelled
+* invoices; `unpaidoverdue` needs a `DueDate` before today (UTC, from the emulator clock).
+*/
+const matchesInvoiceFilter = (invoice, filter, env) => {
+	const considered = (invoice.Booked || env.quirks.paymentFiltersIncludeUnbooked) && !invoice.Cancelled;
+	switch (filter) {
+		case "cancelled": return invoice.Cancelled;
+		case "unbooked": return !invoice.Booked && !invoice.Cancelled;
+		case "unpaid": return considered && invoice.Balance > 0;
+		case "unpaidoverdue": return considered && invoice.Balance > 0 && invoice.DueDate !== null && isIsoDate(invoice.DueDate) && invoice.DueDate < today(env);
+		case "fullypaid": return considered && invoice.Balance === 0;
+	}
+};
+const invoiceSearch = {
+	customernumber: (invoice, value) => invoice.CustomerNumber === value,
+	customername: (invoice, value) => contains(invoice.CustomerName, value),
+	documentnumber: (invoice, value) => invoice.DocumentNumber === value,
+	ocr: (invoice, value) => invoice.OCR === value
+};
+const invoiceListQueryKeys = [
+	"page",
+	"limit",
+	"filter",
+	"fromdate",
+	"todate",
+	...Object.keys(invoiceSearch)
+];
+const listInvoices = (state, { query }, env) => {
+	const filter = query.get("filter");
+	if (filter !== null && !isInvoiceFilter(filter)) return invalidField(`unknown invoice filter ${filter}.`);
+	const fromDate = query.get("fromdate");
+	const toDate = query.get("todate");
+	for (const [key, value] of [["fromdate", fromDate], ["todate", toDate]]) if (value !== null && !isIsoDate(value)) return invalidField(`query parameter ${key} must be a YYYY-MM-DD date.`);
+	const page = paginate(state.invoices.filter((invoice) => (filter === null || matchesInvoiceFilter(invoice, filter, env)) && (fromDate === null || invoice.InvoiceDate >= fromDate) && (toDate === null || invoice.InvoiceDate <= toDate) && Object.entries(invoiceSearch).every(([key, matches]) => {
+		const value = query.get(key);
+		return value === null || matches(invoice, value);
+	})), query);
+	if (page instanceof Response) return page;
+	return jsonResponse(200, {
+		Invoices: page.items.map((invoice) => renderInvoiceRow(env, invoice)),
+		MetaInformation: page.meta
+	});
+};
+const getInvoice = (state, { params }, env) => {
+	const invoice = findInvoice(state, params.DocumentNumber ?? "");
+	return invoice === void 0 ? invoiceNotFound() : jsonResponse(200, { Invoice: renderInvoice(env, invoice) });
+};
+const vatRates = [...fortnoxEmulatorVatCodes.keys()];
+/**
+* One row of an `InvoiceRows` write. `null` means omitted. Referenced articles, cost centers, and
+* projects must exist (the emulated company has none); accounts must be in 1000-8999.
+*/
+const rowPatch = (value, index) => {
+	if (!isJsonObject(value)) return invalidField(`InvoiceRows[${index}] must be an object.`);
+	const patch = {};
+	const label = (key) => `InvoiceRows[${index}].${key}`;
+	for (const [key, field] of Object.entries(value)) {
+		if (field === null) continue;
+		switch (key) {
+			case "RowId":
+				if (!Predicate.isNumber(field) || !Number.isSafeInteger(field) || field < 1) return invalidField(`${label(key)} must be a positive integer.`);
+				patch.RowId = field;
+				break;
+			case "AccountNumber":
+				if (!Predicate.isNumber(field) || !Number.isInteger(field) || field < 1e3 || field > 8999) return invalidField(`${label(key)} must be an account number from 1000 to 8999.`);
+				patch.AccountNumber = field;
+				break;
+			case "ArticleNumber":
+			case "CostCenter":
+			case "Project":
+				if (!Predicate.isString(field)) return invalidField(`${label(key)} must be a string.`);
+				if (field !== "") return noReferencedEntity(key, field);
+				patch[key] = field;
+				break;
+			case "Description":
+			case "Unit":
+				if (!Predicate.isString(field)) return invalidField(`${label(key)} must be a string.`);
+				patch[key] = field;
+				break;
+			case "DeliveredQuantity": {
+				const quantity = Predicate.isString(field) ? Number(field.trim()) : field;
+				if (!Predicate.isNumber(quantity) || !Number.isFinite(quantity) || quantity < 0 || Predicate.isString(field) && field.trim() === "") return invalidField(`${label(key)} must be a non-negative number.`);
+				patch.DeliveredQuantity = formatQuantity(quantity);
+				break;
+			}
+			case "Price":
+				if (!Predicate.isNumber(field) || !Number.isFinite(field)) return invalidField(`${label(key)} must be a finite number.`);
+				patch.Price = field;
+				break;
+			case "Discount":
+				if (!Predicate.isNumber(field) || !Number.isFinite(field) || field < 0) return invalidField(`${label(key)} must be a non-negative number.`);
+				patch.Discount = field;
+				break;
+			case "DiscountType":
+				if (field !== "PERCENT" && field !== "AMOUNT") return invalidField(`${label(key)} must be PERCENT or AMOUNT.`);
+				patch.DiscountType = field;
+				break;
+			case "VAT":
+				if (!Predicate.isNumber(field) || !vatRates.includes(field)) return invalidField(`${label(key)} must be one of ${vatRates.join(", ")}.`);
+				patch.VAT = field;
+				break;
+			default: return invalidField(`${label(key)} is not a writable invoice row field.`);
+		}
+	}
+	return patch;
+};
+const rowPatches = (value) => {
+	if (!Array.isArray(value)) return invalidField("InvoiceRows must be an array.");
+	const patches = [];
+	for (const [index, row] of value.entries()) {
+		const patch = rowPatch(row, index);
+		if (patch instanceof Response) return patch;
+		patches.push(patch);
+	}
+	return patches;
+};
+/**
+* Quirk 1: `InvoiceRows` replaces the row list. Without any `RowId`, rows match existing rows by
+* position; with a `RowId`, that row is updated and rows without one are added. A matched row
+* keeps every omitted field, including `Discount`/`DiscountType` (unless the `stickyRowDiscount`
+* drill knob is off, which resets them); `Discount: 0` clears. RowIds are regenerated for every
+* row, and totals follow from the fields.
+*/
+const mergeRows = (existing, patches, ids, env) => {
+	const byRowId = patches.some((patch) => patch.RowId !== void 0);
+	const rows = [];
+	for (const [index, patch] of patches.entries()) {
+		const base = byRowId ? existing.find((row) => patch.RowId !== void 0 && row.RowId === patch.RowId) : existing[index];
+		if (byRowId && patch.RowId !== void 0 && base === void 0) return invalidField(`InvoiceRows[${index}].RowId ${patch.RowId} does not exist.`);
+		const start = {
+			...newRowDefaults,
+			...base
+		};
+		if (base !== void 0 && !env.quirks.stickyRowDiscount) {
+			start.Discount = 0;
+			start.DiscountType = "PERCENT";
+		}
+		rows.push(buildRow({
+			...start,
+			...patch,
+			RowId: ids.next++
+		}));
+	}
+	return rows;
+};
+const invoiceTextFields = [
+	"Comments",
+	"OurReference",
+	"YourReference",
+	"OCR"
+];
+const isInvoiceTextField = (key) => invoiceTextFields.some((field) => field === key);
+const invoiceReadOnlyFields = [
+	"Balance",
+	"Booked",
+	"Cancelled",
+	"CustomerName",
+	"FinalPayDate",
+	"Gross",
+	"Net",
+	"Sent",
+	"Total",
+	"TotalToPay",
+	"TotalVAT",
+	"VoucherNumber",
+	"VoucherSeries",
+	"VoucherYear"
+];
+/**
+* The writable invoice fields of a create or update body (the connector's invoice mutation
+* fields). Quirk 4: an unknown `CustomerNumber` is rejected with the rejection fixture's 400
+* `ErrorInformation`; other invalid or read-only fields are rejected with 400 too.
+*/
+const invoiceUpdates = (fields, state, existing) => {
+	const scalars = {};
+	let customer;
+	let rows;
+	for (const [key, value] of Object.entries(fields)) {
+		if (key === "DocumentNumber") {
+			if (existing === void 0 || value !== existing.DocumentNumber) return readOnlyField("DocumentNumber is assigned by Fortnox and cannot be changed.");
+			continue;
+		}
+		if (key === "InvoiceRows") {
+			const patches = rowPatches(value);
+			if (patches instanceof Response) return patches;
+			if (existing === void 0 && patches.some((patch) => patch.RowId !== void 0)) return readOnlyField("RowId is assigned by Fortnox.");
+			rows = patches;
+			continue;
+		}
+		if (invoiceReadOnlyFields.includes(key)) return readOnlyField(`${key} is read-only.`);
+		if (!Predicate.isString(value)) return invalidField(key === "CustomerNumber" || key === "Currency" || isInvoiceTextField(key) ? `${key} must be a string.` : `unknown or unsupported invoice field ${key}.`);
+		switch (key) {
+			case "CustomerNumber":
+				customer = findCustomer(state, value);
+				if (customer === void 0) return invoiceCustomerNotFound();
+				scalars.CustomerNumber = value;
+				break;
+			case "Currency":
+				if (value !== "SEK") return noReferencedEntity("Currency", value);
+				scalars.Currency = value;
+				break;
+			case "InvoiceDate":
+			case "DueDate":
+				if (!isIsoDate(value)) return invalidField(`${key} must be a YYYY-MM-DD date.`);
+				scalars[key] = value;
+				break;
+			case "CostCenter":
+			case "Project":
+				if (value !== "") return noReferencedEntity(key, value);
+				scalars[key] = value;
+				break;
+			default:
+				if (!isInvoiceTextField(key)) return invalidField(`unknown or unsupported invoice field ${key}.`);
+				scalars[key] = value;
+		}
+	}
+	return {
+		scalars,
+		customer,
+		rows
+	};
+};
+const replaceInvoice = (state, updated) => {
+	state.invoices = state.invoices.map((invoice) => invoice.DocumentNumber === updated.DocumentNumber ? updated : invoice);
+};
+const updateInvoice = (state, { params, body }, env) => {
+	const invoice = findInvoice(state, params.DocumentNumber ?? "");
+	if (invoice === void 0) return invoiceNotFound();
+	const fields = envelopeObject(body, "Invoice");
+	if (fields instanceof Response) return fields;
+	if (invoice.Booked) return notEditable("a booked invoice cannot be updated.");
+	if (invoice.Cancelled) return notEditable("a cancelled invoice cannot be updated.");
+	const updates = invoiceUpdates(fields, state, invoice);
+	if (updates instanceof Response) return updates;
+	let updated = {
+		...invoice,
+		...updates.scalars,
+		CustomerName: updates.customer?.Name ?? invoice.CustomerName
+	};
+	if (updates.rows !== void 0) {
+		const ids = { next: state.counters.nextRowId };
+		const rows = mergeRows(invoice.InvoiceRows, updates.rows, ids, env);
+		if (rows instanceof Response) return rows;
+		const totals = invoiceTotals(rows);
+		updated = {
+			...updated,
+			InvoiceRows: rows,
+			...totals,
+			Balance: totals.Total
+		};
+		state.counters = {
+			...state.counters,
+			nextRowId: ids.next
+		};
+	}
+	replaceInvoice(state, updated);
+	return jsonResponse(200, { Invoice: renderInvoice(env, updated) });
+};
+const createInvoice = (state, { body }, env) => {
+	const fields = envelopeObject(body, "Invoice");
+	if (fields instanceof Response) return fields;
+	const updates = invoiceUpdates(fields, state, void 0);
+	if (updates instanceof Response) return updates;
+	const { customer } = updates;
+	if (customer === void 0) return invalidField("CustomerNumber is required.");
+	const currency = updates.scalars.Currency ?? customer.Currency;
+	if (currency !== "SEK") return noReferencedEntity("Currency", currency);
+	if (!emulatedCustomerVatTypes.includes(customer.VATType)) return unsupportedVatType(customer.VATType);
+	const terms = termsOfPaymentDays(customer.TermsOfPayment);
+	if (terms === void 0) return unsupportedTermsOfPayment(customer.TermsOfPayment);
+	const invoiceDate = updates.scalars.InvoiceDate ?? today(env);
+	const dueDate = updates.scalars.DueDate ?? addDays(invoiceDate, terms);
+	if (dueDate === void 0) return invalidField(`the due date ${invoiceDate} + ${terms} days is not a representable YYYY-MM-DD date.`);
+	const ids = { next: state.counters.nextRowId };
+	const invoice = invoiceFromSeed({
+		...updates.scalars,
+		DocumentNumber: String(state.counters.nextDocumentNumber),
+		CustomerNumber: customer.CustomerNumber,
+		InvoiceDate: invoiceDate,
+		DueDate: dueDate,
+		EmailInformation: defaultEmailInformation(customer, state.company),
+		InvoiceRows: updates.rows ?? []
+	}, customer, state.company, ids);
+	state.invoices = [...state.invoices, invoice].sort((left, right) => compareNumbers(left.DocumentNumber, right.DocumentNumber));
+	state.counters = {
+		nextRowId: ids.next,
+		nextDocumentNumber: state.counters.nextDocumentNumber + 1
+	};
+	return jsonResponse(201, { Invoice: renderInvoice(env, invoice) });
+};
+const previewInvoice = (state, { params }) => findInvoice(state, params.DocumentNumber ?? "") === void 0 ? invoiceNotFound() : new Response(previewPdfBytes(), {
+	status: 200,
+	headers: { "content-type": "application/pdf" }
+});
+/** Marks the invoice `Sent` and records an outbox entry. Nothing is ever delivered. */
+const emailInvoice = (state, { params }, env) => {
+	const invoice = findInvoice(state, params.DocumentNumber ?? "");
+	if (invoice === void 0) return invoiceNotFound();
+	if (invoice.Cancelled) return notEditable("a cancelled invoice cannot be sent.");
+	const email = invoice.EmailInformation;
+	if (email.EmailAddressTo.trim() === "") return invalidField("the invoice has no EmailInformation.EmailAddressTo.");
+	const updated = {
+		...invoice,
+		Sent: true
+	};
+	replaceInvoice(state, updated);
+	state.outbox = [...state.outbox, {
+		DocumentNumber: invoice.DocumentNumber,
+		EmailAddressTo: email.EmailAddressTo,
+		EmailAddressCC: email.EmailAddressCC,
+		EmailAddressBCC: email.EmailAddressBCC,
+		EmailSubject: email.EmailSubject.replaceAll("{no}", invoice.DocumentNumber),
+		sentAt: new Date(env.now()).toISOString()
+	}];
+	return jsonResponse(200, { Invoice: renderInvoice(env, updated, true) });
+};
+const companyInformation = (state) => jsonResponse(200, { CompanyInformation: state.company });
+const connectorRoute = (method, path, write, caseIds, handler, queryKeys = []) => ({
+	method,
+	path: `/3${path}`,
+	kind: "connector",
+	write,
+	caseIds,
+	evidence: "unverified",
+	queryKeys,
+	handler
+});
+const listCase = "fortnox.invoice.list-populated";
+const previewCase = "fortnox.invoice.preview-pdf";
+const filtersCase = "fortnox.invoice.payment-filters-exclude-unbooked";
+const discountCase = "fortnox.invoice.row-discount-sticky";
+const emptyStringCase = "fortnox.customer.empty-string-keeps-value";
+const rejectionCase = "fortnox.write.rejection-error-information";
+const emailCase = "fortnox.invoice.send-email";
+/** The route table: evidence plus handler. `fortnoxEmulatorRoutes` is its evidence part. */
+const fortnoxApiRoutes = [
+	connectorRoute("GET", "/companyinformation", false, [], companyInformation),
+	connectorRoute("GET", "/customers", false, [], listCustomers, customerListQueryKeys),
+	connectorRoute("GET", "/customers/{CustomerNumber}", false, [emptyStringCase, rejectionCase], getCustomer),
+	connectorRoute("PUT", "/customers/{CustomerNumber}", true, [emptyStringCase], updateCustomer),
+	connectorRoute("GET", "/invoices", false, [listCase, filtersCase], listInvoices, invoiceListQueryKeys),
+	connectorRoute("POST", "/invoices", true, [rejectionCase], createInvoice),
+	connectorRoute("GET", "/invoices/{DocumentNumber}", false, [discountCase, emailCase], getInvoice),
+	connectorRoute("PUT", "/invoices/{DocumentNumber}", true, [discountCase], updateInvoice),
+	connectorRoute("GET", "/invoices/{DocumentNumber}/preview", false, [previewCase], previewInvoice),
+	connectorRoute("GET", "/invoices/{DocumentNumber}/email", true, [emailCase], emailInvoice)
+];
+/** The observed quirks, each tied to its conformance case id. */
+const fortnoxEmulatorQuirks = [
+	{
+		id: "row-discount-sticky",
+		route: "PUT /3/invoices/{DocumentNumber}",
+		caseId: discountCase,
+		knob: "stickyRowDiscount",
+		summary: "InvoiceRows replaces the rows; rows without RowId match by position; an omitted Discount/DiscountType keeps its value; Discount 0 clears; RowIds regenerate; totals are recomputed."
+	},
+	{
+		id: "empty-string-keeps-value",
+		route: "PUT /3/customers/{CustomerNumber}",
+		caseId: emptyStringCase,
+		knob: "emptyStringClears",
+		summary: "A customer update with \"\" for a string field keeps the stored value."
+	},
+	{
+		id: "payment-filters-exclude-unbooked",
+		route: "GET /3/invoices",
+		caseId: filtersCase,
+		knob: "paymentFiltersIncludeUnbooked",
+		summary: "unpaid, unpaidoverdue, and fullypaid consider booked invoices only; unbooked lists unbooked, uncancelled invoices; unpaidoverdue needs DueDate before today."
+	},
+	{
+		id: "rejection-error-information",
+		route: "POST /3/invoices",
+		caseId: rejectionCase,
+		knob: void 0,
+		summary: "Writes for an unknown customer, or with invalid fields, answer 400 with a lowercase ErrorInformation { error, message, code }."
+	},
+	{
+		id: "customer-country-read-only",
+		route: "PUT /3/customers/{CustomerNumber}",
+		caseId: void 0,
+		knob: void 0,
+		summary: "Customer Country is read-only (derived from CountryCode); sending it answers 400 ErrorInformation. No conformance case covers it yet."
+	}
+];
+const templatePattern = (template) => new RegExp(`^${template.split(/(\{[A-Za-z]+\})/).map((part) => /^\{[A-Za-z]+\}$/.test(part) ? "([^/]+)" : part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("")}$`);
+const compiledRoutes = fortnoxApiRoutes.map((route) => ({
+	route,
+	pattern: templatePattern(route.path)
+}));
+/** The route answering `method` + concrete `path`, or `undefined` (fail closed). */
+const matchFortnoxRoute = (method, path) => compiledRoutes.find((candidate) => candidate.route.method === method.toUpperCase() && candidate.pattern.test(path))?.route;
+const decodeJsonText = Schema.decodeUnknownResult(Schema.fromJsonString(Schema.Json));
+/** Parsed JSON, or `undefined` for invalid JSON. */
+const parseJsonText = (text) => {
+	const result = decodeJsonText(text);
+	return Result.isSuccess(result) ? result.success : void 0;
+};
+/** `{Name}` path templates become `:Name` core route parameters. */
+const corePath = (template) => template.replace(/\{([A-Za-z]+)\}/g, ":$1");
+/**
+* Register every route of the table on the core app, over the generation's state. Each request is
+* planned, then faulted, then committed: the handler runs on a draft of the state (handlers replace
+* whole lists and counters, never edit them in place, so a shallow copy keeps every write off the
+* state); a refusal (any answer that is not 2xx) is sent as is and uses up no fault; a successful
+* answer asks `decideFault`, and only an unfaulted one commits the draft. The three steps run
+* synchronously together, so no other request interleaves. A handler that throws answers
+* `handlerFailedResponse()` (nothing written), which the wrapper turns into its `ErrorInformation`
+* 500 with `responseError` in the ledger.
+*/
+const registerFortnoxApi = (app, state, env, decideFault) => {
+	for (const route of fortnoxApiRoutes) app.on(route.method, corePath(route.path), async (context) => {
+		try {
+			const query = new URL(context.req.url).searchParams;
+			const unsupported = unsupportedQueryKey(query, route.queryKeys);
+			if (unsupported !== void 0) return unsupported;
+			const text = await context.req.text();
+			const draft = { ...state };
+			const response = route.handler(draft, {
+				params: context.req.param(),
+				query,
+				body: text === "" ? void 0 : parseJsonText(text)
+			}, env);
+			if (!response.ok) return response;
+			if (decideFault(context.req.header("x-emulator-job-id"))) return answeredOutsideCore();
+			Object.assign(state, draft);
+			return response;
+		} catch {
+			return handlerFailedResponse();
+		}
+	});
+};
+//#endregion
+export { errorInformation, fortnoxApiRoutes, fortnoxEmulatorBasePath, fortnoxEmulatorErrorCodes, fortnoxEmulatorQuirks, matchFortnoxRoute, parseJsonText, registerFortnoxApi };
+
+//# sourceMappingURL=api.mjs.map