@endevops/peppol-schema 0.1.0-beta.2 → 0.1.0-beta.3

package/src/decoders/encode-invoice-response.ts

@@ -1,9 +1,11 @@
+import { Effect, Predicate } from 'effect';
+
 import type { InvoiceResponseDocumentReference, InvoiceResponseDocumentResponse } from '#/schemas/invoice-response-schema';
 import type { PeppolInvoiceResponse } from '#/schemas/invoice-response-schema';
 
 import { encodeMessageParty } from '#/decoders/fields/encode-message-party';
 
-export function encodeInvoiceResponse(invoiceResponse: PeppolInvoiceResponse) {
+export const encodeInvoiceResponse = Effect.fn(function* (invoiceResponse: PeppolInvoiceResponse) {
   return {
     '?xml': { '@version': '1.0', '@encoding': 'UTF-8' },
     ApplicationResponse: {
@@ -21,15 +23,15 @@ export function encodeInvoiceResponse(invoiceResponse: PeppolInvoiceResponse) {
       'cbc:IssueDate': invoiceResponse.issueDate,
       'cbc:IssueTime': invoiceResponse.issueTime,
       'cbc:Note': invoiceResponse.note,
-      'cac:SenderParty': encodeMessageParty(invoiceResponse.senderParty),
-      'cac:ReceiverParty': encodeMessageParty(invoiceResponse.receiverParty),
-      'cac:DocumentResponse': encodeDocumentResponse(invoiceResponse.documentResponse),
+      'cac:SenderParty': yield* encodeMessageParty(invoiceResponse.senderParty),
+      'cac:ReceiverParty': yield* encodeMessageParty(invoiceResponse.receiverParty),
+      'cac:DocumentResponse': yield* encodeDocumentResponse(invoiceResponse.documentResponse),
     },
   };
-}
+});
 
-function encodeDocumentResponse(documentResponse: InvoiceResponseDocumentResponse) {
-  if (!documentResponse) {
+const encodeDocumentResponse = Effect.fn(function* (documentResponse: InvoiceResponseDocumentResponse) {
+  if (Predicate.isNullish(documentResponse)) {
     return undefined;
   }
   return {
@@ -37,20 +39,20 @@ function encodeDocumentResponse(documentResponse: InvoiceResponseDocumentRespons
       'cbc:ResponseCode': documentResponse.response.responseCode,
       'cbc:EffectiveDate': documentResponse.response.effectiveDate,
       'cac:Status': documentResponse.response.status?.map(status => ({
-        'cbc:StatusReasonCode': status.statusReasonCode
+        'cbc:StatusReasonCode': Predicate.isNotNullish(status.statusReasonCode)
           ? { '#text': status.statusReasonCode.value, '@listID': status.statusReasonCode.listId }
           : undefined,
         'cbc:StatusReason': status.statusReason,
         'cac:Condition': status.condition?.map(condition => ({ 'cbc:AttributeID': condition.attributeId, 'cbc:Description': condition.description })),
       })),
     },
-    'cac:DocumentReference': encodeDocumentReference(documentResponse.documentReference),
-    'cac:IssuerParty': encodeMessageParty(documentResponse.issuerParty),
-    'cac:RecipientParty': encodeMessageParty(documentResponse.recipientParty),
+    'cac:DocumentReference': yield* encodeDocumentReference(documentResponse.documentReference),
+    'cac:IssuerParty': yield* encodeMessageParty(documentResponse.issuerParty),
+    'cac:RecipientParty': yield* encodeMessageParty(documentResponse.recipientParty),
   };
-}
+});
 
-function encodeDocumentReference(documentReference: InvoiceResponseDocumentReference) {
-  if (!documentReference) return undefined;
+const encodeDocumentReference = Effect.fn(function* (documentReference: InvoiceResponseDocumentReference) {
+  if (Predicate.isNullish(documentReference)) return undefined;
   return { 'cbc:ID': documentReference.id, 'cbc:IssueDate': documentReference.issueDate, 'cbc:DocumentTypeCode': documentReference.documentTypeCode };
-}
+});

package/src/decoders/encode-invoice.ts

@@ -1,3 +1,5 @@
+import { Effect } from 'effect';
+
 import type { PeppolInvoice } from '#/schemas/invoice';
 
 import { encodeAdditionalDocumentReferences } from '#/decoders/fields/encode-additional-document-references';
@@ -16,7 +18,7 @@ import { encodeSimpleIdentifier } from '#/decoders/fields/encode-simple-identifi
 import { encodeTaxRepresentativeParty } from '#/decoders/fields/encode-tax-representative-party';
 import { encodeTaxTotals } from '#/decoders/fields/encode-tax-totals';
 
-export function encodeInvoice(invoice: PeppolInvoice) {
+export const encodeInvoice = Effect.fn(function* (invoice: PeppolInvoice) {
   return {
     '?xml': { '@version': '1.0', '@encoding': 'UTF-8' },
     Invoice: {
@@ -36,26 +38,26 @@ export function encodeInvoice(invoice: PeppolInvoice) {
       'cbc:TaxCurrencyCode': invoice.taxCurrencyCode,
       'cbc:AccountingCost': invoice.accountingCost,
       'cbc:BuyerReference': invoice.buyerReference,
-      'cac:InvoicePeriod': encodeInvoicePeriod(invoice.invoicePeriod),
-      'cac:OrderReference': encodeOrderReference(invoice.orderReference),
-      'cac:BillingReference': encodeBillingReferences(invoice.billingReferences),
-      'cac:DespatchDocumentReference': encodeSimpleIdentifier(invoice.despatchDocumentReference),
-      'cac:ReceiptDocumentReference': encodeSimpleIdentifier(invoice.receiptDocumentReference),
-      'cac:OriginatorDocumentReference': encodeSimpleIdentifier(invoice.originatorDocumentReference),
-      'cac:ContractDocumentReference': encodeSimpleIdentifier(invoice.contractDocumentReference),
-      'cac:AdditionalDocumentReference': encodeAdditionalDocumentReferences(invoice.additionalDocumentReferences),
-      'cac:ProjectReference': encodeSimpleIdentifier(invoice.projectReference),
-      'cac:AccountingSupplierParty': encodeParty(invoice.accountingSupplierParty),
-      'cac:AccountingCustomerParty': encodeParty(invoice.accountingCustomerParty),
-      'cac:PayeeParty': encodePayeeParty(invoice.payeeParty),
-      'cac:TaxRepresentativeParty': encodeTaxRepresentativeParty(invoice.taxRepresentativeParty),
-      'cac:Delivery': encodeDelivery(invoice.delivery),
-      'cac:PaymentMeans': encodePaymentMeans(invoice.paymentMeans),
-      'cac:PaymentTerms': encodePaymentTerms(invoice.paymentTerms),
-      'cac:AllowanceCharge': encodeAllowanceCharges(invoice.allowanceCharges),
-      'cac:TaxTotal': encodeTaxTotals(invoice.taxTotals),
-      'cac:LegalMonetaryTotal': encodeLegalMonetaryTotal(invoice.legalMonetaryTotal),
-      'cac:InvoiceLine': encodeInvoiceLines(invoice.invoiceLines),
+      'cac:InvoicePeriod': yield* encodeInvoicePeriod(invoice.invoicePeriod),
+      'cac:OrderReference': yield* encodeOrderReference(invoice.orderReference),
+      'cac:BillingReference': yield* encodeBillingReferences(invoice.billingReferences),
+      'cac:DespatchDocumentReference': yield* encodeSimpleIdentifier(invoice.despatchDocumentReference),
+      'cac:ReceiptDocumentReference': yield* encodeSimpleIdentifier(invoice.receiptDocumentReference),
+      'cac:OriginatorDocumentReference': yield* encodeSimpleIdentifier(invoice.originatorDocumentReference),
+      'cac:ContractDocumentReference': yield* encodeSimpleIdentifier(invoice.contractDocumentReference),
+      'cac:AdditionalDocumentReference': yield* encodeAdditionalDocumentReferences(invoice.additionalDocumentReferences),
+      'cac:ProjectReference': yield* encodeSimpleIdentifier(invoice.projectReference),
+      'cac:AccountingSupplierParty': yield* encodeParty(invoice.accountingSupplierParty),
+      'cac:AccountingCustomerParty': yield* encodeParty(invoice.accountingCustomerParty),
+      'cac:PayeeParty': yield* encodePayeeParty(invoice.payeeParty),
+      'cac:TaxRepresentativeParty': yield* encodeTaxRepresentativeParty(invoice.taxRepresentativeParty),
+      'cac:Delivery': yield* encodeDelivery(invoice.delivery),
+      'cac:PaymentMeans': yield* encodePaymentMeans(invoice.paymentMeans),
+      'cac:PaymentTerms': yield* encodePaymentTerms(invoice.paymentTerms),
+      'cac:AllowanceCharge': yield* encodeAllowanceCharges(invoice.allowanceCharges),
+      'cac:TaxTotal': yield* encodeTaxTotals(invoice.taxTotals),
+      'cac:LegalMonetaryTotal': yield* encodeLegalMonetaryTotal(invoice.legalMonetaryTotal),
+      'cac:InvoiceLine': yield* encodeInvoiceLines(invoice.invoiceLines),
     },
   };
-}
+});

package/src/decoders/encode-message-level-response.ts

@@ -1,9 +1,12 @@
+import { Effect, Predicate } from 'effect';
+
 import type { PeppolMessageLevelMessageLevelResponseDocumentResponse } from '#/schemas/message-level-response-document-response-schema';
 import type { PeppolMessageLevelResponse } from '#/schemas/message-level-response-schema';
 
+import { PeppolEncodeError } from '#/decoders/errors';
 import { encodeMessageParty } from '#/decoders/fields/encode-message-party';
 
-export function encodeMessageLevelResponse(messageResponse: PeppolMessageLevelResponse) {
+export const encodeMessageLevelResponse = Effect.fn(function* (messageResponse: PeppolMessageLevelResponse) {
   return {
     '?xml': { '@version': '1.0', '@encoding': 'UTF-8' },
     ApplicationResponse: {
@@ -20,14 +23,19 @@ export function encodeMessageLevelResponse(messageResponse: PeppolMessageLevelRe
       'cbc:ID': messageResponse.id,
       'cbc:IssueDate': messageResponse.issueDate,
       'cbc:IssueTime': messageResponse.issueTime,
-      'cac:SenderParty': encodeMessageParty(messageResponse.senderParty),
-      'cac:ReceiverParty': encodeMessageParty(messageResponse.receiverParty),
-      'cac:DocumentResponse': encodeMessageLevelDocumentResponse(messageResponse.documentResponse),
+      'cac:SenderParty': yield* encodeMessageParty(messageResponse.senderParty),
+      'cac:ReceiverParty': yield* encodeMessageParty(messageResponse.receiverParty),
+      'cac:DocumentResponse': yield* encodeMessageLevelDocumentResponse(messageResponse.documentResponse),
     },
   };
-}
+});
 
-function encodeMessageLevelDocumentResponse(documentResponse: PeppolMessageLevelMessageLevelResponseDocumentResponse) {
+const encodeMessageLevelDocumentResponse = Effect.fn(function* (
+  documentResponse: PeppolMessageLevelMessageLevelResponseDocumentResponse | undefined
+) {
+  if (Predicate.isNullish(documentResponse)) {
+    return yield* new PeppolEncodeError({ message: 'Cannot encode a message level response without a document response' });
+  }
   return {
     'cac:Response': { 'cbc:ResponseCode': documentResponse.response.responseCode, 'cbc:Description': documentResponse.response.description },
     'cac:DocumentReference': {
@@ -44,4 +52,4 @@ function encodeMessageLevelDocumentResponse(documentResponse: PeppolMessageLevel
       },
     })),
   };
-}
+});

package/src/decoders/errors.ts

@@ -0,0 +1,11 @@
+import { Schema } from 'effect';
+
+/**
+ * @description Raised when a PEPPOL document cannot be decoded from its XML node representation.
+ */
+export class PeppolDecodeError extends Schema.TaggedError<PeppolDecodeError>()('PeppolDecodeError', { message: Schema.String }) {}
+
+/**
+ * @description Raised when a PEPPOL document cannot be encoded into its XML node representation.
+ */
+export class PeppolEncodeError extends Schema.TaggedError<PeppolEncodeError>()('PeppolEncodeError', { message: Schema.String }) {}

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

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolAdditionalDocumentReference } from '#/schemas/fields/additional-document-reference-schema';
 import type { RecursivePartial } from '#/types';
@@ -7,32 +9,37 @@ import { getArray } from '#/helpers/get-array';
 import { getProp } from '#/helpers/get-prop';
 import { strOrUnd } from '#/helpers/str-or-und';
 
-export function decodeAdditionalDocumentReferences(doc: XmlNode): Array<RecursivePartial<PeppolAdditionalDocumentReference>> | undefined {
-  const arr = getArray(doc, 'cac:AdditionalDocumentReference');
+export const decodeAdditionalDocumentReferences = Effect.fn(function* (
+  doc: XmlNode
+): Effect.fn.Return<Array<RecursivePartial<PeppolAdditionalDocumentReference>> | undefined> {
+  const arr = yield* getArray(doc, 'cac:AdditionalDocumentReference');
   if (arr.length === 0) {
     return undefined;
   }
 
-  return arr.map(additionalDocumentReference => {
-    const attachment = getProp(additionalDocumentReference, 'cac:Attachment');
-    const embeddedDocumentBinaryObject = getProp(attachment, 'cbc:EmbeddedDocumentBinaryObject');
-    const externalReference = getProp(attachment, 'cac:ExternalReference');
-    return {
-      attachment: attachment
-        ? {
-            embeddedDocumentBinaryObject: embeddedDocumentBinaryObject
-              ? {
-                  content: strOrUnd(embeddedDocumentBinaryObject),
-                  filename: strOrUnd(embeddedDocumentBinaryObject, '@filename'),
-                  mimeCode: strOrUnd(embeddedDocumentBinaryObject, '@mimeCode'),
-                }
-              : undefined,
-            externalReference: externalReference ? { uri: strOrUnd(externalReference, 'cbc:URI') } : undefined,
-          }
-        : undefined,
-      documentDescription: strOrUnd(additionalDocumentReference, 'cbc:DocumentDescription'),
-      documentTypeCode: strOrUnd(additionalDocumentReference, 'cbc:DocumentTypeCode'),
-      id: decodeIdentifier(additionalDocumentReference, 'cbc:ID'),
-    };
-  });
-}
+  return yield* Effect.forEach(
+    arr,
+    Effect.fn(function* (additionalDocumentReference: XmlNode) {
+      const attachment = yield* getProp(additionalDocumentReference, 'cac:Attachment');
+      const embeddedDocumentBinaryObject = yield* getProp(attachment, 'cbc:EmbeddedDocumentBinaryObject');
+      const externalReference = yield* getProp(attachment, 'cac:ExternalReference');
+      return {
+        attachment: Predicate.isNotNullish(attachment)
+          ? {
+              embeddedDocumentBinaryObject: Predicate.isNotNullish(embeddedDocumentBinaryObject)
+                ? {
+                    content: yield* strOrUnd(embeddedDocumentBinaryObject),
+                    filename: yield* strOrUnd(embeddedDocumentBinaryObject, '@filename'),
+                    mimeCode: yield* strOrUnd(embeddedDocumentBinaryObject, '@mimeCode'),
+                  }
+                : undefined,
+              externalReference: Predicate.isNotNullish(externalReference) ? { uri: yield* strOrUnd(externalReference, 'cbc:URI') } : undefined,
+            }
+          : undefined,
+        documentDescription: yield* strOrUnd(additionalDocumentReference, 'cbc:DocumentDescription'),
+        documentTypeCode: yield* strOrUnd(additionalDocumentReference, 'cbc:DocumentTypeCode'),
+        id: yield* decodeIdentifier(additionalDocumentReference, 'cbc:ID'),
+      };
+    })
+  );
+});

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

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolAddress } from '#/schemas/fields/address-schema';
 import type { RecursivePartial } from '#/types';
@@ -5,28 +7,37 @@ import type { RecursivePartial } from '#/types';
 import { getProp } from '#/helpers/get-prop';
 import { strOrUnd } from '#/helpers/str-or-und';
 
-export function decodeAddress(address: XmlNode | undefined, ...path: Array<string>): RecursivePartial<PeppolAddress> | undefined {
-  const val = getProp(address, ...path);
-  if (!val) return undefined;
+export const decodeAddress = Effect.fn(function* (
+  address: XmlNode | undefined,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolAddress> | undefined> {
+  const val = yield* getProp(address, ...path);
+  if (Predicate.isNullish(val)) return undefined;
   return {
-    additionalStreetName: strOrUnd(val, 'cbc:AdditionalStreetName'),
-    addressLine: decodeAddressLine(val, 'cac:AddressLine'),
-    cityName: strOrUnd(val, 'cbc:CityName'),
-    countryCode: decodeCountryCode(val, 'cac:Country'),
-    countrySubentity: strOrUnd(val, 'cbc:CountrySubentity'),
-    postalZone: strOrUnd(val, 'cbc:PostalZone'),
-    streetName: strOrUnd(val, 'cbc:StreetName'),
+    additionalStreetName: yield* strOrUnd(val, 'cbc:AdditionalStreetName'),
+    addressLine: yield* decodeAddressLine(val, 'cac:AddressLine'),
+    cityName: yield* strOrUnd(val, 'cbc:CityName'),
+    countryCode: yield* decodeCountryCode(val, 'cac:Country'),
+    countrySubentity: yield* strOrUnd(val, 'cbc:CountrySubentity'),
+    postalZone: yield* strOrUnd(val, 'cbc:PostalZone'),
+    streetName: yield* strOrUnd(val, 'cbc:StreetName'),
   };
-}
+});
 
-function decodeAddressLine(address: XmlNode, ...path: Array<string>): RecursivePartial<PeppolAddress['addressLine']> | undefined {
-  const val = getProp(address, ...path);
-  if (!val) return undefined;
-  return { line: strOrUnd(val, 'cbc:Line') };
-}
+const decodeAddressLine = Effect.fn(function* (
+  address: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolAddress['addressLine']> | undefined> {
+  const val = yield* getProp(address, ...path);
+  if (Predicate.isNullish(val)) return undefined;
+  return { line: yield* strOrUnd(val, 'cbc:Line') };
+});
 
-function decodeCountryCode(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolAddress['countryCode']> | undefined {
-  const country = getProp(node, ...path);
-  if (!country) return undefined;
-  return { identificationCode: strOrUnd(country, 'cbc:IdentificationCode') };
-}
+const decodeCountryCode = Effect.fn(function* (
+  node: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolAddress['countryCode']> | undefined> {
+  const country = yield* getProp(node, ...path);
+  if (Predicate.isNullish(country)) return undefined;
+  return { identificationCode: yield* strOrUnd(country, 'cbc:IdentificationCode') };
+});

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

@@ -1,3 +1,6 @@
+import { Effect } from 'effect';
+
+import type { PeppolNodeError } from '#/helpers/errors';
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolAllowanceCharge } from '#/schemas/fields/allowance-charge-schema';
 import type { RecursivePartial } from '#/types';
@@ -6,20 +9,22 @@ import { decodeBaseAllowanceCharge } from '#/decoders/fields/decode-base-allowan
 import { decodeTaxCategory } from '#/decoders/fields/decode-tax-category';
 import { getArray } from '#/helpers/get-array';
 
-export function decodeAllowanceCharges(
+export const decodeAllowanceCharges = Effect.fn(function* (
   allowanceCharges: XmlNode,
   ...path: Array<string>
-): Array<RecursivePartial<PeppolAllowanceCharge>> | undefined {
-  const arr = getArray(allowanceCharges, ...path);
-  if (!arr.length) {
+): Effect.fn.Return<Array<RecursivePartial<PeppolAllowanceCharge>> | undefined, PeppolNodeError> {
+  const arr = yield* getArray(allowanceCharges, ...path);
+  if (arr.length === 0) {
     return undefined;
   }
 
-  return arr.map(
-    allowanceCharge =>
-      ({
-        ...decodeBaseAllowanceCharge(allowanceCharge),
-        taxCategory: decodeTaxCategory(allowanceCharge, 'cac:TaxCategory'),
-      }) as RecursivePartial<PeppolAllowanceCharge>
+  return yield* Effect.forEach(
+    arr,
+    Effect.fn(function* (allowanceCharge: XmlNode) {
+      return {
+        ...(yield* decodeBaseAllowanceCharge(allowanceCharge)),
+        taxCategory: yield* decodeTaxCategory(allowanceCharge, 'cac:TaxCategory'),
+      } as RecursivePartial<PeppolAllowanceCharge>;
+    })
   );
-}
+});

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

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolAmount } from '#/schemas/fields/amount-schema';
 import type { PeppolCurrencyCode } from '#/schemas/values/currency-codes';
@@ -5,13 +7,15 @@ import type { RecursivePartial } from '#/types';
 
 import { getProp } from '#/helpers/get-prop';
 
-export function decodeAmount(amount: XmlNode | undefined): RecursivePartial<PeppolAmount> | undefined;
-export function decodeAmount(amount: XmlNode | undefined, ...path: Array<string>): RecursivePartial<PeppolAmount> | undefined;
-export function decodeAmount(amount: XmlNode | undefined, ...path: Array<string>): RecursivePartial<PeppolAmount> | undefined {
-  const val = getProp(amount, ...path);
-  if (!val && val !== 0) return undefined;
-  if (typeof val === 'object') {
-    return { currencyId: String(val['@currencyID']) as PeppolCurrencyCode, value: parseFloat(String(val['#text'] ?? val)) };
+export const decodeAmount = Effect.fn(function* (
+  amount: XmlNode | undefined,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolAmount> | undefined> {
+  const val = yield* getProp(amount, ...path);
+  if (!Predicate.isTruthy(val) && val !== 0) return undefined;
+  if (Predicate.isObject(val)) {
+    const raw = val as XmlNode;
+    return { currencyId: String(raw['@currencyID']) as PeppolCurrencyCode, value: parseFloat(String(raw['#text'] ?? raw)) };
   }
   return { currencyId: '' as PeppolCurrencyCode, value: parseFloat(String(val)) };
-}
+});

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

@@ -1,3 +1,5 @@
+import { Effect } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 
 import { decodeAmount } from '#/decoders/fields/decode-amount';
@@ -5,13 +7,13 @@ import { bool } from '#/helpers/bool';
 import { numOrUnd } from '#/helpers/num-or-und';
 import { strOrUnd } from '#/helpers/str-or-und';
 
-export function decodeBaseAllowanceCharge(allowanceCharge: XmlNode) {
+export const decodeBaseAllowanceCharge = Effect.fn(function* (allowanceCharge: XmlNode) {
   return {
-    allowanceChargeReason: strOrUnd(allowanceCharge, 'cbc:AllowanceChargeReason'),
-    allowanceChargeReasonCode: strOrUnd(allowanceCharge, 'cbc:AllowanceChargeReasonCode'),
-    amount: decodeAmount(allowanceCharge, 'cbc:Amount'),
-    baseAmount: decodeAmount(allowanceCharge, 'cbc:BaseAmount'),
-    chargeIndicator: bool(allowanceCharge, 'cbc:ChargeIndicator'),
-    multiplierFactorNumeric: numOrUnd(allowanceCharge, 'cbc:MultiplierFactorNumeric'),
+    allowanceChargeReason: yield* strOrUnd(allowanceCharge, 'cbc:AllowanceChargeReason'),
+    allowanceChargeReasonCode: yield* strOrUnd(allowanceCharge, 'cbc:AllowanceChargeReasonCode'),
+    amount: yield* decodeAmount(allowanceCharge, 'cbc:Amount'),
+    baseAmount: yield* decodeAmount(allowanceCharge, 'cbc:BaseAmount'),
+    chargeIndicator: yield* bool(allowanceCharge, 'cbc:ChargeIndicator'),
+    multiplierFactorNumeric: yield* numOrUnd(allowanceCharge, 'cbc:MultiplierFactorNumeric'),
   };
-}
+});

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

@@ -1,3 +1,5 @@
+import { Effect } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolBillingReference } from '#/schemas/fields/billing-references-schema';
 import type { RecursivePartial } from '#/types';
@@ -5,16 +7,22 @@ import type { RecursivePartial } from '#/types';
 import { getArray } from '#/helpers/get-array';
 import { strOrUnd } from '#/helpers/str-or-und';
 
-export function decodeBillingReferences(doc: XmlNode, ...path: Array<string>): Array<RecursivePartial<PeppolBillingReference>> | undefined {
-  const arr = getArray(doc, ...path);
-  if (!arr.length) {
-    return undefined;
-  }
+export const decodeBillingReferences = Effect.fn(function* (
+  doc: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<Array<RecursivePartial<PeppolBillingReference>> | undefined> {
+  const arr = yield* getArray(doc, ...path);
+  if (arr.length === 0) return undefined;
 
-  return arr.map(billingReference => ({
-    invoiceDocumentReference: {
-      id: strOrUnd(billingReference, 'cac:InvoiceDocumentReference', 'cbc:ID'),
-      issueDate: strOrUnd(billingReference, 'cac:InvoiceDocumentReference', 'cbc:IssueDate'),
-    },
-  }));
-}
+  return yield* Effect.forEach(
+    arr,
+    Effect.fn(function* (billingReference: XmlNode) {
+      return {
+        invoiceDocumentReference: {
+          id: yield* strOrUnd(billingReference, 'cac:InvoiceDocumentReference', 'cbc:ID'),
+          issueDate: yield* strOrUnd(billingReference, 'cac:InvoiceDocumentReference', 'cbc:IssueDate'),
+        },
+      };
+    })
+  );
+});

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

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolContact } from '#/schemas/fields/contact-schema';
 import type { RecursivePartial } from '#/types';
@@ -5,13 +7,16 @@ import type { RecursivePartial } from '#/types';
 import { getProp } from '#/helpers/get-prop';
 import { strOrUnd } from '#/helpers/str-or-und';
 
-export function decodeContact(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolContact> | undefined {
-  const contactNode = getProp(node, ...path);
-  if (!contactNode) return undefined;
+export const decodeContact = Effect.fn(function* (
+  node: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolContact> | undefined> {
+  const contactNode = yield* getProp(node, ...path);
+  if (Predicate.isNullish(contactNode)) return undefined;
 
   return {
-    electronicMail: strOrUnd(contactNode, 'cbc:ElectronicMail'),
-    name: strOrUnd(contactNode, 'cbc:Name'),
-    telephone: strOrUnd(contactNode, 'cbc:Telephone'),
+    electronicMail: yield* strOrUnd(contactNode, 'cbc:ElectronicMail'),
+    name: yield* strOrUnd(contactNode, 'cbc:Name'),
+    telephone: yield* strOrUnd(contactNode, 'cbc:Telephone'),
   };
-}
+});

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

@@ -1,3 +1,6 @@
+import { Effect } from 'effect';
+
+import type { PeppolNodeError } from '#/helpers/errors';
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolCreditNoteLine } from '#/schemas/fields/credit-note-line-schema';
 import type { RecursivePartial } from '#/types';
@@ -6,12 +9,18 @@ import { decodeLineShared } from '#/decoders/fields/decode-line-shared';
 import { decodeQuantity } from '#/decoders/fields/decode-quantity';
 import { getArray } from '#/helpers/get-array';
 
-export function decodeCreditNoteLines(doc: XmlNode, ...path: Array<string>): Array<RecursivePartial<PeppolCreditNoteLine>> | undefined {
-  const arr = getArray(doc, ...path);
-  if (!arr.length) return undefined;
+export const decodeCreditNoteLines = Effect.fn(function* (
+  doc: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<Array<RecursivePartial<PeppolCreditNoteLine>> | undefined, PeppolNodeError> {
+  const arr = yield* getArray(doc, ...path);
+  if (arr.length === 0) return undefined;
 
-  return arr.map(lineNode => {
-    const shared = decodeLineShared(lineNode);
-    return { ...shared, creditedQuantity: decodeQuantity(lineNode, 'cbc:CreditedQuantity')! };
-  });
-}
+  return yield* Effect.forEach(
+    arr,
+    Effect.fn(function* (lineNode: XmlNode) {
+      const shared = yield* decodeLineShared(lineNode);
+      return { ...shared, creditedQuantity: (yield* decodeQuantity(lineNode, 'cbc:CreditedQuantity'))! };
+    })
+  );
+});

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

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolDelivery } from '#/schemas/fields/delivery-schema';
 import type { RecursivePartial } from '#/types';
@@ -7,29 +9,38 @@ import { decodeIdentifier } from '#/decoders/fields/decode-identifier';
 import { getProp } from '#/helpers/get-prop';
 import { strOrUnd } from '#/helpers/str-or-und';
 
-export function decodeDelivery(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolDelivery> | undefined {
-  const val = getProp(node, ...path);
-  if (!val) return undefined;
+export const decodeDelivery = Effect.fn(function* (
+  node: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolDelivery> | undefined> {
+  const val = yield* getProp(node, ...path);
+  if (Predicate.isNullish(val)) return undefined;
 
   return {
-    actualDeliveryDate: strOrUnd(val, 'cbc:ActualDeliveryDate'),
-    deliveryLocation: decodeDeliveryLocation(val, 'cac:DeliveryLocation'),
-    deliveryParty: decodeDeliveryParty(val, 'cac:DeliveryParty'),
+    actualDeliveryDate: yield* strOrUnd(val, 'cbc:ActualDeliveryDate'),
+    deliveryLocation: yield* decodeDeliveryLocation(val, 'cac:DeliveryLocation'),
+    deliveryParty: yield* decodeDeliveryParty(val, 'cac:DeliveryParty'),
   };
-}
+});
 
-function decodeDeliveryLocation(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolDelivery['deliveryLocation']> | undefined {
-  const val = getProp(node, ...path);
-  if (!val) return undefined;
+const decodeDeliveryLocation = Effect.fn(function* (
+  node: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolDelivery['deliveryLocation']> | undefined> {
+  const val = yield* getProp(node, ...path);
+  if (Predicate.isNullish(val)) return undefined;
 
-  return { address: decodeAddress(val, 'cac:Address'), id: decodeIdentifier(val, 'cbc:ID') };
-}
+  return { address: yield* decodeAddress(val, 'cac:Address'), id: yield* decodeIdentifier(val, 'cbc:ID') };
+});
 
-function decodeDeliveryParty(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolDelivery['deliveryParty']> | undefined {
-  const val = getProp(node, ...path);
-  if (!val) return undefined;
-  const name = strOrUnd(val, 'cac:PartyName', 'cbc:Name');
-  if (!name) return undefined;
+const decodeDeliveryParty = Effect.fn(function* (
+  node: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolDelivery['deliveryParty']> | undefined> {
+  const val = yield* getProp(node, ...path);
+  if (Predicate.isNullish(val)) return undefined;
+  const name = yield* strOrUnd(val, 'cac:PartyName', 'cbc:Name');
+  if (!Predicate.isTruthy(name)) return undefined;
 
   return { partyName: { name } };
-}
+});

package/src/decoders/fields/decode-electronic-address.ts

@@ -1,13 +1,18 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolIdentifier } from '#/schemas/fields/identifier-schema';
 
 import { decodeIdentifier } from '#/decoders/fields/decode-identifier';
 
-export function decodeElectronicAddress<const T extends PeppolIdentifier['schemeId'] = string>(node: XmlNode | undefined, ...path: Array<string>) {
-  const value = decodeIdentifier<T>(node, ...path);
-  if (value?.schemeId) {
+export const decodeElectronicAddress = Effect.fn(function* <const T extends PeppolIdentifier['schemeId'] = string>(
+  node: XmlNode | undefined,
+  ...path: Array<string>
+) {
+  const value = yield* decodeIdentifier<T>(node, ...path);
+  if (Predicate.isTruthy(value?.schemeId)) {
     // @ts-expect-error I don't want to bother with the typecheck
     value.schemeId = (value.schemeId as string).padStart(4, '0') as T;
   }
   return value;
-}
+});