@endevops/peppol-schema 0.0.1

package/src/decoders/fields/decode-party.ts

@@ -0,0 +1,63 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolContact } from '#/schemas/fields/contact-schema';
+import type { PeppolPartySchema } from '#/schemas/fields/party-base-schema';
+import type { PeppolPartyLegalEntitySchema } from '#/schemas/fields/party-legal-entity-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeAddress } from '#/decoders/fields/decode-address';
+import { decodeElectronicAddress } from '#/decoders/fields/decode-electronic-address';
+import { decodeIdentifier } from '#/decoders/fields/decode-identifier';
+import { decodePartiesTaxScheme } from '#/decoders/fields/decode-parties-tax-scheme';
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeParty(party: XmlNode | undefined): RecursivePartial<PeppolPartySchema> | undefined;
+export function decodeParty(party: XmlNode | undefined, ...path: Array<string>): RecursivePartial<PeppolPartySchema> | undefined;
+export function decodeParty(party: XmlNode | undefined, ...path: Array<string>): RecursivePartial<PeppolPartySchema> | undefined {
+  const val = getProp(party, ...path);
+  if (!val) return undefined;
+
+  return {
+    contact: decodeContact(val, 'cac:Contact'),
+    endpointId: decodeElectronicAddress(val, 'cbc:EndpointID'),
+    partyIdentification: decodeAdditionalIdentifiers(val, 'cac:PartyIdentification'),
+    partyLegalEntity: decodePartyLegalEntity(val, 'cac:PartyLegalEntity'),
+    partyName: decodePartyName(val, 'cac:PartyName'),
+    partyTaxSchemes: decodePartiesTaxScheme(val, 'cac:PartyTaxScheme'),
+    postalAddress: decodeAddress(val, 'cac:PostalAddress'),
+  };
+}
+
+function decodePartyName(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolPartySchema['partyName']> | undefined {
+  const partyNameNode = getProp(node, ...path);
+  if (!partyNameNode) return undefined;
+  return { name: strOrUnd(partyNameNode, 'cbc:Name') };
+}
+
+function decodeAdditionalIdentifiers(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolPartySchema['partyIdentification']> | undefined {
+  const val = getProp(node, ...path);
+  if (!val) return undefined;
+  return { id: decodeIdentifier(val, 'cbc:ID') };
+}
+
+function decodePartyLegalEntity(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolPartyLegalEntitySchema> | undefined {
+  const partyLegalEntityNode = getProp(node, ...path);
+  if (!partyLegalEntityNode) return undefined;
+
+  return {
+    companyId: decodeIdentifier(partyLegalEntityNode, 'cbc:CompanyID'),
+    companyLegalForm: strOrUnd(partyLegalEntityNode, 'cbc:CompanyLegalForm'),
+    registrationName: strOrUnd(partyLegalEntityNode, 'cbc:RegistrationName'),
+  };
+}
+
+function decodeContact(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolContact> | undefined {
+  const contactNode = getProp(node, ...path);
+  if (!contactNode) return undefined;
+
+  return {
+    electronicMail: strOrUnd(contactNode, 'cbc:ElectronicMail'),
+    name: strOrUnd(contactNode, 'cbc:Name'),
+    telephone: strOrUnd(contactNode, 'cbc:Telephone'),
+  };
+}

package/src/decoders/fields/decode-payee-party.ts

@@ -0,0 +1,41 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolPayeeParty } from '#/schemas/fields/payee-party';
+import type { RecursivePartial } from '#/types';
+
+import { decodeIdentifier } from '#/decoders/fields/decode-identifier';
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodePayeeParty(payee: XmlNode | undefined, ...path: Array<string>): RecursivePartial<PeppolPayeeParty> | undefined {
+  const node = getProp(payee, ...path);
+  if (!node) return undefined;
+  return {
+    partyIdentification: decodePartyIdentification(node, 'cac:PartyIdentification'),
+    partyLegalEntity: decodePartyLegalEntity(node, 'cac:PartyLegalEntity'),
+    partyName: decodePartyName(node, 'cac:PartyName'),
+  };
+}
+
+function decodePartyLegalEntity(
+  party: XmlNode | undefined,
+  ...path: Array<string>
+): RecursivePartial<PeppolPayeeParty['partyLegalEntity']> | undefined {
+  const node = getProp(party, ...path);
+  if (!node) return undefined;
+  return { companyId: decodeIdentifier(node, 'cbc:CompanyID') };
+}
+
+function decodePartyName(party: XmlNode | undefined, ...path: Array<string>): RecursivePartial<PeppolPayeeParty['partyName']> | undefined {
+  const node = getProp(party, ...path);
+  if (!node) return undefined;
+  return { name: strOrUnd(node, 'cbc:Name') };
+}
+
+function decodePartyIdentification(
+  party: XmlNode | undefined,
+  ...path: Array<string>
+): RecursivePartial<PeppolPayeeParty['partyIdentification']> | undefined {
+  const node = getProp(party, ...path);
+  if (!node) return undefined;
+  return { id: decodeIdentifier(node, 'cbc:ID') };
+}

package/src/decoders/fields/decode-payment-means.ts

@@ -0,0 +1,62 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolIdentifier } from '#/schemas/fields/identifier-schema';
+import type { PeppolPaymentMeans } from '#/schemas/fields/payment-means-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeSimpleIdentifer } from '#/decoders/fields/decode-simple-identifier';
+import { getArray } from '#/helpers/get-array';
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodePaymentMeans(doc: XmlNode, ...path: Array<string>): Array<RecursivePartial<PeppolPaymentMeans>> | undefined {
+  const arr = getArray(doc, ...path);
+  if (!arr.length) return undefined;
+
+  return arr.map(paymentMeans => {
+    const cardAccount = getProp(paymentMeans, 'cac:CardAccount');
+
+    return {
+      cardAccount: cardAccount
+        ? {
+            holderName: strOrUnd(cardAccount, 'cbc:HolderName'),
+            networkId: strOrUnd(cardAccount, 'cbc:NetworkID'),
+            primaryAccountNumberId: strOrUnd(cardAccount, 'cbc:PrimaryAccountNumberID'),
+          }
+        : undefined,
+      payeeFinancialAccount: decodePayeeFinancialAccount(paymentMeans, 'cac:PayeeFinancialAccount'),
+      paymentDueDate: strOrUnd(paymentMeans, 'cbc:PaymentDueDate'),
+      paymentId: strOrUnd(paymentMeans, 'cbc:PaymentID'),
+      paymentMandate: decodePaymentMendates(paymentMeans, 'cac:PaymentMandate'),
+      paymentMeansCode: decodePaymentMeansCodes(paymentMeans, 'cbc:PaymentMeansCode'),
+    };
+  });
+}
+
+function decodePayeeFinancialAccount(
+  doc: XmlNode,
+  ...path: Array<string>
+): RecursivePartial<PeppolPaymentMeans['payeeFinancialAccount']> | undefined {
+  const node = getProp(doc, ...path);
+  if (!node) return undefined;
+
+  let financialInstitutionBranch: RecursivePartial<PeppolIdentifier> | undefined;
+  financialInstitutionBranch = decodeSimpleIdentifer(node, 'cac:FinancialInstitutionBranch');
+  // NOTE: this 2 way comparision is necessary to ensure that `id` is null with a returned value which means that it is not direct child
+  if (financialInstitutionBranch !== undefined && !financialInstitutionBranch?.id) {
+    financialInstitutionBranch = decodeSimpleIdentifer(node, 'cac:FinancialInstitutionBranch', 'ns0:FinancialInstitution');
+  }
+  return { financialInstitutionBranch, id: strOrUnd(node, 'cbc:ID'), name: strOrUnd(node, 'cbc:Name') };
+}
+
+function decodePaymentMendates(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolPaymentMeans['paymentMandate']> | undefined {
+  const node = getProp(doc, ...path);
+  if (!node) return undefined;
+
+  return { id: strOrUnd(node, 'cbc:ID'), payerFinancialAccountId: decodeSimpleIdentifer(node, 'cac:PayerFinancialAccount') };
+}
+
+function decodePaymentMeansCodes(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolPaymentMeans['paymentMeansCode']> | undefined {
+  const node = getProp(doc, ...path);
+  if (!node) return undefined;
+  return { code: strOrUnd(node), name: strOrUnd(node, '@name') };
+}

package/src/decoders/fields/decode-payment-terms.ts

@@ -0,0 +1,13 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolPaymentTerms } from '#/schemas/fields/payment-terms-schema';
+import type { RecursivePartial } from '#/types';
+
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodePaymentTerms(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolPaymentTerms> | undefined {
+  const terms = getProp(doc, ...path);
+  if (!terms) return undefined;
+  const note = getProp(terms, 'cbc:Note');
+  return note ? { note: strOrUnd(note) } : undefined;
+}

package/src/decoders/fields/decode-price-allowance-charge.ts

@@ -0,0 +1,22 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolLinePriceAllowanceCharge } from '#/schemas/fields/line-price-allowance-charge-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeAmount } from '#/decoders/fields/decode-amount';
+import { bool } from '#/helpers/bool';
+import { getProp } from '#/helpers/get-prop';
+
+export function decodePriceAllowanceCharge(
+  allowanceCharges: XmlNode,
+  ...path: Array<string>
+): RecursivePartial<PeppolLinePriceAllowanceCharge> | undefined {
+  const allowanceCharge = getProp(allowanceCharges, ...path);
+  if (!allowanceCharge) {
+    return undefined;
+  }
+  return {
+    amount: decodeAmount(allowanceCharge, 'cbc:Amount'),
+    baseAmount: decodeAmount(allowanceCharge, 'cbc:BaseAmount'),
+    chargeIndicator: bool<false>(allowanceCharge, 'cbc:ChargeIndicator'),
+  };
+}

package/src/decoders/fields/decode-quantity.ts

@@ -0,0 +1,17 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolQuantity } from '#/schemas/fields/quantity-schema';
+import type { RecursivePartial } from '#/types';
+
+import { getProp } from '#/helpers/get-prop';
+import { numOrUnd } from '#/helpers/num-or-und';
+
+export function decodeQuantity(quantity: XmlNode | undefined): RecursivePartial<PeppolQuantity> | undefined;
+export function decodeQuantity(quantity: XmlNode | undefined, ...path: Array<string>): RecursivePartial<PeppolQuantity> | undefined;
+export function decodeQuantity(quantity: XmlNode | undefined, ...path: Array<string>): RecursivePartial<PeppolQuantity> | undefined {
+  const val = getProp(quantity, ...path);
+  if (!val && val !== 0) return undefined;
+  if (typeof val === 'object') {
+    return { unitCode: getProp(val, '@unitCode'), value: numOrUnd(val) };
+  }
+  return { value: numOrUnd(val) };
+}

package/src/decoders/fields/decode-simple-identifier.ts

@@ -0,0 +1,12 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { RecursivePartial } from '#/types';
+
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeSimpleIdentifer(doc: XmlNode, ...path: Array<string>): RecursivePartial<{ id: string }> | undefined {
+  const node = getProp(doc, ...path);
+  if (!node) return undefined;
+
+  return { id: strOrUnd(node, 'cbc:ID') };
+}

package/src/decoders/fields/decode-tax-category.ts

@@ -0,0 +1,21 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolAllowanceCharge } from '#/schemas/fields/allowance-charge-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeSimpleIdentifer } from '#/decoders/fields/decode-simple-identifier';
+import { getProp } from '#/helpers/get-prop';
+import { numOrUnd } from '#/helpers/num-or-und';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeTaxCategory(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolAllowanceCharge['taxCategory']> | undefined {
+  const taxCategory = getProp(doc, ...path);
+  if (!taxCategory) {
+    return undefined;
+  }
+
+  return {
+    id: strOrUnd(taxCategory, 'cbc:ID'),
+    percent: numOrUnd(taxCategory, 'cbc:Percent'),
+    taxSchemeId: decodeSimpleIdentifer(taxCategory, 'cac:TaxScheme'),
+  };
+}

package/src/decoders/fields/decode-tax-representative-party.ts

@@ -0,0 +1,19 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolTaxRepresentativeParty } from '#/schemas/fields/tax-representative-party-schema';
+import type { RecursivePartial } from '#/types';
+
+import { decodeAddress } from '#/decoders/fields/decode-address';
+import { decodePartyTaxScheme } from '#/decoders/fields/decode-party-tax-scheme';
+import { getProp } from '#/helpers/get-prop';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeTaxRepresentativeParty(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolTaxRepresentativeParty> | undefined {
+  const taxRepresentative = getProp(doc, ...path);
+  if (!taxRepresentative) return undefined;
+
+  return {
+    name: strOrUnd(taxRepresentative, 'cac:PartyName', 'cbc:Name'),
+    partyTaxScheme: decodePartyTaxScheme(taxRepresentative, 'cac:PartyTaxScheme'),
+    postalAddress: decodeAddress(taxRepresentative, 'cac:PostalAddress'),
+  };
+}

package/src/decoders/fields/decode-tax-totals.ts

@@ -0,0 +1,43 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolTaxSubTotal } from '#/schemas/fields/tax-subtotal-schema';
+import type { PeppolTaxTotal } from '#/schemas/fields/tax-totals';
+import type { RecursivePartial } from '#/types';
+
+import { decodeAmount } from '#/decoders/fields/decode-amount';
+import { decodeSimpleIdentifer } from '#/decoders/fields/decode-simple-identifier';
+import { getArray } from '#/helpers/get-array';
+import { getProp } from '#/helpers/get-prop';
+import { numOrUnd } from '#/helpers/num-or-und';
+import { strOrUnd } from '#/helpers/str-or-und';
+
+export function decodeTaxTotals(doc: XmlNode, ...path: Array<string>): Array<RecursivePartial<PeppolTaxTotal>> | undefined {
+  const arr = getArray(doc, ...path);
+  if (!arr.length) return undefined;
+
+  return arr.map(n => ({ taxAmount: decodeAmount(n, 'cbc:TaxAmount'), taxSubtotals: decodeTaxSubTotal(n, 'cac:TaxSubtotal') }));
+}
+
+function decodeTaxSubTotal(doc: XmlNode, ...path: Array<string>): Array<RecursivePartial<PeppolTaxSubTotal>> | undefined {
+  const arr = getArray(doc, ...path);
+  if (!arr.length) return undefined;
+  return arr.map(node => ({
+    taxAmount: decodeAmount(node, 'cbc:TaxAmount'),
+    taxCategory: decodeTaxCategory(node, 'cac:TaxCategory'),
+    taxableAmount: decodeAmount(node, 'cbc:TaxableAmount'),
+  }));
+}
+
+function decodeTaxCategory(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolTaxSubTotal['taxCategory']> | undefined {
+  const node = getProp(doc, ...path);
+  if (!node) {
+    return undefined;
+  }
+
+  return {
+    id: strOrUnd(node, 'cbc:ID'),
+    percent: numOrUnd(node, 'cbc:Percent'),
+    taxExemptionReason: strOrUnd(node, 'cbc:TaxExemptionReason'),
+    taxExemptionReasonCode: strOrUnd(node, 'cbc:TaxExemptionReasonCode'),
+    taxSchemeId: decodeSimpleIdentifer(node, 'cac:TaxScheme'),
+  };
+}

package/src/decoders/fields/encode-additional-document-references.ts

@@ -0,0 +1,26 @@
+import type { PeppolAdditionalDocumentReference } from '#/schemas/fields/additional-document-reference-schema';
+
+import { encodeIdentifier } from '#/decoders/fields/encode-identifier';
+
+export function encodeAdditionalDocumentReferences(refs: Array<PeppolAdditionalDocumentReference> | undefined) {
+  return refs?.map(ref => ({
+    'cbc:ID': encodeIdentifier(ref.id),
+    'cbc:DocumentTypeCode': ref.documentTypeCode,
+    'cbc:DocumentDescription': ref.documentDescription,
+    'cac:Attachment': encodeAttachment(ref.attachment),
+  }));
+}
+
+function encodeAttachment(attachment: PeppolAdditionalDocumentReference['attachment'] | undefined) {
+  if (!attachment) return undefined;
+  return {
+    'cac:ExternalReference': attachment.externalReference ? { 'cbc:URI': attachment.externalReference.uri } : undefined,
+    'cbc:EmbeddedDocumentBinaryObject': attachment.embeddedDocumentBinaryObject
+      ? {
+          '#text': attachment.embeddedDocumentBinaryObject.content,
+          '@filename': attachment.embeddedDocumentBinaryObject.filename,
+          '@mimeCode': attachment.embeddedDocumentBinaryObject.mimeCode,
+        }
+      : undefined,
+  };
+}

package/src/decoders/fields/encode-address.ts

@@ -0,0 +1,15 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolAddress } from '#/schemas/fields/address-schema';
+
+export function encodeAddress(address?: PeppolAddress): XmlNode {
+  if (!address) return undefined;
+  return {
+    'cbc:StreetName': address.streetName,
+    'cbc:AdditionalStreetName': address.additionalStreetName,
+    'cbc:CityName': address.cityName,
+    'cbc:PostalZone': address.postalZone,
+    'cbc:CountrySubentity': address.countrySubentity,
+    'cac:AddressLine': address.addressLine?.line ? { 'cbc:Line': address.addressLine.line } : undefined,
+    'cac:Country': { 'cbc:IdentificationCode': address.countryCode.identificationCode },
+  };
+}

package/src/decoders/fields/encode-allowance-charges.ts

@@ -0,0 +1,16 @@
+import type { PeppolAllowanceCharge } from '#/schemas/fields/allowance-charge-schema';
+
+import { encodeAmount } from '#/decoders/fields/encode-amount';
+import { encodeTaxCategory } from '#/decoders/fields/encode-tax-category';
+
+export function encodeAllowanceCharges(allowanceCharges: Array<PeppolAllowanceCharge> | undefined) {
+  return allowanceCharges?.map(allowanceCharge => ({
+    'cbc:ChargeIndicator': allowanceCharge.chargeIndicator,
+    'cbc:AllowanceChargeReasonCode': allowanceCharge.allowanceChargeReasonCode,
+    'cbc:AllowanceChargeReason': allowanceCharge.allowanceChargeReason,
+    'cbc:MultiplierFactorNumeric': allowanceCharge.multiplierFactorNumeric,
+    'cbc:Amount': encodeAmount(allowanceCharge.amount),
+    'cbc:BaseAmount': encodeAmount(allowanceCharge.baseAmount),
+    'cac:TaxCategory': encodeTaxCategory(allowanceCharge.taxCategory),
+  }));
+}

package/src/decoders/fields/encode-amount.ts

@@ -0,0 +1,6 @@
+import type { PeppolAmount } from '#/schemas/fields/amount-schema';
+
+export function encodeAmount(amount?: PeppolAmount) {
+  if (!amount) return undefined;
+  return { '#text': amount.value, '@currencyID': amount.currencyId };
+}

package/src/decoders/fields/encode-billing-references.ts

@@ -0,0 +1,10 @@
+import type { PeppolBillingReference } from '#/schemas/fields/billing-references-schema';
+
+export function encodeBillingReferences(billingReferences: Array<PeppolBillingReference> | undefined) {
+  return billingReferences?.map(billingReference => ({
+    'cac:InvoiceDocumentReference': {
+      'cbc:ID': billingReference.invoiceDocumentReference.id,
+      'cbc:IssueDate': billingReference.invoiceDocumentReference.issueDate,
+    },
+  }));
+}

package/src/decoders/fields/encode-credit-note-lines.ts

@@ -0,0 +1,9 @@
+import type { PeppolCreditNoteLine } from '#/schemas/fields/credit-note-line-schema';
+
+import { encodeLineShared } from '#/decoders/fields/encode-line-shared';
+
+export function encodeCreditNoteLines(creditNoteLines: Array<PeppolCreditNoteLine>) {
+  if (!creditNoteLines.length) return undefined;
+
+  return creditNoteLines.map(encodeLineShared);
+}

package/src/decoders/fields/encode-delivery.ts

@@ -0,0 +1,21 @@
+import type { PeppolDelivery } from '#/schemas/fields/delivery-schema';
+
+import { encodeAddress } from '#/decoders/fields/encode-address';
+import { encodeIdentifier } from '#/decoders/fields/encode-identifier';
+
+export function encodeDelivery(delivery: PeppolDelivery | undefined) {
+  if (!delivery) return undefined;
+
+  return {
+    'cbc:ActualDeliveryDate': delivery.actualDeliveryDate,
+    'cac:DeliveryLocation': encodeDeliveryLocation(delivery.deliveryLocation),
+    'cac:DeliveryParty': delivery.deliveryParty?.partyName.name
+      ? { 'cac:PartyName': { 'cbc:Name': delivery.deliveryParty?.partyName.name } }
+      : undefined,
+  };
+}
+
+function encodeDeliveryLocation(location: PeppolDelivery['deliveryLocation']) {
+  if (!location) return undefined;
+  return { 'cbc:ID': encodeIdentifier(location.id), 'cac:Address': encodeAddress(location.address) };
+}

package/src/decoders/fields/encode-identifier.ts

@@ -0,0 +1,7 @@
+import type { PeppolIdentifier } from '#/schemas/fields/identifier-schema';
+
+export function encodeIdentifier(id?: PeppolIdentifier) {
+  if (!id) return undefined;
+  if (!id.schemeId) return id.id;
+  return { '#text': id.id, '@schemeID': id.schemeId };
+}

package/src/decoders/fields/encode-invoice-line-period.ts

@@ -0,0 +1,5 @@
+import type { PeppolInvoiceLinePeriod } from '#/schemas/fields/invoice-line-period-schema';
+
+export function encodeInvoiceLinePeriod(invoicePeriod: PeppolInvoiceLinePeriod | undefined) {
+  return invoicePeriod ? { 'cbc:StartDate': invoicePeriod.startDate, 'cbc:EndDate': invoicePeriod.endDate } : undefined;
+}

package/src/decoders/fields/encode-invoice-lines.ts

@@ -0,0 +1,9 @@
+import type { PeppolInvoiceLine } from '#/schemas/fields/invoice-line-schema';
+
+import { encodeLineShared } from '#/decoders/fields/encode-line-shared';
+
+export function encodeInvoiceLines(invoiceLines: Array<PeppolInvoiceLine>) {
+  if (!invoiceLines.length) return undefined;
+
+  return invoiceLines.map(encodeLineShared);
+}

package/src/decoders/fields/encode-invoice-period.ts

@@ -0,0 +1,7 @@
+import type { PeppolInvoicePeriod } from '#/schemas/fields/invoice-period-schema';
+
+export function encodeInvoicePeriod(invoicePeriod: PeppolInvoicePeriod | undefined) {
+  return invoicePeriod
+    ? { 'cbc:StartDate': invoicePeriod.startDate, 'cbc:EndDate': invoicePeriod.endDate, 'cbc:DescriptionCode': invoicePeriod.descriptionCode }
+    : undefined;
+}

package/src/decoders/fields/encode-legal-monetary-total.ts

@@ -0,0 +1,16 @@
+import type { PeppolLegalMonetaryTotal } from '#/schemas/fields/legal-monetary-total-schema';
+
+import { encodeAmount } from '#/decoders/fields/encode-amount';
+
+export function encodeLegalMonetaryTotal(legalMonetaryTotal: PeppolLegalMonetaryTotal) {
+  return {
+    'cbc:LineExtensionAmount': encodeAmount(legalMonetaryTotal.lineExtensionAmount),
+    'cbc:TaxExclusiveAmount': encodeAmount(legalMonetaryTotal.taxExclusiveAmount),
+    'cbc:TaxInclusiveAmount': encodeAmount(legalMonetaryTotal.taxInclusiveAmount),
+    'cbc:AllowanceTotalAmount': encodeAmount(legalMonetaryTotal.allowanceTotalAmount),
+    'cbc:ChargeTotalAmount': encodeAmount(legalMonetaryTotal.chargeTotalAmount),
+    'cbc:PrepaidAmount': encodeAmount(legalMonetaryTotal.prepaidAmount),
+    'cbc:PayableRoundingAmount': encodeAmount(legalMonetaryTotal.payableRoundingAmount),
+    'cbc:PayableAmount': encodeAmount(legalMonetaryTotal.payableAmount),
+  };
+}

package/src/decoders/fields/encode-line-allowance-charges.ts

@@ -0,0 +1,14 @@
+import type { PeppolLineAllowanceCharge } from '#/schemas/fields/line-allowance-charge-schema';
+
+import { encodeAmount } from '#/decoders/fields/encode-amount';
+
+export function encodeLineAllowanceCharges(allowanceCharges: Array<PeppolLineAllowanceCharge> | undefined) {
+  return allowanceCharges?.map(allowanceCharge => ({
+    'cbc:ChargeIndicator': allowanceCharge.chargeIndicator,
+    'cbc:AllowanceChargeReasonCode': allowanceCharge.allowanceChargeReasonCode,
+    'cbc:AllowanceChargeReason': allowanceCharge.allowanceChargeReason,
+    'cbc:MultiplierFactorNumeric': allowanceCharge.multiplierFactorNumeric,
+    'cbc:Amount': encodeAmount(allowanceCharge.amount),
+    'cbc:BaseAmount': encodeAmount(allowanceCharge.baseAmount),
+  }));
+}

package/src/decoders/fields/encode-line-price.ts

@@ -0,0 +1,16 @@
+import type { PeppolLinePrice } from '#/schemas/fields/price-schema';
+
+import { encodeAmount } from '#/decoders/fields/encode-amount';
+import { encodePriceAllowanceCharges } from '#/decoders/fields/encode-price-allowance-charges';
+import { encodeQuantity } from '#/decoders/fields/encode-quantity';
+
+export function encodeLinePrice(price: PeppolLinePrice | undefined) {
+  if (!price) {
+    return undefined;
+  }
+  return {
+    'cbc:PriceAmount': encodeAmount(price.priceAmount),
+    'cbc:BaseQuantity': encodeQuantity(price.baseQuantity),
+    'cac:AllowanceCharge': encodePriceAllowanceCharges(price.allowanceCharge),
+  };
+}

package/src/decoders/fields/encode-line-shared.ts

@@ -0,0 +1,50 @@
+import type { PeppolDocumentLine } from '#/document';
+
+import { encodeAmount } from '#/decoders/fields/encode-amount';
+import { encodeIdentifier } from '#/decoders/fields/encode-identifier';
+import { encodeInvoiceLinePeriod } from '#/decoders/fields/encode-invoice-line-period';
+import { encodeLineAllowanceCharges } from '#/decoders/fields/encode-line-allowance-charges';
+import { encodeLinePrice } from '#/decoders/fields/encode-line-price';
+import { encodeQuantity } from '#/decoders/fields/encode-quantity';
+import { encodeSimpleIdentifier } from '#/decoders/fields/encode-simple-identifier';
+import { encodeTaxCategory } from '#/decoders/fields/encode-tax-category';
+
+export function encodeLineShared(lineShared: PeppolDocumentLine) {
+  return {
+    'cbc:ID': lineShared.id,
+    'cbc:Note': lineShared.note,
+    'cbc:InvoicedQuantity': 'invoicedQuantity' in lineShared ? encodeQuantity(lineShared.invoicedQuantity) : undefined,
+    'cbc:CreditedQuantity': 'creditedQuantity' in lineShared ? encodeQuantity(lineShared.creditedQuantity) : undefined,
+    'cbc:LineExtensionAmount': encodeAmount(lineShared.lineExtensionAmount),
+    'cbc:AccountingCost': lineShared.accountingCost,
+    'cac:InvoicePeriod': encodeInvoiceLinePeriod(lineShared.invoicePeriod),
+    'cac:OrderLineReference': lineShared.orderLineReference ? { 'cbc:LineID': lineShared.orderLineReference.lineId } : undefined,
+    'cac:DocumentReference': lineShared.documentReference?.map(documentReference => ({
+      'cbc:DocumentTypeCode': documentReference.documentTypeCode,
+      'cbc:ID': encodeIdentifier(documentReference),
+    })),
+    'cac:AllowanceCharge': encodeLineAllowanceCharges(lineShared.allowanceCharges),
+    'cac:Item': {
+      'cbc:Description': lineShared.item.description,
+      'cbc:Name': lineShared.item.name,
+      'cac:BuyersItemIdentification': encodeSimpleIdentifier(lineShared.item.buyersItemIdentification),
+      'cac:SellersItemIdentification': encodeSimpleIdentifier(lineShared.item.sellersItemIdentification),
+      'cac:StandardItemIdentification': lineShared.item.standardItemIdentification
+        ? { 'cbc:ID': encodeIdentifier(lineShared.item.standardItemIdentification.id) }
+        : undefined,
+      'cac:OriginCountry': lineShared.item.originCountryCode
+        ? { 'cbc:IdentificationCode': lineShared.item.originCountryCode.identificationCode }
+        : undefined,
+      'cac:CommodityClassification': lineShared.item.commodityClassifications?.map(c => ({
+        'cbc:ItemClassificationCode': {
+          '#text': c.itemClassification.id,
+          '@listID': c.itemClassification.listId,
+          '@listVersionID': c.itemClassification.listVersionId,
+        },
+      })),
+      'cac:ClassifiedTaxCategory': encodeTaxCategory(lineShared.item.classifiedTaxCategory),
+      'cac:AdditionalItemProperty': lineShared.item.additionalItemProperties?.map(p => ({ 'cbc:Name': p.name, 'cbc:Value': p.value })),
+    },
+    'cac:Price': encodeLinePrice(lineShared.price),
+  };
+}

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

@@ -0,0 +1,32 @@
+import type { PeppolContact } from '#/schemas/fields/contact-schema';
+import type { PeppolPartyLegalEntitySchema } from '#/schemas/fields/party-legal-entity-schema';
+import type { InvoiceDocumentResponseParty, InvoiceResponseParty } from '#/schemas/invoice-response-schema';
+import type { PeppolMessageLevelResponseParty } from '#/schemas/message-level-response-party-schema';
+
+import { encodeIdentifier } from '#/decoders/fields/encode-identifier';
+
+export function encodeMessageParty(party?: PeppolMessageLevelResponseParty | InvoiceResponseParty | InvoiceDocumentResponseParty) {
+  if (!party) return undefined;
+  return {
+    'cbc:EndpointID': 'endpointId' in party && party.endpointId ? encodeIdentifier(party.endpointId) : undefined,
+    'cac:PartyIdentification':
+      'partyIdentification' in party && party.partyIdentification ? { 'cbc:ID': encodeIdentifier(party.partyIdentification) } : undefined,
+    'cac:PartyName': 'partyName' in party && party.partyName ? { 'cbc:Name': party.partyName.name } : undefined,
+    'cac:PartyLegalEntity': 'partyLegalEntity' in party ? encodePartyLegalEntity(party.partyLegalEntity) : undefined,
+    'cac:Contact': 'contact' in party ? encodeContact(party.contact) : undefined,
+  };
+}
+
+function encodePartyLegalEntity(legalEntity: PeppolPartyLegalEntitySchema) {
+  return {
+    'cbc:RegistrationName': legalEntity.registrationName,
+    'cbc:CompanyID': encodeIdentifier(legalEntity.companyId),
+    'cbc:CompanyLegalForm': legalEntity.companyLegalForm,
+  };
+}
+
+function encodeContact(contact: PeppolContact | undefined) {
+  if (!contact) return undefined;
+
+  return { 'cbc:Name': contact.name, 'cbc:Telephone': contact.telephone, 'cbc:ElectronicMail': contact.electronicMail };
+}

package/src/decoders/fields/encode-order-reference.ts

@@ -0,0 +1,7 @@
+import type { PeppolOrderReference } from '#/schemas/fields/order-reference-schema';
+
+export function encodeOrderReference(orderReference: PeppolOrderReference | undefined) {
+  if (!orderReference) return undefined;
+
+  return { 'cbc:ID': orderReference.id, 'cbc:SalesOrderID': orderReference.salesOrderId };
+}

package/src/decoders/fields/encode-parties-tax-scheme.ts

@@ -0,0 +1,10 @@
+import type { XmlNode } from '#/helpers/get-prop';
+import type { PeppolPartyTaxSchema } from '#/schemas/fields/party-tax-schema';
+
+import { encodePartyTaxScheme } from '#/decoders/fields/encode-party-tax-scheme';
+
+export function encodePartiesTaxScheme(partiesTaxScheme: Array<PeppolPartyTaxSchema> | undefined): XmlNode {
+  if (!partiesTaxScheme?.length) return undefined;
+
+  return partiesTaxScheme.map(partyTaxScheme => encodePartyTaxScheme(partyTaxScheme));
+}