@powerhousedao/network-admin 1.0.0-dev.2 → 1.0.0-staging.3

package/dist/document-models/payment-terms/src/reducers/clauses.js

@@ -1,9 +1,8 @@
-import { DuplicateBonusClauseIdError, BonusClauseNotFoundError, DuplicatePenaltyClauseIdError, PenaltyClauseNotFoundError, } from "../../gen/clauses/error.js";
-export const reducer = {
-    addBonusClauseOperation(state, action, dispatch) {
+export const paymentTermsClausesOperations = {
+    addBonusClauseOperation(state, action) {
         const existingIndex = state.bonusClauses.findIndex((c) => c.id === action.input.id);
         if (existingIndex !== -1) {
-            throw new DuplicateBonusClauseIdError(`Bonus clause with ID ${action.input.id} already exists`);
+            throw new Error(`Bonus clause with ID ${action.input.id} already exists`);
         }
         const newClause = {
             id: action.input.id,
@@ -13,10 +12,10 @@ export const reducer = {
         };
         state.bonusClauses.push(newClause);
     },
-    updateBonusClauseOperation(state, action, dispatch) {
+    updateBonusClauseOperation(state, action) {
         const clauseIndex = state.bonusClauses.findIndex((c) => c.id === action.input.id);
         if (clauseIndex === -1) {
-            throw new BonusClauseNotFoundError(`Bonus clause with ID ${action.input.id} not found`);
+            throw new Error(`Bonus clause with ID ${action.input.id} not found`);
         }
         const clause = state.bonusClauses[clauseIndex];
         if (action.input.condition)
@@ -26,17 +25,17 @@ export const reducer = {
         if (action.input.comment !== undefined)
             clause.comment = action.input.comment || null;
     },
-    deleteBonusClauseOperation(state, action, dispatch) {
+    deleteBonusClauseOperation(state, action) {
         const clauseIndex = state.bonusClauses.findIndex((c) => c.id === action.input.id);
         if (clauseIndex === -1) {
-            throw new BonusClauseNotFoundError(`Bonus clause with ID ${action.input.id} not found`);
+            throw new Error(`Bonus clause with ID ${action.input.id} not found`);
         }
         state.bonusClauses.splice(clauseIndex, 1);
     },
-    addPenaltyClauseOperation(state, action, dispatch) {
+    addPenaltyClauseOperation(state, action) {
         const existingIndex = state.penaltyClauses.findIndex((c) => c.id === action.input.id);
         if (existingIndex !== -1) {
-            throw new DuplicatePenaltyClauseIdError(`Penalty clause with ID ${action.input.id} already exists`);
+            throw new Error(`Penalty clause with ID ${action.input.id} already exists`);
         }
         const newClause = {
             id: action.input.id,
@@ -46,10 +45,10 @@ export const reducer = {
         };
         state.penaltyClauses.push(newClause);
     },
-    updatePenaltyClauseOperation(state, action, dispatch) {
+    updatePenaltyClauseOperation(state, action) {
         const clauseIndex = state.penaltyClauses.findIndex((c) => c.id === action.input.id);
         if (clauseIndex === -1) {
-            throw new PenaltyClauseNotFoundError(`Penalty clause with ID ${action.input.id} not found`);
+            throw new Error(`Penalty clause with ID ${action.input.id} not found`);
         }
         const clause = state.penaltyClauses[clauseIndex];
         if (action.input.condition)
@@ -59,12 +58,11 @@ export const reducer = {
         if (action.input.comment !== undefined)
             clause.comment = action.input.comment || null;
     },
-    deletePenaltyClauseOperation(state, action, dispatch) {
+    deletePenaltyClauseOperation(state, action) {
         const clauseIndex = state.penaltyClauses.findIndex((c) => c.id === action.input.id);
         if (clauseIndex === -1) {
-            throw new PenaltyClauseNotFoundError(`Penalty clause with ID ${action.input.id} not found`);
+            throw new Error(`Penalty clause with ID ${action.input.id} not found`);
         }
         state.penaltyClauses.splice(clauseIndex, 1);
     },
 };
-export const paymentTermsClausesOperations = {};

package/dist/document-models/payment-terms/src/reducers/milestones.d.ts

@@ -1,4 +1,3 @@
 import type { PaymentTermsMilestonesOperations } from "@powerhousedao/network-admin/document-models/payment-terms";
-export declare const reducer: PaymentTermsMilestonesOperations;
 export declare const paymentTermsMilestonesOperations: PaymentTermsMilestonesOperations;
 //# sourceMappingURL=milestones.d.ts.map

package/dist/document-models/payment-terms/src/reducers/milestones.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"milestones.d.ts","sourceRoot":"","sources":["../../../../../document-models/payment-terms/src/reducers/milestones.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,4DAA4D,CAAC;AAEnH,eAAO,MAAM,OAAO,EAAE,gCA+ErB,CAAC;AACF,eAAO,MAAM,gCAAgC,EAAE,gCAC3C,CAAC"}
+{"version":3,"file":"milestones.d.ts","sourceRoot":"","sources":["../../../../../document-models/payment-terms/src/reducers/milestones.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,4DAA4D,CAAC;AAEnH,eAAO,MAAM,gCAAgC,EAAE,gCAwE5C,CAAC"}

package/dist/document-models/payment-terms/src/reducers/milestones.js

@@ -1,9 +1,8 @@
-import { DuplicateMilestoneIdError, MilestoneNotFoundError, } from "../../gen/milestones/error.js";
-export const reducer = {
-    addMilestoneOperation(state, action, dispatch) {
+export const paymentTermsMilestonesOperations = {
+    addMilestoneOperation(state, action) {
         const existingIndex = state.milestoneSchedule.findIndex((m) => m.id === action.input.id);
         if (existingIndex !== -1) {
-            throw new DuplicateMilestoneIdError(`Milestone with ID ${action.input.id} already exists`);
+            throw new Error(`Milestone with ID ${action.input.id} already exists`);
         }
         const newMilestone = {
             id: action.input.id,
@@ -15,10 +14,10 @@ export const reducer = {
         };
         state.milestoneSchedule.push(newMilestone);
     },
-    updateMilestoneOperation(state, action, dispatch) {
+    updateMilestoneOperation(state, action) {
         const milestoneIndex = state.milestoneSchedule.findIndex((m) => m.id === action.input.id);
         if (milestoneIndex === -1) {
-            throw new MilestoneNotFoundError(`Milestone with ID ${action.input.id} not found`);
+            throw new Error(`Milestone with ID ${action.input.id} not found`);
         }
         const milestone = state.milestoneSchedule[milestoneIndex];
         if (action.input.name)
@@ -32,22 +31,22 @@ export const reducer = {
             action.input.requiresApproval !== null)
             milestone.requiresApproval = action.input.requiresApproval;
     },
-    updateMilestoneStatusOperation(state, action, dispatch) {
+    updateMilestoneStatusOperation(state, action) {
         const milestoneIndex = state.milestoneSchedule.findIndex((m) => m.id === action.input.id);
         if (milestoneIndex === -1) {
-            throw new MilestoneNotFoundError(`Milestone with ID ${action.input.id} not found`);
+            throw new Error(`Milestone with ID ${action.input.id} not found`);
         }
         state.milestoneSchedule[milestoneIndex].payoutStatus =
             action.input.payoutStatus;
     },
-    deleteMilestoneOperation(state, action, dispatch) {
+    deleteMilestoneOperation(state, action) {
         const milestoneIndex = state.milestoneSchedule.findIndex((m) => m.id === action.input.id);
         if (milestoneIndex === -1) {
-            throw new MilestoneNotFoundError(`Milestone with ID ${action.input.id} not found`);
+            throw new Error(`Milestone with ID ${action.input.id} not found`);
         }
         state.milestoneSchedule.splice(milestoneIndex, 1);
     },
-    reorderMilestonesOperation(state, action, dispatch) {
+    reorderMilestonesOperation(state, action) {
         const reorderedMilestones = [];
         for (const id of action.input.order) {
             const milestone = state.milestoneSchedule.find((m) => m.id === id);
@@ -58,4 +57,3 @@ export const reducer = {
         state.milestoneSchedule = reorderedMilestones;
     },
 };
-export const paymentTermsMilestonesOperations = {};

package/dist/document-models/payment-terms/src/reducers/terms.d.ts

@@ -1,4 +1,3 @@
 import type { PaymentTermsTermsOperations } from "@powerhousedao/network-admin/document-models/payment-terms";
-export declare const reducer: PaymentTermsTermsOperations;
 export declare const paymentTermsTermsOperations: PaymentTermsTermsOperations;
 //# sourceMappingURL=terms.d.ts.map

package/dist/document-models/payment-terms/src/reducers/terms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"terms.d.ts","sourceRoot":"","sources":["../../../../../document-models/payment-terms/src/reducers/terms.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,4DAA4D,CAAC;AAE9G,eAAO,MAAM,OAAO,EAAE,2BA+CrB,CAAC;AACF,eAAO,MAAM,2BAA2B,EAAE,2BAAgC,CAAC"}
+{"version":3,"file":"terms.d.ts","sourceRoot":"","sources":["../../../../../document-models/payment-terms/src/reducers/terms.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,4DAA4D,CAAC;AAE9G,eAAO,MAAM,2BAA2B,EAAE,2BAsCzC,CAAC"}

package/dist/document-models/payment-terms/src/reducers/terms.js

@@ -1,15 +1,24 @@
-export const reducer = {
-    setBasicTermsOperation(state, action, dispatch) {
+export const paymentTermsTermsOperations = {
+    setBasicTermsOperation(state, action) {
         state.proposer = action.input.proposer;
         state.payer = action.input.payer;
         state.currency = action.input.currency;
         state.paymentModel = action.input.paymentModel;
         state.totalAmount = action.input.totalAmount || null;
     },
-    updateStatusOperation(state, action, dispatch) {
+    updateStatusOperation(state, action) {
         state.status = action.input.status;
     },
-    setEscrowDetailsOperation(state, action, dispatch) {
+    setTimeAndMaterialsOperation(state, action) {
+        state.timeAndMaterials = {
+            retainerAmount: action.input.retainerAmount || null,
+            hourlyRate: action.input.hourlyRate || null,
+            variableCap: action.input.variableCap || null,
+            billingFrequency: action.input.billingFrequency,
+            timesheetRequired: action.input.timesheetRequired,
+        };
+    },
+    setEscrowDetailsOperation(state, action) {
         state.escrowDetails = {
             amountHeld: action.input.amountHeld,
             proofOfFundsDocumentId: action.input.proofOfFundsDocumentId || null,
@@ -17,7 +26,7 @@ export const reducer = {
             escrowProvider: action.input.escrowProvider || null,
         };
     },
-    setEvaluationTermsOperation(state, action, dispatch) {
+    setEvaluationTermsOperation(state, action) {
         state.evaluation = {
             evaluationFrequency: action.input.evaluationFrequency,
             evaluatorTeam: action.input.evaluatorTeam,
@@ -27,23 +36,4 @@ export const reducer = {
             commentsVisibleToClient: action.input.commentsVisibleToClient,
         };
     },
-    setCostAndMaterialsOperation(state, action, dispatch) {
-        state.costAndMaterials = {
-            hourlyRate: action.input.hourlyRate || null,
-            variableCap: action.input.variableCap || null,
-            billingFrequency: action.input.billingFrequency,
-            timesheetRequired: action.input.timesheetRequired,
-        };
-    },
-    setRetainerDetailsOperation(state, action, dispatch) {
-        state.retainerDetails = {
-            retainerAmount: action.input.retainerAmount,
-            billingFrequency: action.input.billingFrequency,
-            startDate: action.input.startDate,
-            endDate: action.input.endDate || null,
-            autoRenew: action.input.autoRenew,
-            servicesIncluded: action.input.servicesIncluded,
-        };
-    },
 };
-export const paymentTermsTermsOperations = {};

package/dist/document-models/payment-terms/src/tests/clauses.test.js

@@ -2,60 +2,65 @@
  * This is a scaffold file meant for customization:
  * - change it by adding new tests or modifying the existing ones
  */
-import { describe, it, expect, beforeEach } from "vitest";
+import { describe, it, expect } from "vitest";
 import { generateMock } from "@powerhousedao/codegen";
-import utils from "../../gen/utils.js";
-import { z, } from "../../gen/schema/index.js";
-import { reducer } from "../../gen/reducer.js";
-import * as creators from "../../gen/clauses/creators.js";
+import { reducer, utils, isPaymentTermsDocument, addBonusClause, AddBonusClauseInputSchema, updateBonusClause, UpdateBonusClauseInputSchema, deleteBonusClause, DeleteBonusClauseInputSchema, addPenaltyClause, AddPenaltyClauseInputSchema, updatePenaltyClause, UpdatePenaltyClauseInputSchema, deletePenaltyClause, DeletePenaltyClauseInputSchema, } from "@powerhousedao/network-admin/document-models/payment-terms";
 describe("Clauses Operations", () => {
-    let document;
-    beforeEach(() => {
-        document = utils.createDocument();
-    });
     it("should handle addBonusClause operation", () => {
-        const input = generateMock(z.AddBonusClauseInputSchema());
-        const updatedDocument = reducer(document, creators.addBonusClause(input));
+        const document = utils.createDocument();
+        const input = generateMock(AddBonusClauseInputSchema());
+        const updatedDocument = reducer(document, addBonusClause(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
         expect(updatedDocument.operations.global[0].action.type).toBe("ADD_BONUS_CLAUSE");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
     it("should handle updateBonusClause operation", () => {
-        const input = generateMock(z.UpdateBonusClauseInputSchema());
-        const updatedDocument = reducer(document, creators.updateBonusClause(input));
+        const document = utils.createDocument();
+        const input = generateMock(UpdateBonusClauseInputSchema());
+        const updatedDocument = reducer(document, updateBonusClause(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
         expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_BONUS_CLAUSE");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
     it("should handle deleteBonusClause operation", () => {
-        const input = generateMock(z.DeleteBonusClauseInputSchema());
-        const updatedDocument = reducer(document, creators.deleteBonusClause(input));
+        const document = utils.createDocument();
+        const input = generateMock(DeleteBonusClauseInputSchema());
+        const updatedDocument = reducer(document, deleteBonusClause(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
         expect(updatedDocument.operations.global[0].action.type).toBe("DELETE_BONUS_CLAUSE");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
     it("should handle addPenaltyClause operation", () => {
-        const input = generateMock(z.AddPenaltyClauseInputSchema());
-        const updatedDocument = reducer(document, creators.addPenaltyClause(input));
+        const document = utils.createDocument();
+        const input = generateMock(AddPenaltyClauseInputSchema());
+        const updatedDocument = reducer(document, addPenaltyClause(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
         expect(updatedDocument.operations.global[0].action.type).toBe("ADD_PENALTY_CLAUSE");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
     it("should handle updatePenaltyClause operation", () => {
-        const input = generateMock(z.UpdatePenaltyClauseInputSchema());
-        const updatedDocument = reducer(document, creators.updatePenaltyClause(input));
+        const document = utils.createDocument();
+        const input = generateMock(UpdatePenaltyClauseInputSchema());
+        const updatedDocument = reducer(document, updatePenaltyClause(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
         expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_PENALTY_CLAUSE");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
     it("should handle deletePenaltyClause operation", () => {
-        const input = generateMock(z.DeletePenaltyClauseInputSchema());
-        const updatedDocument = reducer(document, creators.deletePenaltyClause(input));
+        const document = utils.createDocument();
+        const input = generateMock(DeletePenaltyClauseInputSchema());
+        const updatedDocument = reducer(document, deletePenaltyClause(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
         expect(updatedDocument.operations.global[0].action.type).toBe("DELETE_PENALTY_CLAUSE");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);

package/dist/document-models/payment-terms/src/tests/document-model.test.d.ts

@@ -1,3 +1,7 @@
+/**
+ * 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

package/dist/document-models/payment-terms/src/tests/document-model.test.d.ts.map

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

package/dist/document-models/payment-terms/src/tests/document-model.test.js

@@ -2,17 +2,103 @@
  * This is a scaffold file meant for customization:
  * - change it by adding new tests or modifying the existing ones
  */
-import { describe, it, expect, beforeEach } from "vitest";
-import utils, { initialGlobalState, initialLocalState, } from "../../gen/utils.js";
-describe("Payment Terms Document Model", () => {
-    it("should create a new Payment Terms document", () => {
+/**
+ * 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, paymentTermsDocumentType, isPaymentTermsDocument, assertIsPaymentTermsDocument, isPaymentTermsState, assertIsPaymentTermsState, } from "@powerhousedao/network-admin/document-models/payment-terms";
+import { ZodError } from "zod";
+describe("PaymentTerms Document Model", () => {
+    it("should create a new PaymentTerms document", () => {
         const document = utils.createDocument();
         expect(document).toBeDefined();
-        expect(document.header.documentType).toBe("payment-terms");
+        expect(document.header.documentType).toBe(paymentTermsDocumentType);
     });
-    it("should create a new Payment Terms document with a valid initial state", () => {
+    it("should create a new PaymentTerms document with a valid initial state", () => {
         const document = utils.createDocument();
         expect(document.state.global).toStrictEqual(initialGlobalState);
         expect(document.state.local).toStrictEqual(initialLocalState);
+        expect(isPaymentTermsDocument(document)).toBe(true);
+        expect(isPaymentTermsState(document.state)).toBe(true);
+    });
+    it("should reject a document that is not a PaymentTerms document", () => {
+        const wrongDocumentType = utils.createDocument();
+        wrongDocumentType.header.documentType = "the-wrong-thing-1234";
+        try {
+            expect(assertIsPaymentTermsDocument(wrongDocumentType)).toThrow();
+            expect(isPaymentTermsDocument(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(isPaymentTermsState(wrongState.state)).toBe(false);
+        expect(assertIsPaymentTermsState(wrongState.state)).toThrow();
+        expect(isPaymentTermsDocument(wrongState)).toBe(false);
+        expect(assertIsPaymentTermsDocument(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(isPaymentTermsState(wrongInitialState.state)).toBe(false);
+        expect(assertIsPaymentTermsState(wrongInitialState.state)).toThrow();
+        expect(isPaymentTermsDocument(wrongInitialState)).toBe(false);
+        expect(assertIsPaymentTermsDocument(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(isPaymentTermsDocument(missingIdInHeader)).toBe(false);
+        expect(assertIsPaymentTermsDocument(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(isPaymentTermsDocument(missingNameInHeader)).toBe(false);
+        expect(assertIsPaymentTermsDocument(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(isPaymentTermsDocument(missingCreatedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsPaymentTermsDocument(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(isPaymentTermsDocument(missingLastModifiedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsPaymentTermsDocument(missingLastModifiedAtUtcIsoInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
 });

package/dist/document-models/payment-terms/src/tests/milestones.test.js

@@ -2,52 +2,55 @@
  * This is a scaffold file meant for customization:
  * - change it by adding new tests or modifying the existing ones
  */
-import { describe, it, expect, beforeEach } from "vitest";
+import { describe, it, expect } from "vitest";
 import { generateMock } from "@powerhousedao/codegen";
-import utils from "../../gen/utils.js";
-import { z, } from "../../gen/schema/index.js";
-import { reducer } from "../../gen/reducer.js";
-import * as creators from "../../gen/milestones/creators.js";
+import { reducer, utils, isPaymentTermsDocument, addMilestone, AddMilestoneInputSchema, updateMilestone, UpdateMilestoneInputSchema, updateMilestoneStatus, UpdateMilestoneStatusInputSchema, deleteMilestone, DeleteMilestoneInputSchema, reorderMilestones, ReorderMilestonesInputSchema, } from "@powerhousedao/network-admin/document-models/payment-terms";
 describe("Milestones Operations", () => {
-    let document;
-    beforeEach(() => {
-        document = utils.createDocument();
-    });
     it("should handle addMilestone operation", () => {
-        const input = generateMock(z.AddMilestoneInputSchema());
-        const updatedDocument = reducer(document, creators.addMilestone(input));
+        const document = utils.createDocument();
+        const input = generateMock(AddMilestoneInputSchema());
+        const updatedDocument = reducer(document, addMilestone(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
         expect(updatedDocument.operations.global[0].action.type).toBe("ADD_MILESTONE");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
     it("should handle updateMilestone operation", () => {
-        const input = generateMock(z.UpdateMilestoneInputSchema());
-        const updatedDocument = reducer(document, creators.updateMilestone(input));
+        const document = utils.createDocument();
+        const input = generateMock(UpdateMilestoneInputSchema());
+        const updatedDocument = reducer(document, updateMilestone(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
         expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_MILESTONE");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
     it("should handle updateMilestoneStatus operation", () => {
-        const input = generateMock(z.UpdateMilestoneStatusInputSchema());
-        const updatedDocument = reducer(document, creators.updateMilestoneStatus(input));
+        const document = utils.createDocument();
+        const input = generateMock(UpdateMilestoneStatusInputSchema());
+        const updatedDocument = reducer(document, updateMilestoneStatus(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
         expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_MILESTONE_STATUS");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
     it("should handle deleteMilestone operation", () => {
-        const input = generateMock(z.DeleteMilestoneInputSchema());
-        const updatedDocument = reducer(document, creators.deleteMilestone(input));
+        const document = utils.createDocument();
+        const input = generateMock(DeleteMilestoneInputSchema());
+        const updatedDocument = reducer(document, deleteMilestone(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
         expect(updatedDocument.operations.global[0].action.type).toBe("DELETE_MILESTONE");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
     it("should handle reorderMilestones operation", () => {
-        const input = generateMock(z.ReorderMilestonesInputSchema());
-        const updatedDocument = reducer(document, creators.reorderMilestones(input));
+        const document = utils.createDocument();
+        const input = generateMock(ReorderMilestonesInputSchema());
+        const updatedDocument = reducer(document, reorderMilestones(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
         expect(updatedDocument.operations.global[0].action.type).toBe("REORDER_MILESTONES");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);

package/dist/document-models/payment-terms/src/tests/terms.test.js

@@ -2,60 +2,55 @@
  * This is a scaffold file meant for customization:
  * - change it by adding new tests or modifying the existing ones
  */
-import { describe, it, expect, beforeEach } from "vitest";
+import { describe, it, expect } from "vitest";
 import { generateMock } from "@powerhousedao/codegen";
-import utils from "../../gen/utils.js";
-import { z, } from "../../gen/schema/index.js";
-import { reducer } from "../../gen/reducer.js";
-import * as creators from "../../gen/terms/creators.js";
+import { reducer, utils, isPaymentTermsDocument, setBasicTerms, SetBasicTermsInputSchema, updateStatus, UpdateStatusInputSchema, setTimeAndMaterials, SetTimeAndMaterialsInputSchema, setEscrowDetails, SetEscrowDetailsInputSchema, setEvaluationTerms, SetEvaluationTermsInputSchema, } from "@powerhousedao/network-admin/document-models/payment-terms";
 describe("Terms Operations", () => {
-    let document;
-    beforeEach(() => {
-        document = utils.createDocument();
-    });
     it("should handle setBasicTerms operation", () => {
-        const input = generateMock(z.SetBasicTermsInputSchema());
-        const updatedDocument = reducer(document, creators.setBasicTerms(input));
+        const document = utils.createDocument();
+        const input = generateMock(SetBasicTermsInputSchema());
+        const updatedDocument = reducer(document, setBasicTerms(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
         expect(updatedDocument.operations.global[0].action.type).toBe("SET_BASIC_TERMS");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
     it("should handle updateStatus operation", () => {
-        const input = generateMock(z.UpdateStatusInputSchema());
-        const updatedDocument = reducer(document, creators.updateStatus(input));
+        const document = utils.createDocument();
+        const input = generateMock(UpdateStatusInputSchema());
+        const updatedDocument = reducer(document, updateStatus(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
         expect(updatedDocument.operations.global[0].action.type).toBe("UPDATE_STATUS");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
-    it("should handle setCostAndMaterials operation", () => {
-        const input = generateMock(z.SetCostAndMaterialsInputSchema());
-        const updatedDocument = reducer(document, creators.setCostAndMaterials(input));
-        expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("SET_COST_AND_MATERIALS");
-        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
-        expect(updatedDocument.operations.global[0].index).toEqual(0);
-    });
-    it("should handle setRetainerDetails operation", () => {
-        const input = generateMock(z.SetRetainerDetailsInputSchema());
-        const updatedDocument = reducer(document, creators.setRetainerDetails(input));
+    it("should handle setTimeAndMaterials operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(SetTimeAndMaterialsInputSchema());
+        const updatedDocument = reducer(document, setTimeAndMaterials(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("SET_RETAINER_DETAILS");
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_TIME_AND_MATERIALS");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
     it("should handle setEscrowDetails operation", () => {
-        const input = generateMock(z.SetEscrowDetailsInputSchema());
-        const updatedDocument = reducer(document, creators.setEscrowDetails(input));
+        const document = utils.createDocument();
+        const input = generateMock(SetEscrowDetailsInputSchema());
+        const updatedDocument = reducer(document, setEscrowDetails(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
         expect(updatedDocument.operations.global[0].action.type).toBe("SET_ESCROW_DETAILS");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
     it("should handle setEvaluationTerms operation", () => {
-        const input = generateMock(z.SetEvaluationTermsInputSchema());
-        const updatedDocument = reducer(document, creators.setEvaluationTerms(input));
+        const document = utils.createDocument();
+        const input = generateMock(SetEvaluationTermsInputSchema());
+        const updatedDocument = reducer(document, setEvaluationTerms(input));
+        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
         expect(updatedDocument.operations.global[0].action.type).toBe("SET_EVALUATION_TERMS");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);

package/dist/document-models/payment-terms/tests/terms.test.js

@@ -1,6 +1,6 @@
 import { generateMock } from "@powerhousedao/codegen";
 import { describe, expect, it } from "vitest";
-import { reducer, utils, isPaymentTermsDocument, setBasicTerms, updateStatus, setCostAndMaterials, setEscrowDetails, setEvaluationTerms, setRetainerDetails, SetBasicTermsInputSchema, UpdateStatusInputSchema, SetCostAndMaterialsInputSchema, SetEscrowDetailsInputSchema, SetEvaluationTermsInputSchema, SetRetainerDetailsInputSchema, } from "@powerhousedao/network-admin/document-models/payment-terms";
+import { reducer, utils, isPaymentTermsDocument, setBasicTerms, updateStatus, setTimeAndMaterials, setEscrowDetails, setEvaluationTerms, SetBasicTermsInputSchema, UpdateStatusInputSchema, SetTimeAndMaterialsInputSchema, SetEscrowDetailsInputSchema, SetEvaluationTermsInputSchema, } from "@powerhousedao/network-admin/document-models/payment-terms";
 describe("TermsOperations", () => {
     it("should handle setBasicTerms operation", () => {
         const document = utils.createDocument();
@@ -22,13 +22,13 @@ describe("TermsOperations", () => {
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
-    it("should handle setCostAndMaterials operation", () => {
+    it("should handle setTimeAndMaterials operation", () => {
         const document = utils.createDocument();
-        const input = generateMock(SetCostAndMaterialsInputSchema());
-        const updatedDocument = reducer(document, setCostAndMaterials(input));
+        const input = generateMock(SetTimeAndMaterialsInputSchema());
+        const updatedDocument = reducer(document, setTimeAndMaterials(input));
         expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("SET_COST_AND_MATERIALS");
+        expect(updatedDocument.operations.global[0].action.type).toBe("SET_TIME_AND_MATERIALS");
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
@@ -52,14 +52,4 @@ describe("TermsOperations", () => {
         expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
         expect(updatedDocument.operations.global[0].index).toEqual(0);
     });
-    it("should handle setRetainerDetails operation", () => {
-        const document = utils.createDocument();
-        const input = generateMock(SetRetainerDetailsInputSchema());
-        const updatedDocument = reducer(document, setRetainerDetails(input));
-        expect(isPaymentTermsDocument(updatedDocument)).toBe(true);
-        expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("SET_RETAINER_DETAILS");
-        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
-        expect(updatedDocument.operations.global[0].index).toEqual(0);
-    });
 });