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

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

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolIdentifier } from '#/schemas/fields/identifier-schema';
 import type { RecursivePartial } from '#/types';
@@ -9,20 +11,20 @@ export interface Identifier<T extends PeppolIdentifier['schemeId'] = string> ext
   schemeId?: T;
 }
 
-export function decodeIdentifier<const T extends PeppolIdentifier['schemeId'] = string>(
+export const decodeIdentifier = Effect.fn(function* <const T extends PeppolIdentifier['schemeId'] = string>(
   node: XmlNode | undefined,
   ...path: Array<string>
-): RecursivePartial<Identifier<T>> | undefined {
-  const val = getProp(node, ...path);
-  if (!val && val !== 0) return undefined;
-  const id = strOrUnd(val);
-  if ((typeof val === 'string' || typeof val === 'number') && id) {
+): Effect.fn.Return<RecursivePartial<Identifier<T>> | undefined> {
+  const val = yield* getProp(node, ...path);
+  if (!Predicate.isTruthy(val) && val !== 0) return undefined;
+  const id = yield* strOrUnd(val);
+  if ((Predicate.isString(val) || Predicate.isNumber(val)) && Predicate.isTruthy(id)) {
     return { id };
   }
-  if (!id) return undefined;
+  if (!Predicate.isTruthy(id)) return undefined;
   return {
     id,
     // @ts-expect-error I don't want to bother with the typecheck
-    schemeId: strOrUnd(val, '@schemeID'),
+    schemeId: yield* strOrUnd(val, '@schemeID'),
   };
-}
+});

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

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolInvoiceLinePeriod } from '#/schemas/fields/invoice-line-period-schema';
 import type { RecursivePartial } from '#/types';
@@ -5,9 +7,12 @@ import type { RecursivePartial } from '#/types';
 import { getProp } from '#/helpers/get-prop';
 import { strOrUnd } from '#/helpers/str-or-und';
 
-export function decodeInvoiceLinePeriod(doc: XmlNode): RecursivePartial<PeppolInvoiceLinePeriod> | undefined;
-export function decodeInvoiceLinePeriod(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolInvoiceLinePeriod> | undefined;
-export function decodeInvoiceLinePeriod(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolInvoiceLinePeriod> | undefined {
-  const invoicePeriod = getProp(doc, ...path);
-  return invoicePeriod ? { endDate: strOrUnd(invoicePeriod, 'cbc:EndDate'), startDate: strOrUnd(invoicePeriod, 'cbc:StartDate') } : undefined;
-}
+export const decodeInvoiceLinePeriod = Effect.fn(function* (
+  doc: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolInvoiceLinePeriod> | undefined> {
+  const invoicePeriod = yield* getProp(doc, ...path);
+  return Predicate.isNotNullish(invoicePeriod)
+    ? { endDate: yield* strOrUnd(invoicePeriod, 'cbc:EndDate'), startDate: yield* strOrUnd(invoicePeriod, 'cbc:StartDate') }
+    : undefined;
+});

package/src/decoders/fields/decode-invoice-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 { PeppolInvoiceLine } from '#/schemas/fields/invoice-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 decodeInvoiceLines(doc: XmlNode, ...path: Array<string>): Array<RecursivePartial<PeppolInvoiceLine>> | undefined {
-  const arr = getArray(doc, ...path);
-  if (!arr.length) return undefined;
+export const decodeInvoiceLines = Effect.fn(function* (
+  doc: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<Array<RecursivePartial<PeppolInvoiceLine>> | undefined, PeppolNodeError> {
+  const arr = yield* getArray(doc, ...path);
+  if (arr.length === 0) return undefined;
 
-  return arr.map(lineNode => {
-    const shared = decodeLineShared(lineNode);
-    return { ...shared, invoicedQuantity: decodeQuantity(lineNode, 'cbc:InvoicedQuantity') };
-  });
-}
+  return yield* Effect.forEach(
+    arr,
+    Effect.fn(function* (lineNode: XmlNode) {
+      const shared = yield* decodeLineShared(lineNode);
+      return { ...shared, invoicedQuantity: yield* decodeQuantity(lineNode, 'cbc:InvoicedQuantity') };
+    })
+  );
+});

package/src/decoders/fields/decode-invoice-message-document-party.ts

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { InvoiceDocumentResponseParty } from '#/schemas/invoice-response-schema';
 import type { RecursivePartial } from '#/types';
@@ -6,15 +8,15 @@ import { decodeIdentifier } from '#/decoders/fields/decode-identifier';
 import { getProp } from '#/helpers/get-prop';
 import { strOrUnd } from '#/helpers/str-or-und';
 
-export function decodeInvoiceMessageDocumentParty(
+export const decodeInvoiceMessageDocumentParty = Effect.fn(function* (
   party: XmlNode,
   ...path: Array<string>
-): RecursivePartial<InvoiceDocumentResponseParty> | undefined {
-  const val = getProp(party, ...path);
-  if (!val) return undefined;
-  const partyName = getProp(val, 'cac:PartyName');
+): Effect.fn.Return<RecursivePartial<InvoiceDocumentResponseParty> | undefined> {
+  const val = yield* getProp(party, ...path);
+  if (Predicate.isNullish(val)) return undefined;
+  const partyName = yield* getProp(val, 'cac:PartyName');
   return {
-    partyIdentification: decodeIdentifier(val, 'cac:PartyIdentification', 'cbc:ID'),
-    partyName: partyName ? { name: strOrUnd(partyName, 'cbc:Name') } : undefined,
+    partyIdentification: yield* decodeIdentifier(val, 'cac:PartyIdentification', 'cbc:ID'),
+    partyName: Predicate.isNotNullish(partyName) ? { name: yield* strOrUnd(partyName, 'cbc:Name') } : undefined,
   };
-}
+});

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

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { InvoiceResponseParty } from '#/schemas/invoice-response-schema';
 import type { RecursivePartial } from '#/types';
@@ -8,13 +10,16 @@ import { decodeIdentifier } from '#/decoders/fields/decode-identifier';
 import { decodePartyLegalEntity } from '#/decoders/fields/decode-party-legal-entity';
 import { getProp } from '#/helpers/get-prop';
 
-export function decodeInvoiceMessageParty(party: XmlNode, ...path: Array<string>): RecursivePartial<InvoiceResponseParty> | undefined {
-  const val = getProp(party, ...path);
-  if (!val) return undefined;
+export const decodeInvoiceMessageParty = Effect.fn(function* (
+  party: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<InvoiceResponseParty> | undefined> {
+  const val = yield* getProp(party, ...path);
+  if (Predicate.isNullish(val)) return undefined;
   return {
-    contact: decodeContact(val, 'cac:Contact'),
-    endpointId: decodeElectronicAddress(val, 'cbc:EndpointID'),
-    partyIdentification: decodeIdentifier(val, 'cac:PartyIdentification', 'cbc:ID'),
-    partyLegalEntity: decodePartyLegalEntity(val, 'cac:PartyLegalEntity'),
+    contact: yield* decodeContact(val, 'cac:Contact'),
+    endpointId: yield* decodeElectronicAddress(val, 'cbc:EndpointID'),
+    partyIdentification: yield* decodeIdentifier(val, 'cac:PartyIdentification', 'cbc:ID'),
+    partyLegalEntity: yield* decodePartyLegalEntity(val, 'cac:PartyLegalEntity'),
   };
-}
+});

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

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolInvoicePeriod } from '#/schemas/fields/invoice-period-schema';
 import type { RecursivePartial } from '#/types';
@@ -5,15 +7,16 @@ import type { RecursivePartial } from '#/types';
 import { getProp } from '#/helpers/get-prop';
 import { strOrUnd } from '#/helpers/str-or-und';
 
-export function decodeInvoicePeriod(doc: XmlNode): RecursivePartial<PeppolInvoicePeriod> | undefined;
-export function decodeInvoicePeriod(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolInvoicePeriod> | undefined;
-export function decodeInvoicePeriod(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolInvoicePeriod> | undefined {
-  const invoicePeriod = getProp(doc, ...path);
-  return invoicePeriod
+export const decodeInvoicePeriod = Effect.fn(function* (
+  doc: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolInvoicePeriod> | undefined> {
+  const invoicePeriod = yield* getProp(doc, ...path);
+  return Predicate.isNotNullish(invoicePeriod)
     ? {
-        descriptionCode: strOrUnd(invoicePeriod, 'cbc:DescriptionCode'),
-        endDate: strOrUnd(invoicePeriod, 'cbc:EndDate'),
-        startDate: strOrUnd(invoicePeriod, 'cbc:StartDate'),
+        descriptionCode: yield* strOrUnd(invoicePeriod, 'cbc:DescriptionCode'),
+        endDate: yield* strOrUnd(invoicePeriod, 'cbc:EndDate'),
+        startDate: yield* strOrUnd(invoicePeriod, 'cbc:StartDate'),
       }
     : undefined;
-}
+});

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

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolLegalMonetaryTotal } from '#/schemas/fields/legal-monetary-total-schema';
 import type { RecursivePartial } from '#/types';
@@ -5,18 +7,21 @@ import type { RecursivePartial } from '#/types';
 import { decodeAmount } from '#/decoders/fields/decode-amount';
 import { getProp } from '#/helpers/get-prop';
 
-export function decodeLegalMonetaryTotal(node: XmlNode | undefined, ...path: Array<string>): RecursivePartial<PeppolLegalMonetaryTotal> | undefined {
-  const val = getProp(node, ...path);
-  if (!val) return undefined;
+export const decodeLegalMonetaryTotal = Effect.fn(function* (
+  node: XmlNode | undefined,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolLegalMonetaryTotal> | undefined> {
+  const val = yield* getProp(node, ...path);
+  if (Predicate.isNullish(val)) return undefined;
 
   return {
-    allowanceTotalAmount: decodeAmount(val, 'cbc:AllowanceTotalAmount'),
-    chargeTotalAmount: decodeAmount(val, 'cbc:ChargeTotalAmount'),
-    lineExtensionAmount: decodeAmount(val, 'cbc:LineExtensionAmount'),
-    payableAmount: decodeAmount(val, 'cbc:PayableAmount'),
-    payableRoundingAmount: decodeAmount(val, 'cbc:PayableRoundingAmount'),
-    prepaidAmount: decodeAmount(val, 'cbc:PrepaidAmount'),
-    taxExclusiveAmount: decodeAmount(val, 'cbc:TaxExclusiveAmount'),
-    taxInclusiveAmount: decodeAmount(val, 'cbc:TaxInclusiveAmount'),
+    allowanceTotalAmount: yield* decodeAmount(val, 'cbc:AllowanceTotalAmount'),
+    chargeTotalAmount: yield* decodeAmount(val, 'cbc:ChargeTotalAmount'),
+    lineExtensionAmount: yield* decodeAmount(val, 'cbc:LineExtensionAmount'),
+    payableAmount: yield* decodeAmount(val, 'cbc:PayableAmount'),
+    payableRoundingAmount: yield* decodeAmount(val, 'cbc:PayableRoundingAmount'),
+    prepaidAmount: yield* decodeAmount(val, 'cbc:PrepaidAmount'),
+    taxExclusiveAmount: yield* decodeAmount(val, 'cbc:TaxExclusiveAmount'),
+    taxInclusiveAmount: yield* decodeAmount(val, 'cbc:TaxInclusiveAmount'),
   };
-}
+});

package/src/decoders/fields/decode-line-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 { PeppolLineAllowanceCharge } from '#/schemas/fields/line-allowance-charge-schema';
 import type { RecursivePartial } from '#/types';
@@ -5,13 +8,18 @@ import type { RecursivePartial } from '#/types';
 import { decodeBaseAllowanceCharge } from '#/decoders/fields/decode-base-allowance-charge';
 import { getArray } from '#/helpers/get-array';
 
-export function decodeLineAllowanceCharges(
+export const decodeLineAllowanceCharges = Effect.fn(function* (
   allowanceCharges: XmlNode,
   ...path: Array<string>
-): Array<RecursivePartial<PeppolLineAllowanceCharge>> | undefined {
-  const arr = getArray(allowanceCharges, ...path);
-  if (!arr.length) {
+): Effect.fn.Return<Array<RecursivePartial<PeppolLineAllowanceCharge>> | undefined, PeppolNodeError> {
+  const arr = yield* getArray(allowanceCharges, ...path);
+  if (arr.length === 0) {
     return undefined;
   }
-  return arr.map(allowanceCharge => ({ ...decodeBaseAllowanceCharge(allowanceCharge) }) as RecursivePartial<PeppolLineAllowanceCharge>);
-}
+  return yield* Effect.forEach(
+    arr,
+    Effect.fn(function* (allowanceCharge: XmlNode) {
+      return { ...(yield* decodeBaseAllowanceCharge(allowanceCharge)) } as RecursivePartial<PeppolLineAllowanceCharge>;
+    })
+  );
+});

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

@@ -1,3 +1,6 @@
+import { Effect, Predicate } from 'effect';
+
+import type { PeppolNodeError } from '#/helpers/errors';
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolLinePrice } from '#/schemas/fields/price-schema';
 import type { RecursivePartial } from '#/types';
@@ -7,13 +10,16 @@ import { decodePriceAllowanceCharge } from '#/decoders/fields/decode-price-allow
 import { decodeQuantity } from '#/decoders/fields/decode-quantity';
 import { getProp } from '#/helpers/get-prop';
 
-export function decodeLinePrice(price: XmlNode, ...path: Array<string>): RecursivePartial<PeppolLinePrice> | undefined {
-  const node = getProp(price, ...path);
-  if (!node) return undefined;
+export const decodeLinePrice = Effect.fn(function* (
+  price: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolLinePrice> | undefined, PeppolNodeError> {
+  const node = yield* getProp(price, ...path);
+  if (Predicate.isNullish(node)) return undefined;
 
   return {
-    allowanceCharge: decodePriceAllowanceCharge(node, 'cac:AllowanceCharge'),
-    baseQuantity: decodeQuantity(node, 'cbc:BaseQuantity'),
-    priceAmount: decodeAmount(node, 'cbc:PriceAmount'),
+    allowanceCharge: yield* decodePriceAllowanceCharge(node, 'cac:AllowanceCharge'),
+    baseQuantity: yield* decodeQuantity(node, 'cbc:BaseQuantity'),
+    priceAmount: yield* decodeAmount(node, 'cbc:PriceAmount'),
   };
-}
+});

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

@@ -1,4 +1,7 @@
+import { Effect, Predicate } from 'effect';
+
 import type { PeppolDocumentLine } from '#/document';
+import type { PeppolNodeError } from '#/helpers/errors';
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolBaseLine } from '#/schemas/fields/base-line-schema';
 import type { RecursivePartial } from '#/types';
@@ -16,55 +19,73 @@ import { strOrUnd } from '#/helpers/str-or-und';
 
 type PeppolDocumentLineItem = PeppolDocumentLine['item'];
 
-export function decodeLineShared(lineShared: XmlNode): RecursivePartial<PeppolBaseLine> {
-  const item = getProp(lineShared, 'cac:Item');
-  const orderLineReference = getProp(lineShared, 'cac:OrderLineReference');
+export const decodeLineShared = Effect.fn(function* (lineShared: XmlNode): Effect.fn.Return<RecursivePartial<PeppolBaseLine>, PeppolNodeError> {
+  const item = yield* getProp(lineShared, 'cac:Item');
+  const orderLineReference = yield* getProp(lineShared, 'cac:OrderLineReference');
 
   return {
-    accountingCost: strOrUnd(lineShared, 'cbc:AccountingCost'),
-    allowanceCharges: decodeLineAllowanceCharges(lineShared, 'cac:AllowanceCharge'),
-    documentReference: getArray(lineShared, 'cac:DocumentReference').map(documentReference => ({
-      documentTypeCode: strOrUnd(documentReference, 'cbc:DocumentTypeCode'),
-      id: strOrUnd(documentReference, 'cbc:ID'),
-      schemeId: strOrUnd(documentReference, 'cbc:ID', '@schemeID'),
-    })),
-    id: strOrUnd(lineShared, 'cbc:ID'),
-    invoicePeriod: decodeInvoiceLinePeriod(lineShared, 'cac:InvoicePeriod'),
+    accountingCost: yield* strOrUnd(lineShared, 'cbc:AccountingCost'),
+    allowanceCharges: yield* decodeLineAllowanceCharges(lineShared, 'cac:AllowanceCharge'),
+    documentReference: yield* Effect.forEach(
+      yield* getArray(lineShared, 'cac:DocumentReference'),
+      Effect.fn(function* (documentReference: XmlNode) {
+        return {
+          documentTypeCode: yield* strOrUnd(documentReference, 'cbc:DocumentTypeCode'),
+          id: yield* strOrUnd(documentReference, 'cbc:ID'),
+          schemeId: yield* strOrUnd(documentReference, 'cbc:ID', '@schemeID'),
+        };
+      })
+    ),
+    id: yield* strOrUnd(lineShared, 'cbc:ID'),
+    invoicePeriod: yield* decodeInvoiceLinePeriod(lineShared, 'cac:InvoicePeriod'),
     item: {
-      additionalItemProperties: getArray(item, 'cac:AdditionalItemProperty').map(n => ({
-        name: strOrUnd(n, 'cbc:Name'),
-        value: strOrUnd(n, 'cbc:Value'),
-      })),
-      buyersItemIdentification: decodeSimpleIdentifer(item, 'cac:BuyersItemIdentification'),
-      classifiedTaxCategory: decodeTaxCategory(item, 'cac:ClassifiedTaxCategory'),
-      commodityClassifications: getArray(item, 'cac:CommodityClassification').map(commodityClassification => ({
-        itemClassification: {
-          id: strOrUnd(commodityClassification, 'cbc:ItemClassificationCode'),
-          listId: strOrUnd(commodityClassification, 'cbc:ItemClassificationCode', '@listID'),
-          listVersionId: strOrUnd(commodityClassification, 'cbc:ItemClassificationCode', '@listVersionID'),
-        },
-      })),
-      description: strOrUnd(item, 'cbc:Description'),
-      name: strOrUnd(item, 'cbc:Name'),
-      originCountryCode: decodeOriginCountryCode(item, 'cac:OriginCountry'),
-      sellersItemIdentification: decodeSimpleIdentifer(item, 'cac:SellersItemIdentification'),
-      standardItemIdentification: decodeStandardItem(item, 'cac:StandardItemIdentification'),
+      additionalItemProperties: yield* Effect.forEach(
+        yield* getArray(item, 'cac:AdditionalItemProperty'),
+        Effect.fn(function* (n: XmlNode) {
+          return { name: yield* strOrUnd(n, 'cbc:Name'), value: yield* strOrUnd(n, 'cbc:Value') };
+        })
+      ),
+      buyersItemIdentification: yield* decodeSimpleIdentifer(item, 'cac:BuyersItemIdentification'),
+      classifiedTaxCategory: yield* decodeTaxCategory(item, 'cac:ClassifiedTaxCategory'),
+      commodityClassifications: yield* Effect.forEach(
+        yield* getArray(item, 'cac:CommodityClassification'),
+        Effect.fn(function* (commodityClassification: XmlNode) {
+          return {
+            itemClassification: {
+              id: yield* strOrUnd(commodityClassification, 'cbc:ItemClassificationCode'),
+              listId: yield* strOrUnd(commodityClassification, 'cbc:ItemClassificationCode', '@listID'),
+              listVersionId: yield* strOrUnd(commodityClassification, 'cbc:ItemClassificationCode', '@listVersionID'),
+            },
+          };
+        })
+      ),
+      description: yield* strOrUnd(item, 'cbc:Description'),
+      name: yield* strOrUnd(item, 'cbc:Name'),
+      originCountryCode: yield* decodeOriginCountryCode(item, 'cac:OriginCountry'),
+      sellersItemIdentification: yield* decodeSimpleIdentifer(item, 'cac:SellersItemIdentification'),
+      standardItemIdentification: yield* decodeStandardItem(item, 'cac:StandardItemIdentification'),
     },
-    lineExtensionAmount: decodeAmount(lineShared, 'cbc:LineExtensionAmount'),
-    note: strOrUnd(lineShared, 'cbc:Note'),
-    orderLineReference: orderLineReference ? { lineId: strOrUnd(orderLineReference, 'cbc:LineID') } : undefined,
-    price: decodeLinePrice(lineShared, 'cac:Price'),
+    lineExtensionAmount: yield* decodeAmount(lineShared, 'cbc:LineExtensionAmount'),
+    note: yield* strOrUnd(lineShared, 'cbc:Note'),
+    orderLineReference: Predicate.isNotNullish(orderLineReference) ? { lineId: yield* strOrUnd(orderLineReference, 'cbc:LineID') } : undefined,
+    price: yield* decodeLinePrice(lineShared, 'cac:Price'),
   };
-}
+});
 
-function decodeStandardItem(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolDocumentLineItem['standardItemIdentification']> {
-  const val = getProp(node, ...path);
-  if (!val) return;
-  return { id: decodeIdentifier(val, 'cbc:ID') };
-}
+const decodeStandardItem = Effect.fn(function* (
+  node: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolDocumentLineItem['standardItemIdentification']>> {
+  const val = yield* getProp(node, ...path);
+  if (Predicate.isNullish(val)) return undefined;
+  return { id: yield* decodeIdentifier(val, 'cbc:ID') };
+});
 
-function decodeOriginCountryCode(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolDocumentLineItem['originCountryCode']> {
-  const country = getProp(node, ...path);
-  if (!country) return undefined;
-  return { identificationCode: strOrUnd(country, 'cbc:IdentificationCode') };
-}
+const decodeOriginCountryCode = Effect.fn(function* (
+  node: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolDocumentLineItem['originCountryCode']>> {
+  const country = yield* getProp(node, ...path);
+  if (Predicate.isNullish(country)) return undefined;
+  return { identificationCode: yield* strOrUnd(country, 'cbc:IdentificationCode') };
+});

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

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolMessageLevelResponseParty } from '#/schemas/message-level-response-party-schema';
 import type { RecursivePartial } from '#/types';
@@ -5,8 +7,11 @@ import type { RecursivePartial } from '#/types';
 import { decodeElectronicAddress } from '#/decoders/fields/decode-electronic-address';
 import { getProp } from '#/helpers/get-prop';
 
-export function decodeMessageLevelParty(party: XmlNode, ...path: Array<string>): RecursivePartial<PeppolMessageLevelResponseParty> | undefined {
-  const val = getProp(party, ...path);
-  if (!val) return undefined;
-  return { endpointId: decodeElectronicAddress(val, 'cbc:EndpointID') };
-}
+export const decodeMessageLevelParty = Effect.fn(function* (
+  party: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolMessageLevelResponseParty> | undefined> {
+  const val = yield* getProp(party, ...path);
+  if (Predicate.isNullish(val)) return undefined;
+  return { endpointId: yield* decodeElectronicAddress(val, 'cbc:EndpointID') };
+});

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

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolOrderReference } from '#/schemas/fields/order-reference-schema';
 import type { RecursivePartial } from '#/types';
@@ -5,9 +7,12 @@ import type { RecursivePartial } from '#/types';
 import { getProp } from '#/helpers/get-prop';
 import { strOrUnd } from '#/helpers/str-or-und';
 
-export function decodeOrderReference(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolOrderReference> | undefined {
-  const val = getProp(node, ...path);
-  if (!val) return undefined;
+export const decodeOrderReference = Effect.fn(function* (
+  node: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolOrderReference> | undefined> {
+  const val = yield* getProp(node, ...path);
+  if (Predicate.isNullish(val)) return undefined;
 
-  return { id: strOrUnd(val, 'cbc:ID'), salesOrderId: strOrUnd(val, 'cbc:SalesOrderID') };
-}
+  return { id: yield* strOrUnd(val, 'cbc:ID'), salesOrderId: yield* strOrUnd(val, 'cbc:SalesOrderID') };
+});

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

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolPartyTaxSchema } from '#/schemas/fields/party-tax-schema';
 import type { RecursivePartial } from '#/types';
@@ -5,15 +7,18 @@ import type { RecursivePartial } from '#/types';
 import { decodePartyTaxScheme } from '#/decoders/fields/decode-party-tax-scheme';
 import { getArray } from '#/helpers/get-array';
 
-export function decodePartiesTaxScheme(doc: XmlNode, ...path: Array<string>): RecursivePartial<Array<PeppolPartyTaxSchema>> | undefined {
-  const node = getArray(doc, ...path);
-  if (!node?.length) return undefined;
+export const decodePartiesTaxScheme = Effect.fn(function* (
+  doc: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<Array<PeppolPartyTaxSchema>> | undefined> {
+  const node = yield* getArray(doc, ...path);
+  if (node.length === 0) return undefined;
 
-  return node.reduce((prev, n) => {
-    const val = decodePartyTaxScheme(n);
-    if (val) {
-      prev.push(val);
-    }
-    return prev;
-  }, []);
-}
+  const values = yield* Effect.forEach(
+    node,
+    Effect.fn(function* (n: XmlNode) {
+      return yield* decodePartyTaxScheme(n);
+    })
+  );
+  return values.filter(Predicate.isNotNullish);
+});

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

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolPartyLegalEntitySchema } from '#/schemas/fields/party-legal-entity-schema';
 import type { RecursivePartial } from '#/types';
@@ -6,13 +8,16 @@ import { decodeIdentifier } from '#/decoders/fields/decode-identifier';
 import { getProp } from '#/helpers/get-prop';
 import { strOrUnd } from '#/helpers/str-or-und';
 
-export function decodePartyLegalEntity(node: XmlNode, ...path: Array<string>): RecursivePartial<PeppolPartyLegalEntitySchema> | undefined {
-  const partyLegalEntityNode = getProp(node, ...path);
-  if (!partyLegalEntityNode) return undefined;
+export const decodePartyLegalEntity = Effect.fn(function* (
+  node: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolPartyLegalEntitySchema> | undefined> {
+  const partyLegalEntityNode = yield* getProp(node, ...path);
+  if (Predicate.isNullish(partyLegalEntityNode)) return undefined;
 
   return {
-    companyId: decodeIdentifier(partyLegalEntityNode, 'cbc:CompanyID'),
-    companyLegalForm: strOrUnd(partyLegalEntityNode, 'cbc:CompanyLegalForm'),
-    registrationName: strOrUnd(partyLegalEntityNode, 'cbc:RegistrationName'),
+    companyId: yield* decodeIdentifier(partyLegalEntityNode, 'cbc:CompanyID'),
+    companyLegalForm: yield* strOrUnd(partyLegalEntityNode, 'cbc:CompanyLegalForm'),
+    registrationName: yield* strOrUnd(partyLegalEntityNode, 'cbc:RegistrationName'),
   };
-}
+});

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

@@ -1,3 +1,5 @@
+import { Effect, Predicate } from 'effect';
+
 import type { XmlNode } from '#/helpers/get-prop';
 import type { PeppolPartyTaxSchema } from '#/schemas/fields/party-tax-schema';
 import type { RecursivePartial } from '#/types';
@@ -6,9 +8,12 @@ import { decodeSimpleIdentifer } from '#/decoders/fields/decode-simple-identifie
 import { getProp } from '#/helpers/get-prop';
 import { strOrUnd } from '#/helpers/str-or-und';
 
-export function decodePartyTaxScheme(doc: XmlNode, ...path: Array<string>): RecursivePartial<PeppolPartyTaxSchema> | undefined {
-  const node = getProp(doc, ...path);
-  if (!node) return undefined;
+export const decodePartyTaxScheme = Effect.fn(function* (
+  doc: XmlNode,
+  ...path: Array<string>
+): Effect.fn.Return<RecursivePartial<PeppolPartyTaxSchema> | undefined> {
+  const node = yield* getProp(doc, ...path);
+  if (Predicate.isNullish(node)) return undefined;
 
-  return { companyId: strOrUnd(node, 'cbc:CompanyID'), taxSchemeId: decodeSimpleIdentifer(node, 'cac:TaxScheme') };
-}
+  return { companyId: yield* strOrUnd(node, 'cbc:CompanyID'), taxSchemeId: yield* decodeSimpleIdentifer(node, 'cac:TaxScheme') };
+});