@endevops/peppol-schema 0.1.0-beta.5 → 0.1.0-beta.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/SchemaStore/schemastore/refs/heads/master/src/schemas/json/package.json",
   "name": "@endevops/peppol-schema",
-  "version": "0.1.0-beta.5",
+  "version": "0.1.0-beta.6",
   "description": "A simple example library built by tsdown",
   "license": "Apache-2.0",
   "contributors": [

package/src/decoders/fields/encode-message-party.ts

@@ -1,5 +1,7 @@
 import { Effect, Predicate } from 'effect';
 
+import type { PeppolContact } from '#/schemas/fields/peppol-contact-schema';
+import type { PeppolIdentifier } from '#/schemas/fields/peppol-identifier-schema';
 import type { PeppolInvoiceDocumentResponseParty, PeppolInvoiceResponseParty } from '#/schemas/peppol-invoice-response-schema';
 import type { PeppolMessageLevelResponseParty } from '#/schemas/peppol-message-level-response-party-schema';
 
@@ -7,18 +9,29 @@ import { encodeContact } from '#/decoders/fields/encode-contact';
 import { encodeIdentifier } from '#/decoders/fields/encode-identifier';
 import { encodePartyLegalEntity } from '#/decoders/fields/encode-party-legal-entity';
 
-export const encodeMessageParty = Effect.fn(function* (
-  party?: PeppolMessageLevelResponseParty | PeppolInvoiceResponseParty | PeppolInvoiceDocumentResponseParty
-) {
+type ResponseParty = PeppolMessageLevelResponseParty | PeppolInvoiceResponseParty | PeppolInvoiceDocumentResponseParty;
+
+/**
+ * @description The response party union exposes different fields per variant; reading the optional ones through a shared view keeps the encoder branch-free.
+ */
+interface ResponsePartyFields {
+  endpointId?: PeppolIdentifier | undefined;
+  partyIdentification?: PeppolIdentifier | undefined;
+  partyName?: { name: string } | undefined;
+  partyLegalEntity?:
+    | { registrationName?: string | undefined; companyId?: PeppolIdentifier | undefined; companyLegalForm?: string | undefined }
+    | undefined;
+  contact?: PeppolContact | undefined;
+}
+
+export const encodeMessageParty = Effect.fn(function* (party?: ResponseParty) {
   if (Predicate.isNullish(party)) return undefined;
+  const fields = party as ResponsePartyFields;
   return {
-    'cbc:EndpointID': 'endpointId' in party && Predicate.isNotNullish(party.endpointId) ? yield* encodeIdentifier(party.endpointId) : undefined,
-    'cac:PartyIdentification':
-      'partyIdentification' in party && Predicate.isNotNullish(party.partyIdentification)
-        ? { 'cbc:ID': yield* encodeIdentifier(party.partyIdentification) }
-        : undefined,
-    'cac:PartyName': 'partyName' in party && Predicate.isNotNullish(party.partyName) ? { 'cbc:Name': party.partyName.name } : undefined,
-    'cac:PartyLegalEntity': 'partyLegalEntity' in party ? yield* encodePartyLegalEntity(party.partyLegalEntity) : undefined,
-    'cac:Contact': 'contact' in party ? yield* encodeContact(party.contact) : undefined,
+    'cbc:EndpointID': yield* encodeIdentifier(fields.endpointId),
+    'cac:PartyIdentification': fields.partyIdentification ? { 'cbc:ID': yield* encodeIdentifier(fields.partyIdentification) } : undefined,
+    'cac:PartyName': fields.partyName ? { 'cbc:Name': fields.partyName.name } : undefined,
+    'cac:PartyLegalEntity': fields.partyLegalEntity ? yield* encodePartyLegalEntity(fields.partyLegalEntity) : undefined,
+    'cac:Contact': yield* encodeContact(fields.contact),
   };
 });

package/src/schemas/utils/peppol-vat-regex-schema.ts

@@ -47,5 +47,3 @@ export const peppolVatRegexSchema = Schema.Union([
   Schema.String.check(Schema.isStartsWith('SI'), Schema.isPattern(/^SI\d{8}$/)),
   Schema.String.check(Schema.isStartsWith('SK'), Schema.isPattern(/^SK\d{10}$/)),
 ]);
-
-export type VatRegex = typeof peppolVatRegexSchema.Type;

package/src/schematron/gr/gr-r-006.ts

@@ -10,13 +10,13 @@ const rule = {
   message: 'Greek Suppliers must provide the VAT number of the buyer, if the buyer is Greek ',
 } as const satisfies SchematronRule;
 
+const isGreekCountry = (country: string): boolean => country === 'GR' || country === 'EL';
+
 function evaluateGrR006(document: PeppolDocument): boolean {
-  const isGreekSupplier = getSupplierCountry(document) === 'GR' || getSupplierCountry(document) === 'EL';
-  const isGreekCustomer = getCustomerCountry(document) === 'GR' || getCustomerCountry(document) === 'EL';
-  if (!isGreekSupplier || !isGreekCustomer) {
+  if (!isGreekCountry(getSupplierCountry(document)) || !isGreekCountry(getCustomerCountry(document))) {
     return true;
   }
-  const vatSchemes = document.accountingCustomerParty.partyTaxSchemes?.filter(scheme => scheme.taxSchemeId.id.trim().toUpperCase() === 'VAT') ?? [];
+  const vatSchemes = (document.accountingCustomerParty.partyTaxSchemes ?? []).filter(scheme => scheme.taxSchemeId.id.trim().toUpperCase() === 'VAT');
   if (vatSchemes.length !== 1) {
     return false;
   }

package/src/schematron/helpers.ts

@@ -566,19 +566,17 @@ export function everyVatBreakdownTaxableMatchesRateSum(document: PeppolDocument)
  * @description Returns all identifiers carrying a scheme identifier, used by the PEPPOL-COMMON-R* rules.
  */
 export function getIdentifiersWithSchemeId(document: PeppolDocument): Array<{ id: string; schemeId: string }> {
-  const result: Array<{ id: string; schemeId: string }> = [];
-  const push = (id: string | undefined, schemeId: string | undefined) => {
-    if (id && schemeId) {
-      result.push({ id, schemeId });
-    }
-  };
+  const candidates: Array<{ id: string | undefined; schemeId: string | undefined }> = [];
   for (const party of [document.accountingSupplierParty, document.accountingCustomerParty]) {
-    push(party.endpointId?.id, party.endpointId?.schemeId);
-    push(party.partyIdentification?.id?.id, party.partyIdentification?.id?.schemeId);
-    push(party.partyLegalEntity.companyId?.id, party.partyLegalEntity.companyId?.schemeId);
+    candidates.push(
+      { id: party.endpointId?.id, schemeId: party.endpointId?.schemeId },
+      { id: party.partyIdentification?.id?.id, schemeId: party.partyIdentification?.id?.schemeId },
+      { id: party.partyLegalEntity.companyId?.id, schemeId: party.partyLegalEntity.companyId?.schemeId }
+    );
   }
-  if (document.payeeParty?.partyIdentification?.id) {
-    push(document.payeeParty.partyIdentification.id.id, document.payeeParty.partyIdentification.id.schemeId);
+  const payeeIdentification = document.payeeParty?.partyIdentification?.id;
+  if (payeeIdentification) {
+    candidates.push({ id: payeeIdentification.id, schemeId: payeeIdentification.schemeId });
   }
-  return result;
+  return candidates.filter((candidate): candidate is { id: string; schemeId: string } => Boolean(candidate.id) && Boolean(candidate.schemeId));
 }

package/src/schematron/peppol/cl/peppol-en16931-cl007.ts

@@ -12,33 +12,33 @@ const rule = {
 
 const isValidCurrency = (code: string): boolean => (currencyCodesKeys as ReadonlyArray<string>).includes(code);
 
-function evaluatePeppolEn16931CL007(document: PeppolDocument): boolean {
-  const currencies: Array<string> = [document.documentCurrencyCode];
-  if (document.taxCurrencyCode) {
-    currencies.push(document.taxCurrencyCode);
-  }
-  for (const line of getLines(document)) {
-    currencies.push(line.lineExtensionAmount.currencyId);
-    currencies.push(line.price.priceAmount.currencyId);
-  }
+const collectCurrencies = (document: PeppolDocument): Array<string> => {
   const total = document.legalMonetaryTotal;
-  currencies.push(
+  const optionalTotalCurrencies = [
+    total.allowanceTotalAmount?.currencyId,
+    total.chargeTotalAmount?.currencyId,
+    total.prepaidAmount?.currencyId,
+    total.payableRoundingAmount?.currencyId,
+  ].filter((code): code is string => code !== undefined);
+
+  return [
+    document.documentCurrencyCode,
+    ...(document.taxCurrencyCode ? [document.taxCurrencyCode] : []),
+    ...getLines(document).flatMap(line => [line.lineExtensionAmount.currencyId, line.price.priceAmount.currencyId]),
     total.lineExtensionAmount.currencyId,
     total.taxExclusiveAmount.currencyId,
     total.taxInclusiveAmount.currencyId,
-    total.payableAmount.currencyId
-  );
-  if (total.allowanceTotalAmount) currencies.push(total.allowanceTotalAmount.currencyId);
-  if (total.chargeTotalAmount) currencies.push(total.chargeTotalAmount.currencyId);
-  if (total.prepaidAmount) currencies.push(total.prepaidAmount.currencyId);
-  if (total.payableRoundingAmount) currencies.push(total.payableRoundingAmount.currencyId);
-  for (const taxTotal of document.taxTotals) {
-    currencies.push(taxTotal.taxAmount.currencyId);
-    for (const subtotal of taxTotal.taxSubtotals ?? []) {
-      currencies.push(subtotal.taxAmount.currencyId, subtotal.taxableAmount.currencyId);
-    }
-  }
-  return currencies.every(isValidCurrency);
+    total.payableAmount.currencyId,
+    ...optionalTotalCurrencies,
+    ...document.taxTotals.flatMap(taxTotal => [
+      taxTotal.taxAmount.currencyId,
+      ...(taxTotal.taxSubtotals ?? []).flatMap(subtotal => [subtotal.taxAmount.currencyId, subtotal.taxableAmount.currencyId]),
+    ]),
+  ];
+};
+
+function evaluatePeppolEn16931CL007(document: PeppolDocument): boolean {
+  return collectCurrencies(document).every(isValidCurrency);
 }
 
 export const validatePeppolEn16931CL007 = schematronRule(rule, evaluatePeppolEn16931CL007);

package/src/schematron/peppol/f/peppol-en16931-f001.ts

@@ -15,18 +15,24 @@ const isValidDate = (value: string | undefined): boolean => value === undefined
 const encodeDateSync = Schema.encodeSync(Schema.Union([PeppolIsoDateString, Schema.String]));
 const isDate = Schema.is(PeppolIsoDateString);
 
-function evaluatePeppolEn16931F001(document: PeppolDocument): boolean {
-  const dates: Array<string | undefined> = [encodeDateSync(document.issueDate)];
-  if (Predicate.hasProperty(document, 'dueDate') && isDate(document.dueDate)) dates.push(encodeDateSync(document.dueDate));
-  if (document.taxPointDate) dates.push(encodeDateSync(document.taxPointDate));
-  if (document.invoicePeriod?.startDate) dates.push(encodeDateSync(document.invoicePeriod.startDate));
-  if (document.invoicePeriod?.endDate) dates.push(encodeDateSync(document.invoicePeriod.endDate));
-  if (document.delivery?.actualDeliveryDate) dates.push(encodeDateSync(document.delivery.actualDeliveryDate));
-  for (const line of getLines(document)) {
-    if (line.invoicePeriod?.startDate) dates.push(encodeDateSync(line.invoicePeriod.startDate));
-    if (line.invoicePeriod?.endDate) dates.push(encodeDateSync(line.invoicePeriod.endDate));
+const collectDates = (document: PeppolDocument): Array<string> => {
+  const optionalDates = [
+    document.taxPointDate,
+    document.invoicePeriod?.startDate,
+    document.invoicePeriod?.endDate,
+    document.delivery?.actualDeliveryDate,
+    ...getLines(document).flatMap(line => [line.invoicePeriod?.startDate, line.invoicePeriod?.endDate]),
+  ].filter((date): date is string => date !== undefined);
+
+  const dates = [document.issueDate, ...optionalDates].map(date => encodeDateSync(date));
+  if (Predicate.hasProperty(document, 'dueDate') && isDate(document.dueDate)) {
+    dates.push(encodeDateSync(document.dueDate));
   }
-  return dates.every(isValidDate);
+  return dates;
+};
+
+function evaluatePeppolEn16931F001(document: PeppolDocument): boolean {
+  return collectDates(document).every(isValidDate);
 }
 
 export const validatePeppolEn16931F001 = schematronRule(rule, evaluatePeppolEn16931F001);

package/src/schematron/peppol/r/peppol-en16931-r051.ts

@@ -10,20 +10,34 @@ const rule = {
     'All currencyID attributes must have the same value as the invoice currency code (BT-5), except for the invoice total VAT amount in accounting currency (BT-111).',
 } as const satisfies SchematronRule;
 
+interface CurrencyAmount {
+  currencyId: string;
+}
+
+interface AllowanceChargeAmounts {
+  amount?: CurrencyAmount | undefined;
+  baseAmount?: CurrencyAmount | undefined;
+}
+
+const matchesCurrency = (amount: CurrencyAmount | undefined, expected: string): boolean => amount?.currencyId === expected;
+
+const optionalMatchesCurrency = (amount: CurrencyAmount | undefined, expected: string): boolean =>
+  amount === undefined || matchesCurrency(amount, expected);
+
+const allowanceChargeMatchesCurrency = (allowanceCharge: AllowanceChargeAmounts, expected: string): boolean =>
+  matchesCurrency(allowanceCharge.amount, expected) && optionalMatchesCurrency(allowanceCharge.baseAmount, expected);
+
 function evaluatePeppolEn16931R051(document: PeppolDocument): boolean {
-  const documentCurrency = document.documentCurrencyCode;
-  const checkCurrency = (currencyId: string | undefined): boolean => currencyId === documentCurrency;
+  const currency = document.documentCurrencyCode;
 
-  const documentAllowancesOk = (document.allowanceCharges ?? []).every(
-    ac => checkCurrency(ac.amount?.currencyId) && (!ac.baseAmount || checkCurrency(ac.baseAmount.currencyId))
-  );
+  const documentAllowancesOk = (document.allowanceCharges ?? []).every(allowanceCharge => allowanceChargeMatchesCurrency(allowanceCharge, currency));
 
-  const linesOk = getLines(document).every(line => {
-    const lineAllowancesOk = (line.allowanceCharges ?? []).every(
-      ac => checkCurrency(ac.amount?.currencyId) && (!ac.baseAmount || checkCurrency(ac.baseAmount.currencyId))
-    );
-    return checkCurrency(line.price.priceAmount.currencyId) && checkCurrency(line.lineExtensionAmount.currencyId) && lineAllowancesOk;
-  });
+  const linesOk = getLines(document).every(
+    line =>
+      matchesCurrency(line.price.priceAmount, currency) &&
+      matchesCurrency(line.lineExtensionAmount, currency) &&
+      (line.allowanceCharges ?? []).every(allowanceCharge => allowanceChargeMatchesCurrency(allowanceCharge, currency))
+  );
 
   const taxTotalsOk = document.taxTotals.every(total => {
     // Only tax totals with subtotals are in scope for BT-110; the accounting currency total (BT-111) is excluded.
@@ -31,21 +45,27 @@ function evaluatePeppolEn16931R051(document: PeppolDocument): boolean {
       return true;
     }
     return (
-      checkCurrency(total.taxAmount.currencyId) &&
-      (total.taxSubtotals ?? []).every(st => checkCurrency(st.taxAmount.currencyId) && checkCurrency(st.taxableAmount.currencyId))
+      matchesCurrency(total.taxAmount, currency) &&
+      (total.taxSubtotals ?? []).every(subtotal => matchesCurrency(subtotal.taxAmount, currency) && matchesCurrency(subtotal.taxableAmount, currency))
     );
   });
 
   const totals = document.legalMonetaryTotal;
+  const requiredTotals: Array<CurrencyAmount> = [
+    totals.lineExtensionAmount,
+    totals.taxExclusiveAmount,
+    totals.taxInclusiveAmount,
+    totals.payableAmount,
+  ];
+  const optionalTotals: Array<CurrencyAmount | undefined> = [
+    totals.allowanceTotalAmount,
+    totals.chargeTotalAmount,
+    totals.prepaidAmount,
+    totals.payableRoundingAmount,
+  ];
+
   const totalsOk =
-    checkCurrency(totals.lineExtensionAmount.currencyId) &&
-    checkCurrency(totals.taxExclusiveAmount.currencyId) &&
-    checkCurrency(totals.taxInclusiveAmount.currencyId) &&
-    (!totals.allowanceTotalAmount || checkCurrency(totals.allowanceTotalAmount.currencyId)) &&
-    (!totals.chargeTotalAmount || checkCurrency(totals.chargeTotalAmount.currencyId)) &&
-    (!totals.prepaidAmount || checkCurrency(totals.prepaidAmount.currencyId)) &&
-    (!totals.payableRoundingAmount || checkCurrency(totals.payableRoundingAmount.currencyId)) &&
-    checkCurrency(totals.payableAmount.currencyId);
+    requiredTotals.every(amount => matchesCurrency(amount, currency)) && optionalTotals.every(amount => optionalMatchesCurrency(amount, currency));
 
   return documentAllowancesOk && linesOk && taxTotalsOk && totalsOk;
 }