@powerhousedao/contributor-billing 1.0.0-dev.15 → 1.0.0-dev.16

package/dist/document-models/invoice/v1/src/reducers/general.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"general.d.ts","sourceRoot":"","sources":["../../../../../../document-models/invoice/v1/src/reducers/general.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+DAA+D,CAAC;AAgB9G,eAAO,MAAM,wBAAwB,EAAE,wBAqEtC,CAAC"}

package/dist/document-models/invoice/v1/src/reducers/general.js

@@ -0,0 +1,75 @@
+/**
+ * Converts a date string to ISO datetime format if it's not already in that format
+ * Handles both date-only (YYYY-MM-DD) and datetime (YYYY-MM-DDTHH:mm:ss.sssZ) strings
+ */
+function ensureDatetimeFormat(dateStr) {
+    if (!dateStr || dateStr.trim() === "")
+        return null;
+    // If it's already a datetime string, return as is
+    if (dateStr.includes("T"))
+        return dateStr;
+    // Convert date-only to datetime at midnight UTC
+    return `${dateStr}T00:00:00.000Z`;
+}
+export const invoiceGeneralOperations = {
+    editInvoiceOperation(state, action) {
+        const newState = { ...state };
+        newState.currency = action.input.currency ?? state.currency;
+        // Convert date strings to datetime format to match Zod schema requirements
+        newState.dateDue =
+            action.input.dateDue !== undefined
+                ? ensureDatetimeFormat(action.input.dateDue)
+                : state.dateDue;
+        newState.dateIssued =
+            action.input.dateIssued !== undefined
+                ? ensureDatetimeFormat(action.input.dateIssued)
+                : state.dateIssued;
+        newState.dateDelivered =
+            action.input.dateDelivered !== undefined
+                ? ensureDatetimeFormat(action.input.dateDelivered)
+                : state.dateDelivered;
+        newState.invoiceNo = action.input.invoiceNo ?? state.invoiceNo;
+        newState.notes = action.input.notes ?? state.notes;
+        Object.assign(state, newState);
+    },
+    editStatusOperation(state, action) {
+        if (state.status === "DRAFT" &&
+            action.input.status !== "DRAFT" &&
+            action.input.status !== "CANCELLED") {
+            const wallet = state.issuer?.paymentRouting?.wallet;
+            if (!wallet?.address || (!wallet.chainName && !wallet.chainId)) {
+                throw new Error("Issuer wallet address and chain must be set before moving out of DRAFT");
+            }
+        }
+        state.status = action.input.status;
+    },
+    editPaymentDataOperation(state, action) {
+        const payment = state.payments.find((payment) => payment.id === action.input.id);
+        if (payment) {
+            payment.processorRef = action.input.processorRef ?? payment.processorRef;
+            payment.paymentDate = action.input.paymentDate ?? payment.paymentDate;
+            payment.txnRef = action.input.txnRef ?? payment.txnRef;
+            payment.confirmed = action.input.confirmed ?? payment.confirmed;
+            payment.issue = action.input.issue ?? payment.issue;
+        }
+    },
+    addPaymentOperation(state, action) {
+        const payment = {
+            id: action.input.id,
+            processorRef: action.input.processorRef ?? "",
+            paymentDate: ensureDatetimeFormat(action.input.paymentDate) ?? null,
+            txnRef: action.input.txnRef ?? "",
+            confirmed: action.input.confirmed ?? false,
+            issue: action.input.issue ?? "",
+            amount: 0,
+        };
+        state.payments.push(payment);
+    },
+    setExportedDataOperation(state, action) {
+        const exportedData = {
+            timestamp: action.input.timestamp,
+            exportedLineItems: action.input.exportedLineItems,
+        };
+        state.exported = exportedData;
+    },
+};

package/dist/document-models/invoice/v1/src/reducers/items.d.ts

@@ -0,0 +1,3 @@
+import type { InvoiceItemsOperations } from "@powerhousedao/contributor-billing/document-models/invoice/v1";
+export declare const invoiceItemsOperations: InvoiceItemsOperations;
+//# sourceMappingURL=items.d.ts.map

package/dist/document-models/invoice/v1/src/reducers/items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"items.d.ts","sourceRoot":"","sources":["../../../../../../document-models/invoice/v1/src/reducers/items.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+DAA+D,CAAC;AAE5G,eAAO,MAAM,sBAAsB,EAAE,sBA8FpC,CAAC"}

package/dist/document-models/invoice/v1/src/reducers/items.js

@@ -0,0 +1,166 @@
+export const invoiceItemsOperations = {
+    addLineItemOperation(state, action) {
+        const item = {
+            ...action.input,
+            lineItemTag: [],
+        };
+        if (state.lineItems.find((x) => x.id === item.id))
+            throw new Error("Duplicate input.id");
+        validatePrices(item);
+        state.lineItems.push(item);
+        updateTotals(state);
+    },
+    editLineItemOperation(state, action) {
+        const stateItem = state.lineItems.find((x) => x.id === action.input.id);
+        if (!stateItem)
+            throw new Error("Item matching input.id not found");
+        const sanitizedInput = Object.fromEntries(Object.entries(action.input).filter(([, value]) => value !== null));
+        // Ensure lineItemTag is always an array if provided
+        if ("lineItemTag" in action.input) {
+            sanitizedInput.lineItemTag = (action.input
+                .lineItemTag ?? []);
+        }
+        const nextItem = {
+            ...stateItem,
+            ...sanitizedInput,
+        };
+        validatePrices(nextItem);
+        applyInvariants(state, nextItem);
+        Object.assign(stateItem, nextItem);
+        updateTotals(state);
+    },
+    deleteLineItemOperation(state, action) {
+        state.lineItems = state.lineItems.filter((x) => x.id !== action.input.id);
+        updateTotals(state);
+    },
+    setLineItemTagOperation(state, action) {
+        const stateItem = state.lineItems.find((x) => x.id === action.input.lineItemId);
+        if (!stateItem)
+            throw new Error("Item matching input.id not found");
+        // if tag already exists with the same dimension, update the value and label
+        const existingTag = stateItem.lineItemTag?.find((tag) => tag.dimension === action.input.dimension);
+        if (existingTag) {
+            existingTag.value = action.input.value;
+            existingTag.label = action.input.label || null;
+        }
+        else {
+            // if tag does not exist, add it
+            const newTag = {
+                dimension: action.input.dimension,
+                value: action.input.value,
+                label: action.input.label || null,
+            };
+            if (!stateItem.lineItemTag) {
+                stateItem.lineItemTag = [];
+            }
+            // Add the new tag
+            stateItem.lineItemTag?.push(newTag);
+        }
+    },
+    setInvoiceTagOperation(state, action) {
+        // if tag already exists with the same dimension, update the value and label
+        const existingTag = state.invoiceTags?.find((tag) => tag.dimension === action.input.dimension);
+        if (existingTag) {
+            existingTag.value = action.input.value;
+            existingTag.label = action.input.label || null;
+        }
+        else {
+            // if tag does not exist, add it
+            const newTag = {
+                dimension: action.input.dimension,
+                value: action.input.value,
+                label: action.input.label || null,
+            };
+            if (!state.invoiceTags) {
+                state.invoiceTags = [];
+            }
+            // Add the new tag
+            state.invoiceTags.push(newTag);
+        }
+    },
+};
+function updateTotals(state) {
+    state.totalPriceTaxExcl = state.lineItems.reduce((total, lineItem) => {
+        return total + lineItem.quantity * lineItem.unitPriceTaxExcl;
+    }, 0.0);
+    state.totalPriceTaxIncl = state.lineItems.reduce((total, lineItem) => {
+        return total + lineItem.quantity * lineItem.unitPriceTaxIncl;
+    }, 0.0);
+}
+function validatePrices(item) {
+    const EPSILON = 0.00001; // Small value for floating point comparisons
+    // Calculate total prices from unit prices and quantity
+    const calcPriceIncl = item.quantity * item.unitPriceTaxIncl;
+    const calcPriceExcl = item.quantity * item.unitPriceTaxExcl;
+    // Convert tax percentage to decimal rate
+    const taxRate = item.taxPercent / 100;
+    // Helper function to compare floating point numbers
+    const isClose = (a, b) => Math.abs(a - b) < EPSILON;
+    // Validate unit prices (tax-exclusive should equal tax-inclusive / (1 + taxRate))
+    const expectedUnitPriceExcl = item.unitPriceTaxIncl / (1 + taxRate);
+    if (!isClose(item.unitPriceTaxExcl, expectedUnitPriceExcl)) {
+        throw new Error("Tax inclusive/exclusive unit prices failed comparison.");
+    }
+    // Validate total prices
+    if (!isClose(calcPriceIncl, item.totalPriceTaxIncl)) {
+        throw new Error("Calculated unitPriceTaxIncl does not match input total");
+    }
+    if (!isClose(calcPriceExcl, item.totalPriceTaxExcl)) {
+        throw new Error("Calculated unitPriceTaxExcl does not match input total");
+    }
+    // Validate total prices using the tax rate
+    const expectedTotalPriceExcl = calcPriceIncl / (1 + taxRate);
+    if (!isClose(calcPriceExcl, expectedTotalPriceExcl)) {
+        throw new Error("Tax inclusive/exclusive totals failed comparison.");
+    }
+}
+const applyInvariants = (state, nextItem) => {
+    const EPSILON = 0.00001; // Small value for floating point comparisons
+    // Helper function to compare floating point numbers
+    const isClose = (a, b) => Math.abs(a - b) < EPSILON;
+    // Helper function to check if a value has changed significantly
+    const hasChanged = (oldValue, newValue) => !isClose(oldValue, newValue);
+    // Find the current state of this line item
+    const currentItem = state.lineItems.find((item) => item.id === nextItem.id);
+    if (!currentItem) {
+        // New item, no comparison needed
+        return;
+    }
+    const taxRate = nextItem.taxPercent / 100;
+    // Check if totalPriceTaxExcl was changed and update unitPriceTaxExcl accordingly
+    const expectedTotalPriceTaxExcl = nextItem.quantity * nextItem.unitPriceTaxExcl;
+    if (hasChanged(expectedTotalPriceTaxExcl, nextItem.totalPriceTaxExcl)) {
+        // Total was changed, update unit price
+        nextItem.unitPriceTaxExcl = nextItem.totalPriceTaxExcl / nextItem.quantity;
+        // Update tax-inclusive unit price to maintain tax relationship
+        nextItem.unitPriceTaxIncl = nextItem.unitPriceTaxExcl * (1 + taxRate);
+        // Update tax-inclusive total to maintain consistency
+        nextItem.totalPriceTaxIncl = nextItem.quantity * nextItem.unitPriceTaxIncl;
+    }
+    // Check if totalPriceTaxIncl was changed and update unitPriceTaxIncl accordingly
+    const expectedTotalPriceTaxIncl = nextItem.quantity * nextItem.unitPriceTaxIncl;
+    if (hasChanged(expectedTotalPriceTaxIncl, nextItem.totalPriceTaxIncl)) {
+        // Total was changed, update unit price
+        nextItem.unitPriceTaxIncl = nextItem.totalPriceTaxIncl / nextItem.quantity;
+        // Update tax-exclusive unit price to maintain tax relationship
+        nextItem.unitPriceTaxExcl = nextItem.unitPriceTaxIncl / (1 + taxRate);
+        // Update tax-exclusive total to maintain consistency
+        nextItem.totalPriceTaxExcl = nextItem.quantity * nextItem.unitPriceTaxExcl;
+    }
+    // Check if unitPriceTaxExcl was changed and update totals accordingly
+    const expectedUnitPriceTaxIncl = nextItem.unitPriceTaxExcl * (1 + taxRate);
+    if (hasChanged(expectedUnitPriceTaxIncl, nextItem.unitPriceTaxIncl)) {
+        // Unit price was changed, update tax-inclusive unit price and totals
+        nextItem.unitPriceTaxIncl = nextItem.unitPriceTaxExcl * (1 + taxRate);
+        nextItem.totalPriceTaxExcl = nextItem.quantity * nextItem.unitPriceTaxExcl;
+        nextItem.totalPriceTaxIncl = nextItem.quantity * nextItem.unitPriceTaxIncl;
+    }
+    // Check if unitPriceTaxIncl was changed and update totals accordingly
+    const expectedUnitPriceTaxExcl = nextItem.unitPriceTaxIncl / (1 + taxRate);
+    if (hasChanged(expectedUnitPriceTaxExcl, nextItem.unitPriceTaxExcl)) {
+        // Unit price was changed, update tax-exclusive unit price and totals
+        nextItem.unitPriceTaxExcl = nextItem.unitPriceTaxIncl / (1 + taxRate);
+        nextItem.totalPriceTaxExcl = nextItem.quantity * nextItem.unitPriceTaxExcl;
+        nextItem.totalPriceTaxIncl = nextItem.quantity * nextItem.unitPriceTaxIncl;
+    }
+};

package/dist/document-models/invoice/v1/src/reducers/parties.d.ts

@@ -0,0 +1,3 @@
+import type { InvoicePartiesOperations } from "@powerhousedao/contributor-billing/document-models/invoice/v1";
+export declare const invoicePartiesOperations: InvoicePartiesOperations;
+//# sourceMappingURL=parties.d.ts.map

package/dist/document-models/invoice/v1/src/reducers/parties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parties.d.ts","sourceRoot":"","sources":["../../../../../../document-models/invoice/v1/src/reducers/parties.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+DAA+D,CAAC;AAS9G,eAAO,MAAM,wBAAwB,EAAE,wBAidtC,CAAC"}

package/dist/document-models/invoice/v1/src/reducers/transitions.d.ts

@@ -0,0 +1,3 @@
+import type { InvoiceTransitionsOperations } from "@powerhousedao/contributor-billing/document-models/invoice/v1";
+export declare const invoiceTransitionsOperations: InvoiceTransitionsOperations;
+//# sourceMappingURL=transitions.d.ts.map

package/dist/document-models/invoice/v1/src/reducers/transitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transitions.d.ts","sourceRoot":"","sources":["../../../../../../document-models/invoice/v1/src/reducers/transitions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,+DAA+D,CAAC;AA6BlH,eAAO,MAAM,4BAA4B,EAAE,4BA0K1C,CAAC"}

package/dist/document-models/invoice/v1/src/reducers/transitions.js

@@ -0,0 +1,191 @@
+/**
+ * Converts a date string to ISO datetime format if it's not already in that format
+ * Handles both date-only (YYYY-MM-DD) and datetime (YYYY-MM-DDTHH:mm:ss.sssZ) strings
+ */
+function ensureDatetimeFormat(dateStr) {
+    if (!dateStr || dateStr.trim() === "")
+        return null;
+    // If it's already a datetime string, return as is
+    if (dateStr.includes("T"))
+        return dateStr;
+    // Convert date-only to datetime at midnight UTC
+    return `${dateStr}T00:00:00.000Z`;
+}
+const permittedTransitions = {
+    DRAFT: ["CANCELLED", "ISSUED"],
+    CANCELLED: ["DRAFT"],
+    ISSUED: ["REJECTED", "ACCEPTED"],
+    REJECTED: ["ISSUED"],
+    ACCEPTED: ["PAYMENTSCHEDULED", "PAYMENTCLOSED"],
+    PAYMENTSCHEDULED: ["PAYMENTSENT", "PAYMENTISSUE", "PAYMENTCLOSED"],
+    PAYMENTSENT: ["PAYMENTISSUE", "PAYMENTRECEIVED"],
+    PAYMENTISSUE: ["ACCEPTED", "PAYMENTCLOSED"],
+    PAYMENTRECEIVED: ["PAYMENTISSUE"],
+    PAYMENTCLOSED: ["ACCEPTED"],
+};
+export const invoiceTransitionsOperations = {
+    cancelOperation(state) {
+        if (permittedTransitions[state.status].includes("CANCELLED")) {
+            state.status = "CANCELLED";
+        }
+        else {
+            throw new Error(`Invalid transition from ${state.status} to CANCELLED`);
+        }
+    },
+    issueOperation(state, action) {
+        if (!action.input.invoiceNo || !action.input.dateIssued) {
+            throw new Error("Invoice number and date issued are required");
+        }
+        const wallet = state.issuer?.paymentRouting?.wallet;
+        const stablecoins = ["USDS", "DAI", "USDC"];
+        const isStablecoin = stablecoins.includes(state.currency.toUpperCase());
+        if (isStablecoin &&
+            (!wallet?.address || (!wallet.chainName && !wallet.chainId))) {
+            throw new Error("Issuer wallet address and chain must be set before issuing an invoice");
+        }
+        if (permittedTransitions[state.status].includes("ISSUED")) {
+            state.status = "ISSUED";
+            state.invoiceNo = action.input.invoiceNo;
+            // Convert date string to datetime format to match Zod schema requirements
+            state.dateIssued =
+                ensureDatetimeFormat(action.input.dateIssued) ||
+                    action.input.dateIssued;
+        }
+        else {
+            throw new Error(`Invalid transition from ${state.status} to ISSUED`);
+        }
+    },
+    resetOperation(state) {
+        if (permittedTransitions[state.status].includes("DRAFT")) {
+            state.status = "DRAFT";
+        }
+        else {
+            throw new Error(`Invalid transition from ${state.status} to DRAFT`);
+        }
+    },
+    rejectOperation(state, action) {
+        if (!action.input.id || !action.input.reason) {
+            throw new Error("Reason, ID and final are required");
+        }
+        if (permittedTransitions[state.status].includes("REJECTED")) {
+            state.status = "REJECTED";
+            const rejection = {
+                id: action.input.id,
+                reason: action.input.reason,
+                final: action.input.final,
+            };
+            state.rejections.push(rejection);
+        }
+        else {
+            throw new Error(`Invalid transition from ${state.status} to REJECTED`);
+        }
+    },
+    acceptOperation(state, action) {
+        if (!action.input.payAfter) {
+            throw new Error("Pay after is required");
+        }
+        if (permittedTransitions[state.status].includes("ACCEPTED")) {
+            state.status = "ACCEPTED";
+            state.payAfter = action.input.payAfter;
+        }
+        else {
+            throw new Error(`Invalid transition from ${state.status} to ACCEPTED`);
+        }
+    },
+    reinstateOperation(state) {
+        const finalRejection = state.rejections.find((rejection) => rejection.final === true);
+        if (finalRejection) {
+            throw new Error("Cannot reinstate an invoice that has been rejected");
+        }
+        if (permittedTransitions[state.status].includes("ISSUED")) {
+            state.status = "ISSUED";
+        }
+        else {
+            throw new Error(`Invalid transition from ${state.status} to ISSUED`);
+        }
+    },
+    schedulePaymentOperation(state, action) {
+        if (!action.input.id || !action.input.processorRef) {
+            throw new Error("ID and processorRef are required");
+        }
+        if (permittedTransitions[state.status].includes("PAYMENTSCHEDULED")) {
+            state.status = "PAYMENTSCHEDULED";
+            state.payments.push({
+                id: action.input.id,
+                processorRef: action.input.processorRef,
+                paymentDate: action.input.paymentDate,
+                txnRef: "",
+                confirmed: false,
+                issue: "",
+                amount: 0,
+            });
+        }
+        else {
+            throw new Error(`Invalid transition from ${state.status} to PAYMENTSCHEDULED`);
+        }
+    },
+    reapprovePaymentOperation(state) {
+        if (permittedTransitions[state.status].includes("ACCEPTED")) {
+            state.status = "ACCEPTED";
+        }
+        else {
+            throw new Error(`Invalid transition from ${state.status} to ACCEPTED`);
+        }
+    },
+    registerPaymentTxOperation(state, action) {
+        if (permittedTransitions[state.status].includes("PAYMENTSENT")) {
+            state.status = "PAYMENTSENT";
+            const payment = state.payments.find((payment) => payment.id === action.input.id);
+            if (!payment)
+                throw new Error("Payment not found");
+            payment.txnRef = action.input.txRef;
+            payment.paymentDate = action.input.timestamp;
+        }
+        else {
+            throw new Error(`Invalid transition from ${state.status} to PAYMENTSENT`);
+        }
+    },
+    reportPaymentIssueOperation(state, action) {
+        if (!action.input.id || !action.input.issue) {
+            throw new Error("ID and issue are required");
+        }
+        if (permittedTransitions[state.status].includes("PAYMENTISSUE")) {
+            state.status = "PAYMENTISSUE";
+            const payment = state.payments.find((payment) => payment.id === action.input.id);
+            if (!payment)
+                throw new Error("Payment not found");
+            payment.issue = action.input.issue;
+        }
+        else {
+            throw new Error(`Invalid transition from ${state.status} to PAYMENTISSUE`);
+        }
+    },
+    confirmPaymentOperation(state, action) {
+        if (!action.input.id || !action.input.amount) {
+            throw new Error("ID and amount are required");
+        }
+        if (permittedTransitions[state.status].includes("PAYMENTRECEIVED")) {
+            state.status = "PAYMENTRECEIVED";
+            const payment = state.payments.find((payment) => payment.id === action.input.id);
+            if (!payment)
+                throw new Error("Payment not found");
+            payment.confirmed = true;
+            payment.amount = action.input.amount;
+        }
+        else {
+            throw new Error(`Invalid transition from ${state.status} to PAYMENTRECEIVED`);
+        }
+    },
+    closePaymentOperation(state, action) {
+        if (!action.input.closureReason) {
+            throw new Error("Closure reason is required");
+        }
+        if (permittedTransitions[state.status].includes("PAYMENTCLOSED")) {
+            state.status = "PAYMENTCLOSED";
+            state.closureReason = action.input.closureReason;
+        }
+        else {
+            throw new Error(`Invalid transition from ${state.status} to PAYMENTCLOSED`);
+        }
+    },
+};

package/dist/document-models/invoice/v1/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../document-models/invoice/v1/src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC"}

package/dist/document-models/invoice/v1/tests/document-model.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-model.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/invoice/v1/tests/document-model.test.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH;;;GAGG"}

package/dist/document-models/invoice/v1/tests/document-model.test.js

@@ -0,0 +1,104 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+import { describe, it, expect } from "vitest";
+import { utils, initialGlobalState, initialLocalState, invoiceDocumentType, isInvoiceDocument, assertIsInvoiceDocument, isInvoiceState, assertIsInvoiceState, } from "@powerhousedao/contributor-billing/document-models/invoice/v1";
+import { ZodError } from "zod";
+describe("Invoice Document Model", () => {
+    it("should create a new Invoice document", () => {
+        const document = utils.createDocument();
+        expect(document).toBeDefined();
+        expect(document.header.documentType).toBe(invoiceDocumentType);
+    });
+    it("should create a new Invoice document with a valid initial state", () => {
+        const document = utils.createDocument();
+        expect(document.state.global).toStrictEqual(initialGlobalState);
+        expect(document.state.local).toStrictEqual(initialLocalState);
+        expect(isInvoiceDocument(document)).toBe(true);
+        expect(isInvoiceState(document.state)).toBe(true);
+    });
+    it("should reject a document that is not a Invoice document", () => {
+        const wrongDocumentType = utils.createDocument();
+        wrongDocumentType.header.documentType = "the-wrong-thing-1234";
+        try {
+            expect(assertIsInvoiceDocument(wrongDocumentType)).toThrow();
+            expect(isInvoiceDocument(wrongDocumentType)).toBe(false);
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(ZodError);
+        }
+    });
+    const wrongState = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    wrongState.state.global = {
+        ...{ notWhat: "you want" },
+    };
+    try {
+        expect(isInvoiceState(wrongState.state)).toBe(false);
+        expect(assertIsInvoiceState(wrongState.state)).toThrow();
+        expect(isInvoiceDocument(wrongState)).toBe(false);
+        expect(assertIsInvoiceDocument(wrongState)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const wrongInitialState = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    wrongInitialState.initialState.global = {
+        ...{ notWhat: "you want" },
+    };
+    try {
+        expect(isInvoiceState(wrongInitialState.state)).toBe(false);
+        expect(assertIsInvoiceState(wrongInitialState.state)).toThrow();
+        expect(isInvoiceDocument(wrongInitialState)).toBe(false);
+        expect(assertIsInvoiceDocument(wrongInitialState)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingIdInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingIdInHeader.header.id;
+    try {
+        expect(isInvoiceDocument(missingIdInHeader)).toBe(false);
+        expect(assertIsInvoiceDocument(missingIdInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingNameInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingNameInHeader.header.name;
+    try {
+        expect(isInvoiceDocument(missingNameInHeader)).toBe(false);
+        expect(assertIsInvoiceDocument(missingNameInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingCreatedAtUtcIsoInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingCreatedAtUtcIsoInHeader.header.createdAtUtcIso;
+    try {
+        expect(isInvoiceDocument(missingCreatedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsInvoiceDocument(missingCreatedAtUtcIsoInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingLastModifiedAtUtcIsoInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingLastModifiedAtUtcIsoInHeader.header.lastModifiedAtUtcIso;
+    try {
+        expect(isInvoiceDocument(missingLastModifiedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsInvoiceDocument(missingLastModifiedAtUtcIsoInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+});

package/dist/document-models/invoice/v1/tests/general.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"general.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/invoice/v1/tests/general.test.ts"],"names":[],"mappings":""}

package/dist/document-models/invoice/v1/tests/general.test.js

@@ -0,0 +1,60 @@
+import { generateMock } from "@powerhousedao/common/utils";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isInvoiceDocument, editInvoice, addPayment, editPaymentData, editStatus, setExportedData, EditInvoiceInputSchema, AddPaymentInputSchema, EditPaymentDataInputSchema, EditStatusInputSchema, SetExportedDataInputSchema, } from "@powerhousedao/contributor-billing/document-models/invoice/v1";
+describe("GeneralOperations", () => {
+    it("should handle editInvoice operation", () => {
+        const document = utils.createDocument();
+        const input = {
+            ...generateMock(EditInvoiceInputSchema()),
+            dateIssued: "2024-01-01T00:00:00.000Z",
+            dateDue: "2024-02-01T00:00:00.000Z",
+            dateDelivered: "2024-01-15T00:00:00.000Z",
+        };
+        const updatedDocument = reducer(document, editInvoice(input));
+        expect(isInvoiceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("EDIT_INVOICE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle addPayment operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddPaymentInputSchema());
+        const updatedDocument = reducer(document, addPayment(input));
+        expect(isInvoiceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_PAYMENT");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle editPaymentData operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(EditPaymentDataInputSchema());
+        const updatedDocument = reducer(document, editPaymentData(input));
+        expect(isInvoiceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("EDIT_PAYMENT_DATA");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle editStatus operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(EditStatusInputSchema());
+        const updatedDocument = reducer(document, editStatus(input));
+        expect(isInvoiceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("EDIT_STATUS");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle setExportedData operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetExportedDataInputSchema());
+        const updatedDocument = reducer(document, setExportedData(input));
+        expect(isInvoiceDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_EXPORTED_DATA");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/invoice/v1/tests/items.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"items.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/invoice/v1/tests/items.test.ts"],"names":[],"mappings":""}