@powerhousedao/contributor-billing 0.1.41 → 0.1.43

package/dist/document-models/service-offering/src/reducers/tier-management.js

@@ -1,3 +1,4 @@
+import { AddPricingOptionTierNotFoundError, DuplicateBillingCycleError, UpdatePricingOptionTierNotFoundError, PricingOptionNotFoundError, RemovePricingOptionTierNotFoundError, RemovePricingOptionNotFoundError, } from "../../gen/tier-management/error.js";
 export const serviceOfferingTierManagementOperations = {
     addTierOperation(state, action) {
         state.tiers.push({
@@ -10,29 +11,36 @@ export const serviceOfferingTierManagementOperations = {
                 amount: action.input.amount || null,
                 currency: action.input.currency,
                 billingCycle: action.input.billingCycle,
-                setupFee: action.input.setupFee || null
+                setupFee: action.input.setupFee || null,
+                perSeatAmount: action.input.perSeatAmount || null,
+                perSeatCurrency: action.input.perSeatCurrency || null,
+                perSeatBillingCycle: action.input.perSeatBillingCycle || null,
+                perSeatLabel: action.input.perSeatLabel || null,
             },
-            isCustomPricing: action.input.isCustomPricing || false
+            pricingOptions: [],
+            isCustomPricing: action.input.isCustomPricing || false,
         });
         state.lastModified = action.input.lastModified;
     },
     updateTierOperation(state, action) {
-        const tier = state.tiers.find(t => t.id === action.input.id);
+        const tier = state.tiers.find((t) => t.id === action.input.id);
         if (tier) {
             if (action.input.name) {
                 tier.name = action.input.name;
             }
-            if (action.input.description !== undefined && action.input.description !== null) {
+            if (action.input.description !== undefined &&
+                action.input.description !== null) {
                 tier.description = action.input.description;
             }
-            if (action.input.isCustomPricing !== undefined && action.input.isCustomPricing !== null) {
+            if (action.input.isCustomPricing !== undefined &&
+                action.input.isCustomPricing !== null) {
                 tier.isCustomPricing = action.input.isCustomPricing;
             }
         }
         state.lastModified = action.input.lastModified;
     },
     updateTierPricingOperation(state, action) {
-        const tier = state.tiers.find(t => t.id === action.input.tierId);
+        const tier = state.tiers.find((t) => t.id === action.input.tierId);
         if (tier) {
             if (action.input.amount !== undefined) {
                 tier.pricing.amount = action.input.amount;
@@ -46,18 +54,31 @@ export const serviceOfferingTierManagementOperations = {
             if (action.input.setupFee !== undefined) {
                 tier.pricing.setupFee = action.input.setupFee;
             }
+            if (action.input.perSeatAmount !== undefined) {
+                tier.pricing.perSeatAmount = action.input.perSeatAmount;
+            }
+            if (action.input.perSeatCurrency !== undefined) {
+                tier.pricing.perSeatCurrency = action.input.perSeatCurrency || null;
+            }
+            if (action.input.perSeatBillingCycle !== undefined) {
+                tier.pricing.perSeatBillingCycle =
+                    action.input.perSeatBillingCycle || null;
+            }
+            if (action.input.perSeatLabel !== undefined) {
+                tier.pricing.perSeatLabel = action.input.perSeatLabel || null;
+            }
         }
         state.lastModified = action.input.lastModified;
     },
     deleteTierOperation(state, action) {
-        const tierIndex = state.tiers.findIndex(t => t.id === action.input.id);
+        const tierIndex = state.tiers.findIndex((t) => t.id === action.input.id);
         if (tierIndex !== -1) {
             state.tiers.splice(tierIndex, 1);
         }
         state.lastModified = action.input.lastModified;
     },
     addServiceLevelOperation(state, action) {
-        const tier = state.tiers.find(t => t.id === action.input.tierId);
+        const tier = state.tiers.find((t) => t.id === action.input.tierId);
         if (tier) {
             tier.serviceLevels.push({
                 id: action.input.serviceLevelId,
@@ -67,15 +88,15 @@ export const serviceOfferingTierManagementOperations = {
                 variations: action.input.variations || null,
                 annexes: action.input.annexes || null,
                 customValue: action.input.customValue || null,
-                setupFee: action.input.setupFee || null
+                setupFee: action.input.setupFee || null,
             });
         }
         state.lastModified = action.input.lastModified;
     },
     updateServiceLevelOperation(state, action) {
-        const tier = state.tiers.find(t => t.id === action.input.tierId);
+        const tier = state.tiers.find((t) => t.id === action.input.tierId);
         if (tier) {
-            const serviceLevel = tier.serviceLevels.find(sl => sl.id === action.input.serviceLevelId);
+            const serviceLevel = tier.serviceLevels.find((sl) => sl.id === action.input.serviceLevelId);
             if (serviceLevel) {
                 if (action.input.level) {
                     serviceLevel.level = action.input.level;
@@ -100,9 +121,9 @@ export const serviceOfferingTierManagementOperations = {
         state.lastModified = action.input.lastModified;
     },
     removeServiceLevelOperation(state, action) {
-        const tier = state.tiers.find(t => t.id === action.input.tierId);
+        const tier = state.tiers.find((t) => t.id === action.input.tierId);
         if (tier) {
-            const serviceLevelIndex = tier.serviceLevels.findIndex(sl => sl.id === action.input.serviceLevelId);
+            const serviceLevelIndex = tier.serviceLevels.findIndex((sl) => sl.id === action.input.serviceLevelId);
             if (serviceLevelIndex !== -1) {
                 tier.serviceLevels.splice(serviceLevelIndex, 1);
             }
@@ -110,48 +131,137 @@ export const serviceOfferingTierManagementOperations = {
         state.lastModified = action.input.lastModified;
     },
     addUsageLimitOperation(state, action) {
-        const tier = state.tiers.find(t => t.id === action.input.tierId);
+        const tier = state.tiers.find((t) => t.id === action.input.tierId);
         if (tier) {
             tier.usageLimits.push({
                 id: action.input.limitId,
                 serviceId: action.input.serviceId,
                 metric: action.input.metric,
+                unitName: action.input.unitName || null,
                 limit: action.input.limit || null,
                 resetPeriod: action.input.resetPeriod || null,
-                notes: action.input.notes || null
+                notes: action.input.notes || null,
+                unitPrice: action.input.unitPrice || null,
+                unitPriceCurrency: action.input.unitPriceCurrency || null,
+                unitPriceBillingCycle: action.input.unitPriceBillingCycle || null,
             });
         }
         state.lastModified = action.input.lastModified;
     },
     updateUsageLimitOperation(state, action) {
-        const tier = state.tiers.find(t => t.id === action.input.tierId);
+        const tier = state.tiers.find((t) => t.id === action.input.tierId);
         if (tier) {
-            const usageLimit = tier.usageLimits.find(ul => ul.id === action.input.limitId);
+            const usageLimit = tier.usageLimits.find((ul) => ul.id === action.input.limitId);
             if (usageLimit) {
                 if (action.input.metric) {
                     usageLimit.metric = action.input.metric;
                 }
+                if (action.input.unitName !== undefined) {
+                    usageLimit.unitName = action.input.unitName || null;
+                }
                 if (action.input.limit !== undefined && action.input.limit !== null) {
                     usageLimit.limit = action.input.limit;
                 }
                 if (action.input.resetPeriod) {
                     usageLimit.resetPeriod = action.input.resetPeriod;
                 }
-                if (action.input.notes !== undefined && action.input.notes !== null) {
-                    usageLimit.notes = action.input.notes;
+                if (action.input.notes !== undefined) {
+                    usageLimit.notes = action.input.notes || null;
+                }
+                if (action.input.unitPrice !== undefined) {
+                    usageLimit.unitPrice = action.input.unitPrice || null;
+                }
+                if (action.input.unitPriceCurrency !== undefined) {
+                    usageLimit.unitPriceCurrency =
+                        action.input.unitPriceCurrency || null;
+                }
+                if (action.input.unitPriceBillingCycle !== undefined) {
+                    usageLimit.unitPriceBillingCycle =
+                        action.input.unitPriceBillingCycle || null;
                 }
             }
         }
         state.lastModified = action.input.lastModified;
     },
     removeUsageLimitOperation(state, action) {
-        const tier = state.tiers.find(t => t.id === action.input.tierId);
+        const tier = state.tiers.find((t) => t.id === action.input.tierId);
         if (tier) {
-            const limitIndex = tier.usageLimits.findIndex(ul => ul.id === action.input.limitId);
+            const limitIndex = tier.usageLimits.findIndex((ul) => ul.id === action.input.limitId);
             if (limitIndex !== -1) {
                 tier.usageLimits.splice(limitIndex, 1);
             }
         }
         state.lastModified = action.input.lastModified;
     },
+    addTierPricingOptionOperation(state, action) {
+        const tier = state.tiers.find((t) => t.id === action.input.tierId);
+        if (!tier) {
+            throw new AddPricingOptionTierNotFoundError("Tier with the specified ID does not exist");
+        }
+        const existingCycle = tier.pricingOptions.find((po) => po.billingCycle === action.input.billingCycle);
+        if (existingCycle) {
+            throw new DuplicateBillingCycleError("A pricing option with this billing cycle already exists for this tier");
+        }
+        const isDefault = action.input.isDefault || tier.pricingOptions.length === 0;
+        if (isDefault) {
+            tier.pricingOptions.forEach((po) => {
+                po.isDefault = false;
+            });
+        }
+        tier.pricingOptions.push({
+            id: action.input.pricingOptionId,
+            billingCycle: action.input.billingCycle,
+            amount: action.input.amount,
+            currency: action.input.currency,
+            setupFee: action.input.setupFee || null,
+            perSeatAmount: action.input.perSeatAmount || null,
+            isDefault: isDefault,
+        });
+        state.lastModified = action.input.lastModified;
+    },
+    updateTierPricingOptionOperation(state, action) {
+        const tier = state.tiers.find((t) => t.id === action.input.tierId);
+        if (!tier) {
+            throw new UpdatePricingOptionTierNotFoundError("Tier with the specified ID does not exist");
+        }
+        const pricingOption = tier.pricingOptions.find((po) => po.id === action.input.pricingOptionId);
+        if (!pricingOption) {
+            throw new PricingOptionNotFoundError("Pricing option with the specified ID does not exist");
+        }
+        if (action.input.amount !== undefined && action.input.amount !== null) {
+            pricingOption.amount = action.input.amount;
+        }
+        if (action.input.currency) {
+            pricingOption.currency = action.input.currency;
+        }
+        if (action.input.setupFee !== undefined) {
+            pricingOption.setupFee = action.input.setupFee || null;
+        }
+        if (action.input.perSeatAmount !== undefined) {
+            pricingOption.perSeatAmount = action.input.perSeatAmount || null;
+        }
+        if (action.input.isDefault === true) {
+            tier.pricingOptions.forEach((po) => {
+                po.isDefault = false;
+            });
+            pricingOption.isDefault = true;
+        }
+        state.lastModified = action.input.lastModified;
+    },
+    removeTierPricingOptionOperation(state, action) {
+        const tier = state.tiers.find((t) => t.id === action.input.tierId);
+        if (!tier) {
+            throw new RemovePricingOptionTierNotFoundError("Tier with the specified ID does not exist");
+        }
+        const optionIndex = tier.pricingOptions.findIndex((po) => po.id === action.input.pricingOptionId);
+        if (optionIndex === -1) {
+            throw new RemovePricingOptionNotFoundError("Pricing option with the specified ID does not exist");
+        }
+        const wasDefault = tier.pricingOptions[optionIndex].isDefault;
+        tier.pricingOptions.splice(optionIndex, 1);
+        if (wasDefault && tier.pricingOptions.length > 0) {
+            tier.pricingOptions[0].isDefault = true;
+        }
+        state.lastModified = action.input.lastModified;
+    },
 };

package/dist/document-models/service-offering/tests/document-model.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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
+ */
+export {};
+//# sourceMappingURL=document-model.test.d.ts.map

package/dist/document-models/service-offering/tests/document-model.test.d.ts.map

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

package/dist/document-models/service-offering/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, serviceOfferingDocumentType, isServiceOfferingDocument, assertIsServiceOfferingDocument, isServiceOfferingState, assertIsServiceOfferingState, } from "@powerhousedao/contributor-billing/document-models/service-offering";
+import { ZodError } from "zod";
+describe("ServiceOffering Document Model", () => {
+    it("should create a new ServiceOffering document", () => {
+        const document = utils.createDocument();
+        expect(document).toBeDefined();
+        expect(document.header.documentType).toBe(serviceOfferingDocumentType);
+    });
+    it("should create a new ServiceOffering document with a valid initial state", () => {
+        const document = utils.createDocument();
+        expect(document.state.global).toStrictEqual(initialGlobalState);
+        expect(document.state.local).toStrictEqual(initialLocalState);
+        expect(isServiceOfferingDocument(document)).toBe(true);
+        expect(isServiceOfferingState(document.state)).toBe(true);
+    });
+    it("should reject a document that is not a ServiceOffering document", () => {
+        const wrongDocumentType = utils.createDocument();
+        wrongDocumentType.header.documentType = "the-wrong-thing-1234";
+        try {
+            expect(assertIsServiceOfferingDocument(wrongDocumentType)).toThrow();
+            expect(isServiceOfferingDocument(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(isServiceOfferingState(wrongState.state)).toBe(false);
+        expect(assertIsServiceOfferingState(wrongState.state)).toThrow();
+        expect(isServiceOfferingDocument(wrongState)).toBe(false);
+        expect(assertIsServiceOfferingDocument(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(isServiceOfferingState(wrongInitialState.state)).toBe(false);
+        expect(assertIsServiceOfferingState(wrongInitialState.state)).toThrow();
+        expect(isServiceOfferingDocument(wrongInitialState)).toBe(false);
+        expect(assertIsServiceOfferingDocument(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(isServiceOfferingDocument(missingIdInHeader)).toBe(false);
+        expect(assertIsServiceOfferingDocument(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(isServiceOfferingDocument(missingNameInHeader)).toBe(false);
+        expect(assertIsServiceOfferingDocument(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(isServiceOfferingDocument(missingCreatedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsServiceOfferingDocument(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(isServiceOfferingDocument(missingLastModifiedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsServiceOfferingDocument(missingLastModifiedAtUtcIsoInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+});

package/dist/document-models/service-offering/tests/offering-management.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=offering-management.test.d.ts.map

package/dist/document-models/service-offering/tests/offering-management.test.d.ts.map

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

package/dist/document-models/service-offering/tests/offering-management.test.js

@@ -0,0 +1,145 @@
+import { generateMock } from "@powerhousedao/codegen";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isServiceOfferingDocument, updateOfferingInfo, updateOfferingStatus, setOperator, setOfferingId, addTargetAudience, removeTargetAudience, setFacetTarget, removeFacetTarget, addFacetOption, removeFacetOption, setSetupServices, setRecurringServices, UpdateOfferingInfoInputSchema, UpdateOfferingStatusInputSchema, SetOperatorInputSchema, SetOfferingIdInputSchema, AddTargetAudienceInputSchema, RemoveTargetAudienceInputSchema, SetFacetTargetInputSchema, RemoveFacetTargetInputSchema, AddFacetOptionInputSchema, RemoveFacetOptionInputSchema, SetSetupServicesInputSchema, SetRecurringServicesInputSchema, selectResourceTemplate, changeResourceTemplate, SelectResourceTemplateInputSchema, ChangeResourceTemplateInputSchema, } from "@powerhousedao/contributor-billing/document-models/service-offering";
+describe("OfferingManagementOperations", () => {
+    it("should handle updateOfferingInfo operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateOfferingInfoInputSchema());
+        const updatedDocument = reducer(document, updateOfferingInfo(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_OFFERING_INFO");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateOfferingStatus operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateOfferingStatusInputSchema());
+        const updatedDocument = reducer(document, updateOfferingStatus(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_OFFERING_STATUS");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle setOperator operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetOperatorInputSchema());
+        const updatedDocument = reducer(document, setOperator(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_OPERATOR");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle setOfferingId operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetOfferingIdInputSchema());
+        const updatedDocument = reducer(document, setOfferingId(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_OFFERING_ID");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle addTargetAudience operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddTargetAudienceInputSchema());
+        const updatedDocument = reducer(document, addTargetAudience(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_TARGET_AUDIENCE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeTargetAudience operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveTargetAudienceInputSchema());
+        const updatedDocument = reducer(document, removeTargetAudience(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_TARGET_AUDIENCE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle setFacetTarget operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetFacetTargetInputSchema());
+        const updatedDocument = reducer(document, setFacetTarget(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_FACET_TARGET");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeFacetTarget operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveFacetTargetInputSchema());
+        const updatedDocument = reducer(document, removeFacetTarget(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_FACET_TARGET");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle addFacetOption operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddFacetOptionInputSchema());
+        const updatedDocument = reducer(document, addFacetOption(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_FACET_OPTION");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeFacetOption operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveFacetOptionInputSchema());
+        const updatedDocument = reducer(document, removeFacetOption(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_FACET_OPTION");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle setSetupServices operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetSetupServicesInputSchema());
+        const updatedDocument = reducer(document, setSetupServices(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_SETUP_SERVICES");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle setRecurringServices operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetRecurringServicesInputSchema());
+        const updatedDocument = reducer(document, setRecurringServices(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_RECURRING_SERVICES");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle selectResourceTemplate operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SelectResourceTemplateInputSchema());
+        const updatedDocument = reducer(document, selectResourceTemplate(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("SELECT_RESOURCE_TEMPLATE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle changeResourceTemplate operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(ChangeResourceTemplateInputSchema());
+        const updatedDocument = reducer(document, changeResourceTemplate(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("CHANGE_RESOURCE_TEMPLATE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/service-offering/tests/option-group-management.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=option-group-management.test.d.ts.map

package/dist/document-models/service-offering/tests/option-group-management.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"option-group-management.test.d.ts","sourceRoot":"","sources":["../../../../document-models/service-offering/tests/option-group-management.test.ts"],"names":[],"mappings":""}

package/dist/document-models/service-offering/tests/option-group-management.test.js

@@ -0,0 +1,35 @@
+import { generateMock } from "@powerhousedao/codegen";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isServiceOfferingDocument, addOptionGroup, updateOptionGroup, deleteOptionGroup, AddOptionGroupInputSchema, UpdateOptionGroupInputSchema, DeleteOptionGroupInputSchema, } from "@powerhousedao/contributor-billing/document-models/service-offering";
+describe("OptionGroupManagementOperations", () => {
+    it("should handle addOptionGroup operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddOptionGroupInputSchema());
+        const updatedDocument = reducer(document, addOptionGroup(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_OPTION_GROUP");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateOptionGroup operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateOptionGroupInputSchema());
+        const updatedDocument = reducer(document, updateOptionGroup(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_OPTION_GROUP");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle deleteOptionGroup operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(DeleteOptionGroupInputSchema());
+        const updatedDocument = reducer(document, deleteOptionGroup(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("DELETE_OPTION_GROUP");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/service-offering/tests/service-management.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=service-management.test.d.ts.map

package/dist/document-models/service-offering/tests/service-management.test.d.ts.map

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

package/dist/document-models/service-offering/tests/service-management.test.js

@@ -0,0 +1,55 @@
+import { generateMock } from "@powerhousedao/codegen";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isServiceOfferingDocument, addService, updateService, deleteService, addFacetBinding, removeFacetBinding, AddServiceInputSchema, UpdateServiceInputSchema, DeleteServiceInputSchema, AddFacetBindingInputSchema, RemoveFacetBindingInputSchema, } from "@powerhousedao/contributor-billing/document-models/service-offering";
+describe("ServiceManagementOperations", () => {
+    it("should handle addService operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddServiceInputSchema());
+        const updatedDocument = reducer(document, addService(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_SERVICE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle updateService operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(UpdateServiceInputSchema());
+        const updatedDocument = reducer(document, updateService(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_SERVICE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle deleteService operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(DeleteServiceInputSchema());
+        const updatedDocument = reducer(document, deleteService(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("DELETE_SERVICE");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle addFacetBinding operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(AddFacetBindingInputSchema());
+        const updatedDocument = reducer(document, addFacetBinding(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_FACET_BINDING");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle removeFacetBinding operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(RemoveFacetBindingInputSchema());
+        const updatedDocument = reducer(document, removeFacetBinding(input));
+        expect(isServiceOfferingDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_FACET_BINDING");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/service-offering/tests/tier-management.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tier-management.test.d.ts.map

package/dist/document-models/service-offering/tests/tier-management.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-management.test.d.ts","sourceRoot":"","sources":["../../../../document-models/service-offering/tests/tier-management.test.ts"],"names":[],"mappings":""}