@dmptool/types 1.0.8 → 1.1.1

package/dist/questions/__tests__/dateQuestions.spec.js

@@ -6,6 +6,8 @@ describe("DateQuestion", () => {
         const validDate = {
             type: "date",
             attributes: {
+                label: "Date",
+                help: "Enter a date",
                 max: "2023-12-31",
                 min: "2023-01-01",
                 step: 1,
@@ -47,28 +49,18 @@ describe("DateRangeQuestion", () => {
             type: "dateRange",
             columns: {
                 start: {
-                    type: "date",
-                    attributes: {
-                        label: "Start Date",
-                        max: "2023-12-31",
-                        min: "2023-01-01",
-                        step: 1,
-                    },
-                    meta: {
-                        schemaVersion: "1.0"
-                    }
+                    label: "Start Date",
+                    help: "Enter a date",
+                    max: "2023-12-31",
+                    min: "2023-01-01",
+                    step: 1,
                 },
                 end: {
-                    type: "date",
-                    attributes: {
-                        label: "End Date",
-                        max: "2023-12-31",
-                        min: "2023-01-01",
-                        step: 1,
-                    },
-                    meta: {
-                        schemaVersion: "1.0"
-                    }
+                    label: "End Date",
+                    help: "Enter a date",
+                    max: "2023-12-31",
+                    min: "2023-01-01",
+                    step: 1,
                 },
             },
             meta: {
@@ -82,62 +74,16 @@ describe("DateRangeQuestion", () => {
             type: "dateRange",
             columns: {
                 start: {
-                    type: "date",
-                    attributes: {
-                        label: "Start Date",
-                        max: "2023-12-31",
-                        min: "2023-01-01",
-                        step: 1,
-                    },
-                    meta: {
-                        schemaVersion: "1.0"
-                    }
+                    label: "Start Date",
+                    max: "2023-12-31",
+                    min: "2023-01-01",
+                    step: 1,
                 },
                 end: {
-                    type: "date",
-                    attributes: {
-                        label: 123, // Invalid type for label
-                        max: "2023-12-31",
-                        min: "2023-01-01",
-                        step: 1,
-                    },
-                    meta: {
-                        schemaVersion: "1.0"
-                    }
-                },
-            },
-            meta: {
-                schemaVersion: "1.0"
-            }
-        };
-        expect(() => dateQuestions_1.DateRangeQuestionSchema.parse(invalidDateRange)).toThrow();
-    });
-    it("should require labels for start and end dates", () => {
-        const invalidDateRange = {
-            type: "dateRange",
-            columns: {
-                start: {
-                    type: "date",
-                    attributes: {
-                        max: "2023-12-31",
-                        min: "2023-01-01",
-                        step: 1,
-                    },
-                    meta: {
-                        schemaVersion: "1.0"
-                    }
-                },
-                end: {
-                    type: "date",
-                    attributes: {
-                        label: "End Date",
-                        max: "2023-12-31",
-                        min: "2023-01-01",
-                        step: 1,
-                    },
-                    meta: {
-                        schemaVersion: "1.0"
-                    }
+                    label: 123, // Invalid type for label
+                    max: "2023-12-31",
+                    min: "2023-01-01",
+                    step: 1,
                 },
             },
             meta: {

package/dist/questions/__tests__/graphQLQuestions.spec.js

@@ -19,6 +19,8 @@ const graphQLQuestions_1 = require("../graphQLQuestions");
                 ],
             },
             attributes: {
+                label: "Search",
+                help: "Search for a user",
                 multiple: true,
             },
             meta: {
@@ -53,6 +55,10 @@ const graphQLQuestions_1 = require("../graphQLQuestions");
     (0, globals_1.it)("should validate a correct TypeaheadSearchQuestion object", () => {
         const validData = {
             type: "typeaheadSearch",
+            attributes: {
+                label: "Search",
+                help: "Search for a user",
+            },
             graphQL: {
                 displayFields: [
                     { propertyName: "title", label: "Title" },

package/dist/questions/__tests__/numberQuestions.spec.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const numberQuestions_1 = require("../numberQuestions");
+describe("Number Questions Zod Schemas", () => {
+    it("should validate a valid CurrencyQuestion", () => {
+        const validCurrencyQuestion = {
+            type: "currency",
+            meta: {
+                schemaVersion: "1.0",
+                denomination: "USD",
+            },
+            attributes: {
+                max: 100,
+                min: 1,
+                step: 0.01,
+            },
+        };
+        expect(() => numberQuestions_1.CurrencyQuestionSchema.parse(validCurrencyQuestion)).not.toThrow();
+    });
+    it("should invalidate an invalid CurrencyQuestion", () => {
+        const invalidCurrencyQuestion = {
+            type: "currency",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                max: "100", // Invalid type
+            },
+        };
+        expect(() => numberQuestions_1.CurrencyQuestionSchema.parse(invalidCurrencyQuestion)).toThrow();
+    });
+    it("should validate a valid NumberQuestion", () => {
+        const validNumberQuestion = {
+            type: "number",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                max: 100,
+                min: 0,
+                step: 1,
+            },
+        };
+        expect(() => numberQuestions_1.NumberQuestionSchema.parse(validNumberQuestion)).not.toThrow();
+    });
+    it("should invalidate an invalid NumberQuestion", () => {
+        const invalidNumberQuestion = {
+            type: "number",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                step: "1", // Invalid type
+            },
+        };
+        expect(() => numberQuestions_1.NumberQuestionSchema.parse(invalidNumberQuestion)).toThrow();
+    });
+    it("should validate a valid NumberRangeQuestion", () => {
+        const validNumberRangeQuestion = {
+            type: "numberRange",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                label: "Range",
+                help: "Enter a range"
+            },
+            columns: {
+                start: {
+                    label: "Start",
+                    help: "Enter a starting number",
+                    min: 0,
+                    max: 50,
+                    step: 1,
+                },
+                end: {
+                    label: "End",
+                    help: "Enter an ending number",
+                    min: 50,
+                    max: 100,
+                    step: 1,
+                },
+            },
+        };
+        expect(() => numberQuestions_1.NumberRangeQuestionSchema.parse(validNumberRangeQuestion)).not.toThrow();
+    });
+    it("should invalidate an invalid NumberRangeQuestion", () => {
+        const invalidNumberRangeQuestion = {
+            type: "numberRange",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            columns: {
+                start: {
+                    min: 0,
+                    max: 50,
+                },
+                end: {
+                    label: "End",
+                    min: 50,
+                    max: "100",
+                    step: 1,
+                },
+            },
+        };
+        expect(() => numberQuestions_1.NumberRangeQuestionSchema.parse(invalidNumberRangeQuestion)).toThrow();
+    });
+});

package/dist/questions/__tests__/optionBasedQuestions.spec.js

@@ -2,25 +2,73 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const globals_1 = require("@jest/globals");
 const optionBasedQuestions_1 = require("../optionBasedQuestions");
+(0, globals_1.describe)("BooleanQuestion", () => {
+    (0, globals_1.it)('optional fields should not throw an error if the value is undefined', () => {
+        const validBooleanQuestion = {
+            type: "boolean",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                checked: undefined, // Valid value
+            },
+        };
+        (0, globals_1.expect)(() => optionBasedQuestions_1.BooleanQuestionSchema.parse(validBooleanQuestion)).not.toThrow();
+    });
+    (0, globals_1.it)('optional fields should throw an error if the value is null', () => {
+        const invalidBooleanQuestion = {
+            type: "boolean",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                checked: null, // Invalid value
+            },
+        };
+        (0, globals_1.expect)(() => optionBasedQuestions_1.BooleanQuestionSchema.parse(invalidBooleanQuestion)).toThrow();
+    });
+    (0, globals_1.it)("should validate a valid BooleanQuestion", () => {
+        const validBooleanQuestion = {
+            type: "boolean",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                checked: true,
+            },
+        };
+        (0, globals_1.expect)(() => optionBasedQuestions_1.BooleanQuestionSchema.parse(validBooleanQuestion)).not.toThrow();
+    });
+    (0, globals_1.it)("should invalidate an invalid BooleanQuestion", () => {
+        const invalidBooleanQuestion = {
+            type: "boolean",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                checked: "true", // Invalid type
+            },
+        };
+        (0, globals_1.expect)(() => optionBasedQuestions_1.BooleanQuestionSchema.parse(invalidBooleanQuestion)).toThrow();
+    });
+});
 (0, globals_1.describe)("CheckboxesQuestion", () => {
     (0, globals_1.it)("should validate a valid CheckboxesQuestion object", () => {
         const validCheckboxesQuestion = {
             type: "checkBoxes",
+            attributes: {
+                label: "Fruits",
+                help: "Select all fruits you like",
+            },
             options: [
                 {
-                    type: "option",
-                    attributes: {
-                        label: "Apple",
-                        value: "apple",
-                        checked: true,
-                    },
+                    label: "Apple",
+                    value: "apple",
+                    checked: true,
                 },
                 {
-                    type: "option",
-                    attributes: {
-                        label: "Banana",
-                        value: "banana",
-                    },
+                    label: "Banana",
+                    value: "banana",
                 },
             ],
             meta: {
@@ -32,14 +80,15 @@ const optionBasedQuestions_1 = require("../optionBasedQuestions");
     (0, globals_1.it)("should throw an error for an invalid CheckboxesQuestion object", () => {
         const invalidCheckboxesQuestion = {
             type: "checkBoxes",
+            attributes: {
+                label: "Has an apple?",
+                help: "Whether or not you have an apple in your fridge.",
+            },
             options: [
                 {
-                    type: "option",
-                    attributes: {
-                        label: "Apple",
-                        value: "apple",
-                        checked: "true", // Invalid type for checked
-                    },
+                    label: "Apple",
+                    value: "apple",
+                    checked: "true", // Invalid type for checked
                 },
             ],
             meta: {
@@ -53,21 +102,19 @@ const optionBasedQuestions_1 = require("../optionBasedQuestions");
     (0, globals_1.it)("should validate a valid RadioButtonsQuestion object", () => {
         const validRadioButtonsQuestion = {
             type: "radioButtons",
+            attributes: {
+                label: "Fruits",
+                help: "Select all fruits you like",
+            },
             options: [
                 {
-                    type: "option",
-                    attributes: {
-                        label: "Male",
-                        value: "male",
-                        selected: true,
-                    },
+                    label: "Male",
+                    value: "male",
+                    selected: true,
                 },
                 {
-                    type: "option",
-                    attributes: {
-                        label: "Female",
-                        value: "female",
-                    },
+                    label: "Female",
+                    value: "female",
                 },
             ],
             meta: {
@@ -81,12 +128,9 @@ const optionBasedQuestions_1 = require("../optionBasedQuestions");
             type: "radioButtons",
             options: [
                 {
-                    type: "option",
-                    attributes: {
-                        label: "Male",
-                        value: "male",
-                        selected: "true", // Invalid type for selected
-                    },
+                    label: "Male",
+                    value: "male",
+                    selected: "true", // Invalid type for selected
                 },
             ],
             meta: {
@@ -100,26 +144,22 @@ const optionBasedQuestions_1 = require("../optionBasedQuestions");
     (0, globals_1.it)("should validate a valid SelectBoxQuestion object", () => {
         const validSelectBoxQuestion = {
             type: "selectBox",
+            attributes: {
+                label: "Fruits",
+                help: "Select all fruits you like",
+                multiple: true,
+            },
             options: [
                 {
-                    type: "option",
-                    attributes: {
-                        label: "USA",
-                        value: "usa",
-                        selected: true,
-                    },
+                    label: "USA",
+                    value: "us",
+                    selected: true,
                 },
                 {
-                    type: "option",
-                    attributes: {
-                        label: "Canada",
-                        value: "canada",
-                    },
+                    label: "Canada",
+                    value: "ca",
                 },
             ],
-            attributes: {
-                multiple: true,
-            },
             meta: {
                 schemaVersion: "1.0"
             }
@@ -132,12 +172,9 @@ const optionBasedQuestions_1 = require("../optionBasedQuestions");
             questionText: "Select your country",
             options: [
                 {
-                    type: "option",
-                    attributes: {
-                        label: "USA",
-                        value: "usa",
-                        selected: "true", // Invalid type for selected
-                    },
+                    label: "USA",
+                    value: "us",
+                    selected: "true", // Invalid type for selected
                 },
             ],
             attributes: {

package/dist/questions/__tests__/tableQuestion.spec.js

@@ -20,6 +20,8 @@ describe("TableQuestionSchema", () => {
                     content: {
                         type: "number",
                         attributes: {
+                            label: "Age",
+                            help: "Enter your age",
                             min: 18,
                             max: 65,
                             step: 1,

package/dist/questions/__tests__/textQuestions.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/questions/__tests__/textQuestions.spec.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const textQuestions_1 = require("../textQuestions");
+describe("Primitive Questions Zod Schemas", () => {
+    it("should validate a valid EmailQuestion", () => {
+        const validEmailQuestion = {
+            type: "email",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                label: "Email",
+                help: "Enter your email address",
+                maxLength: 50,
+                minLength: 5,
+                multiple: true,
+                pattern: "^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$",
+            },
+        };
+        expect(() => textQuestions_1.EmailQuestionSchema.parse(validEmailQuestion)).not.toThrow();
+    });
+    it("should invalidate an invalid EmailQuestion", () => {
+        const invalidEmailQuestion = {
+            type: "email",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                maxLength: "50", // Invalid type
+            },
+        };
+        expect(() => textQuestions_1.EmailQuestionSchema.parse(invalidEmailQuestion)).toThrow();
+    });
+    it("should validate a valid TextAreaQuestion", () => {
+        const validTextAreaQuestion = {
+            type: "textArea",
+            meta: {
+                schemaVersion: "1.0",
+                asRichText: true,
+            },
+            attributes: {
+                label: "Description",
+                help: "Enter a description of your project",
+                cols: 30,
+                rows: 5,
+                maxLength: 500,
+                minLength: 10,
+            },
+        };
+        expect(() => textQuestions_1.TextAreaQuestionSchema.parse(validTextAreaQuestion)).not.toThrow();
+    });
+    it("should invalidate an invalid TextAreaQuestion", () => {
+        const invalidTextAreaQuestion = {
+            type: "textArea",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                cols: "30", // Invalid type
+            },
+        };
+        expect(() => textQuestions_1.TextAreaQuestionSchema.parse(invalidTextAreaQuestion)).toThrow();
+    });
+    it("should validate a valid TextQuestion", () => {
+        const validTextQuestion = {
+            type: "text",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                label: "Name",
+                help: "Enter your name",
+                maxLength: 100,
+                minLength: 1,
+                pattern: "^[a-zA-Z]+$",
+            },
+        };
+        expect(() => textQuestions_1.TextQuestionSchema.parse(validTextQuestion)).not.toThrow();
+    });
+    it("should invalidate an invalid TextQuestion", () => {
+        const invalidTextQuestion = {
+            type: "text",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                maxLength: "100", // Invalid type
+            },
+        };
+        expect(() => textQuestions_1.TextQuestionSchema.parse(invalidTextQuestion)).toThrow();
+    });
+    it("should validate a valid URLQuestion", () => {
+        const validURLQuestion = {
+            type: "url",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                label: "URL",
+                help: "Enter a URL",
+                maxLength: 200,
+                minLength: 10,
+                pattern: "https?://.+",
+            },
+        };
+        expect(() => textQuestions_1.URLQuestionSchema.parse(validURLQuestion)).not.toThrow();
+    });
+    it("should invalidate an invalid URLQuestion", () => {
+        const invalidURLQuestion = {
+            type: "url",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                maxLength: "200", // Invalid type
+            },
+        };
+        expect(() => textQuestions_1.URLQuestionSchema.parse(invalidURLQuestion)).toThrow();
+    });
+});